Rotate GIF

Turn an animated GIF upright, mirror it, or tilt it by a few degrees, without turning it into a still image or changing how fast it plays.

1. 1

   Add your GIF

   Drag an animated GIF onto the drop area, or click to browse. Animated WebP and APNG work too. The file is read on your device and never uploaded.

2. 2

   Turn it

   Press rotate left or rotate right for a quarter turn, or pick 90, 180 or 270 directly. Add a mirror if the picture is also the wrong way round. The preview turns with you.

3. 3

   Tilt it, if you need to

   The fine angle slider adds up to 45 degrees either way on top of the quarter turn. Anything other than a quarter turn grows the canvas and leaves new corners, so choose whether those are see-through, white or black.

4. 4

   Rotate and download

   Press Rotate, then Download. Each frame's delay, the loop count and any transparency come through unchanged, so the animation plays exactly as it did — just the right way up.

Most rotations are corrections rather than choices. A clip recorded on a phone held sideways arrives sideways, because the orientation lived in a tag the capture app wrote and the export threw away. A screen recording from a rotated monitor comes out on its side. A GIF pulled from a video shot in portrait plays back on its back. And a surprising number of animations are simply mirrored — grabbed from a front-facing camera, where the preview you were watching was a reflection of you and the file is not. None of that is an artistic decision, and none of it should cost you a re-export.

Turn or mirror an animated GIF without losing a pixel, tilt it by any angle with see-through corners, and keep every frame's timing and the loop count exactly as they were.

Reads GIF, animated WebP and APNG. Writes a standard GIF89a with per-frame delays, loop count and transparency preserved.

What a turn is actually for

• Orientation, fixed at the file. A GIF has no orientation tag that renderers honour, so a sideways animation is sideways everywhere — in a README, in a chat client, in a slide. Turning the pixels is the only fix that travels with the file.
• Mirrored footage, un-mirrored. Front-facing camera captures are reflections. Text in them runs backwards and anything asymmetric reads wrong, and no amount of rotation corrects it — only a flip does.
• A straighter picture. A photographed screen or a hand-held capture is usually a degree or two off level. A small fine-angle turn is the difference between a clip that looks captured and one that looks made.
• Fitting a shape. A portrait animation turned landscape fills a wide slot instead of sitting in two grey bars. With the canvas held at its original size, the turn happens inside the shape the destination already expects.

Rotation is not one thing. It is two operations that behave completely differently, and almost every tool in this category presents them as a single control — which is how a 90-degree turn ends up being run through machinery designed for 37 degrees, softening every edge in a file for no reason at all. This tool keeps them apart, tells you which one you are in, and does not let the expensive one contaminate the cheap one.

A quarter turn and a mirror cost nothing

Turning by 90, 180 or 270 degrees, or mirroring left-to-right or top-to-bottom, moves each pixel to a different position on the grid. No pixel is averaged with a neighbour, none is invented, none is discarded. The set of colours in the file is therefore exactly what it was — and because the palette is built from a count of those colours, the palette that comes out is bit-identical to the one this same file would get with no rotation at all. Every pixel then maps to the same palette entry it would have mapped to. That is what "lossless" means here, and it is measured rather than claimed: the turned frame is compared pixel for pixel against an independent image library performing the same turn, and against a separate integer calculation of where each pixel should have landed, and both agree at zero difference out of 255.

The detail that decides it

The cosine of 90 degrees, computed the obvious way, is not zero — it is about 6 followed by seventeen zeros, and then a 1. Build a rotation from that number and every pixel lands a vanishing fraction off the grid, which a graphics pipeline resolves by interpolating between neighbours. The picture looks identical. Any check with a tolerance passes. And the operation is quietly no longer a permutation: edges are softened, the colour set has changed, and the palette is no longer the one the unrotated file would have. The four right angles here carry exact whole-number values instead, and smoothing is switched off for them, so there is no path by which a quarter turn can resample.

Any other angle resamples, and grows

A fractional angle puts the picture on a grid it does not line up with, so each output pixel is a blend of the source pixels near it. That is unavoidable and it is what makes a tilted picture look smooth rather than jagged. It also grows the canvas: the smallest upright rectangle containing a turned rectangle is bigger than either. A 200 by 100 frame turned 30 degrees needs 223 by 187 — more than twice the pixels — and the difference between the two shapes is the corners, which is where this category actually fails.

A rotated rectangle never covers its own bounding box. Turn a square by 45 degrees and exactly half of the output was never part of the picture. Something has to be there, and what most tools put there is white.

• White is a decision, not a default. On an animation with a transparent background, white corners are four triangles that were not in your file and cannot be removed afterwards. On a dark animation they are a bright frame. Neither is what was asked for.
• Cropping instead loses the corners. The other common answer is to hold the original canvas and let the turned picture overflow, which quietly cuts the four corners of the actual picture. That can be the right choice — it is offered here as Keep original size — but it should be a choice.
• See-through is the honest default. The new area is left transparent unless you say otherwise, so the corners are absent rather than invented. White and black are one press away when the destination needs an opaque file.

How this is actually tested

This matters because the wrong test is indistinguishable from no test. A tool in this repository once checked that the corners after a straightening rotation were opaque — which a white fill satisfies perfectly — and the check sat green while every angle above 10 degrees exported visible white triangles covering 5.9% of the image. The assertion was pointed at a property that could not be wrong. Here the corners are read on the alpha channel, which is the only reading that can tell a see-through corner from a white one, on a fully opaque source so that any transparency in the output must have come from the rotation. The same check is then run with the fill set to white and is required to fail, because an assertion that cannot go red is not an assertion.

One limitation that belongs to the format

GIF stores transparency as a single palette slot rather than as an alpha channel, so a pixel is either fully see-through or fully opaque. That means the diagonal edge of a tilted picture is stair-stepped rather than feathered, and there is nothing any tool can do about it inside the format. Two practical consequences: a tilted animation on a busy background reads better with a solid corner colour than with transparency, and a solid colour also produces a smaller file, because transparency and the frame-to-frame optimisation both need the one reserved palette slot and cannot both have it.

Once the picture no longer fits its frame, there are only two honest answers, and this tool offers both rather than choosing for you.

• Grow to fit. The canvas expands to the smallest upright rectangle that holds the turned picture. Nothing is cut. This is the default and it is what every other tool does, silently.
• Keep original size. The canvas holds the source's own width and height and the turned picture is centred inside it — overhang is cut, shortfall is padded. This is what you want when the result has to go back into a slot of a fixed shape, and we could not find it offered anywhere else.
• Which one is lossless. Grow to fit keeps a quarter turn lossless, because every pixel still has somewhere to go. Keep original size on a non-square frame does not, because a 300 by 100 picture turned upright cannot fit in a 300 by 100 box. The tool says which you are in rather than leaving you to work it out.

Why the numbers swap

A quarter turn exchanges the two axes, so a 300 by 100 animation becomes 100 by 300. That is not a side effect to be corrected; it is what a quarter turn is. It is worth mentioning because it is the easiest thing in this whole tool to test badly: a square input hides it completely, and a rotator that silently did nothing at all would pass every check performed on a square. The result line shows both sizes so the swap is visible, and the file's dimensions are read back out of the finished GIF rather than taken on trust.

Rotating a still image is one transform and one draw. An animated GIF is a stack of frames, and the format makes almost every assumption you would like to make about them false. A frame is not necessarily the size of the animation: it is legally a smaller rectangle at an offset, storing only the region that changed since the last one. Each frame carries a disposal method saying what to do with the previous frame before drawing it. Each may declare its own transparent colour, and each may carry its own palette. A rotator that turns those stored fragments and puts them back at their old offsets produces output that flickers, ghosts, or places half the animation in the wrong corner.

What happens to each frame here

• Composite. Every frame is drawn onto a canvas of the animation's logical size, honouring its offset, its disposal method and its transparency, so what gets turned is the picture a viewer would actually see rather than the fragment the file happened to store.
• Turn, once. The mirror, the rotation and the plan's size ceiling are one transform applied in a single draw on your graphics hardware. Doing them as separate passes would resample two or three times where one is enough.
• Re-quantise. A palette is built from a sample spread across the whole animation, not from the first frame, then every pixel is mapped to it. Building it per frame is what makes colours shift visibly between frames in other tools — and for a quarter turn this step provably changes nothing at all.
• Re-optimise. Unchanged regions between frames are marked transparent again at the new geometry. This is where most of a GIF's size comes from, and it is what stops a turn making the file needlessly bigger.

When the dithering control disappears, and why

Ordered dithering nudges each pixel by an amount that depends on where it is, which is what breaks up banding in a reduced palette. It is hidden in two situations, and both are cases where it would do damage rather than good. On a quarter turn, that position dependence is fatal: the same colour at a new position would be nudged differently and could land on a different palette entry, so a turn that changed nothing would come out having changed something — and there is nothing to dither anyway, because no approximation is being made. With a solid corner fill, it textures the fill: measured on a tilted animation with a white surround, a small sample of what was supposed to be flat white held three different greys, because the softened boundary between the fill and the picture puts near-white shades in the palette for the dithering to land on. A colour you chose should come out as that colour, so dithering is switched off wherever the fill is solid and the control is not offered there.

Almost every real rotation is one of four cases, and knowing which one you are in saves the guesswork.

• Sideways phone footage. A quarter turn, one direction or the other. If you are not sure which, turn once and look at the preview — it costs nothing and nothing is written until you press Rotate.
• Upside down. 180 degrees. Note that 180 and a double mirror look identical on a symmetric picture and are different operations on everything else; if text appears, only 180 keeps it readable.
• Selfie-camera mirroring. A horizontal flip, with no rotation at all. Backwards text is the reliable tell.
• A crooked capture. A fine angle of one to four degrees, with Keep original size if the small crop is acceptable and Grow to fit if it is not. This is the only case where the cost is real, and at those angles it is not visible.

By material

• Screen recordings. Quarter turns only, if you can. Interface edges are the crispest thing in any capture and a fractional angle softens all of them at once.
• Pixel art and sprites. Quarter turns are exact on a pixel grid and fractional angles destroy it. If you must tilt pixel art, use the Pixel resample mode, which keeps hard edges instead of blending them.
• Photographic clips. A fractional angle is fine here — a photograph has no grid to break. Smooth resampling is the right choice, and it is the default.
• Anything with transparency. Keep the corner fill see-through, or the transparent background gains four opaque triangles the moment you leave a quarter turn.

• Documentation and READMEs. A capture from a rotated monitor is unreadable in a document and a quarter turn fixes it permanently, in the file, without a re-recording.
• Chat and social posts. No chat client offers a rotate button on an animation it is displaying. The orientation has to be right in the file before it is sent.
• Slides and presentations. Slide software can rotate a placed image on screen, but the exported PDF or video often bakes in the original. Turning the file first removes the question.
• Mirrored camera captures. Anything recorded from a front-facing camera is reversed. A flip is the only correction, and it is free.

What the swap does to your dimensions

Plan for the swap before you turn. A 1080 by 1920 portrait animation becomes 1920 by 1080 landscape, which is the shape a feed wants but four times the width of a chat column. Discord and Slack custom emoji are 128 by 128, so a quarter turn of a square is free and of anything else changes what fits. GitHub's README column is about 700 pixels in practice. X renders inline images up to 506 pixels wide. If a turn takes you past those, the resizer is the next stop and it is one link away.

Four things go wrong with rotated GIFs often enough to be worth naming, and all four have a cause rather than a mystery. None of them is your file being broken.

• It came back as a still picture. The tool read the first frame and discarded the rest. Almost every general-purpose image editor does this to an animation, silently, because it was built for pictures and a GIF is a valid picture to it. The frame count is on the result line here, so you can see it survived rather than hoping.
• There are white triangles in the corners. The angle was not a multiple of 90, the canvas grew, and something had to go in the new area. Choose the see-through corner fill, or a colour that matches your destination. A quarter turn has no new area at all.
• It plays at the wrong speed now. The delays were flattened to one average value, or dropped and replaced with a default frame rate. GIF delays are per frame and routinely irregular; a tool that assumes a constant rate produces a valid file that plays wrong. Compare the total duration before and after — this tool prints both.
• The file is much bigger than it was. Either the canvas grew, which is unavoidable at a fractional angle, or the frame-to-frame optimisation was lost. Transparency and that optimisation compete for the same reserved palette slot, so a see-through corner fill costs bytes; a solid one does not.

Flicker and ghosting, and why there is no setting for it here

One more failure is specific to animations that use frame differencing, where each frame stores only what changed since the last. Turn those stored fragments and put them back at their old offsets and you get fragments of earlier frames scattered through the result. The best-known editor in this category ships a manual three-way engine switch and a help page explaining that its fast default breaks such files, that the slower one works but removes all optimisation and produces larger files, and that the third has worse quality. That is three ways to be wrong presented as a choice. Here every frame is composited onto the full canvas before anything is turned, so there is no fast-but-wrong path to offer and nothing to switch between.

The input list is closed and enforced at the file dialog rather than at the engine, so a file this tool cannot open is refused in milliseconds with a route to the tool that can — instead of being accepted and failing later behind a spinner.

• GIF in. Animated or single-frame, interlaced or not, with a global palette or a different local palette on every frame. Sub-rectangle frames at an offset are composited onto the full canvas before anything is turned.
• Animated WebP and APNG in. Both are read by our own demuxers on every browser rather than by a native decoder, so frames and timing are identical everywhere.
• GIF out, always. A standard GIF89a with a global colour table, per-frame delays, disposal methods and a loop extension carrying the source's own loop count.
• Anything else is refused with a route. A video is sent to Video to GIF, a still photo to the GIF Maker. Neither is described as an error with your file, because it is not one.

What the tool reads

GIF is decoded natively where the browser has a decoder for it and by our own reader everywhere else, so an animation opens the same way on every engine rather than arriving as its first frame. Animated WebP and APNG always take our own reader, which is what keeps frame counts and timing identical across engines. One detail worth naming: the native decoder reports a loop-forever GIF's repeat count as infinity, which is not a number a GIF file can store — it is translated back to zero, the format's own encoding of forever, rather than written out as whatever the arithmetic produced.

Size and batch limits

• Free. One file up to 50 MB and up to 300 frames, output up to 2048 pixels on the long edge. Full quality, and every control on this page — the free plan is not a reduced-quality rotation, it is a single-file one.
• Pro. Up to 20 files at once, downloaded as one ZIP, with no imposed dimension cap. Batch is what Pro buys here, because turning a folder of clips one at a time is the actual chore.
• The limit both plans share. Every frame is expanded to full colour while it is being worked on, so a memory budget bounds the job before it starts rather than letting the tab stop responding while the progress ring keeps turning.

Nothing is uploaded. The file is decoded frame by frame on your machine, each frame is composited and turned by a single transform, a palette is built across the whole animation, unchanged regions are marked transparent again, and the result is written out as a standard GIF89a. All of it runs in a background thread so the page stays responsive, and the turn itself runs on your graphics hardware where it is available.

Why the same file rotates identically every time

• A deterministic quantiser. Median cut, not the randomised neural quantiser most GIF libraries use, so the same input with the same settings always produces byte-identical output.
• Identical results on every path. The graphics-accelerated and processor paths are required to produce the same bytes, not merely similar ones — a path choosing a different palette entry would show as colour flicker between frames.
• Geometry checked against another implementation. The turn is compared pixel for pixel against an independent image library performing the same turn, and against a separate integer calculation of where each pixel should land. Two answers agreeing is evidence; one answer agreeing with itself is not.

What a rotator must not change

Four things have to come out exactly as they went in: each frame's own delay, the total playback time, the loop count, and which pixels are transparent. A tool that re-times an animation while rotating it produces a perfectly valid GIF that simply plays at the wrong speed; one that flattens transparency produces a picture with a box around it; one that defaults the loop count turns a three-play animation into an endless one. All four are measured on every run here rather than assumed, and the numbers are on the result line so you can read them.

Measured results

• Quarter-turn accuracy Zero. The largest per-channel difference between our turn and an independent image library performing the same turn is 0 out of 255, on every quarter turn and both mirrors — an equality rather than a tolerance, because a permutation resamples nothing.
• Round trip Four quarter turns return the original pixels exactly, and 180 degrees applied twice does the same. Both at 0 out of 255.
• The corners At 45 degrees, 50% of the output is fill and all four corners read alpha 0 — see-through, not white. The same check with the fill set to white is required to fail, and does.
• Speed 100 frames of 480 by 270 turned a quarter in 256 ms; the same file at an arbitrary angle in 692 ms.

Quarter turns and mirrors are exact pixel permutations, verified at zero difference against an independent image library and against a separate integer calculation. Rotation is hardware accelerated where your device supports it, and the accelerated and fallback paths produce byte-identical output. Measured on the reference device: 100 frames of 480 by 270 turned in 256 ms. It all runs on your device, not our servers.

• GIF Cropper
• GIF Resizer
• GIF Compressor
• Rotate Image
• Rotate Video
• All GIF tools