How to Turn a Screen Recording Into a GIF (Mac, Linux, Online)

Turning a screen recording into a GIF is easy; turning it into a GIF that is small and still sharp takes three decisions: frame rate, width and palette. This guide gives the settings we use, our free in-browser converter, the ffmpeg command for Mac, Linux and Windows, the free desktop apps, how to shrink a GIF that is still too big, and when you should not make a GIF at all.

The settings that decide size

A GIF stores every frame as an indexed image with at most 256 colours and only simple compression between frames. So its size grows with the number of frames, the number of pixels per frame and how much of the picture changes. The settings below are our starting points for screen recordings; we tested them with ffmpeg and our own converter.

Size targets by destination

These are our rules of thumb, not platform limits. Where a platform has a hard upload limit, check its current documentation, because those change.

Method 1: in the browser, no upload

Evidence: tested by us (we built it). Our free MP4 to GIF converter runs entirely in your browser tab. It reads an MP4, WebM or MOV file, steps through it frame by frame, builds a 256-colour palette for each frame and writes the GIF with JavaScript. The file is never uploaded, so there is no queue, no size-based pricing, no sign-up and no watermark.

Its fixed limits, so you know what you get:

• It converts the first 30 seconds of the file.
• Output is up to 720 px wide at 12 fps; smaller sources keep their size.
• There are no trim, crop or frame-rate controls, so trim the video to the part you want first.
• The browser has to be able to decode the file; H.264 MP4, WebM and most MOV files work.

Many other online converters upload your video to their servers to process it. That is fine for public content, but think twice with an unreleased product or anything showing customer data. We explain how ZoomCap handles files on the security page.

Method 2: export GIF straight from ZoomCap

If you want zooms, a background or a smoother cursor in the GIF, export it from the recorder instead of converting the raw capture. Evidence: tested by us. ZoomCap's editor exports GIF alongside MP4 (up to 4K). The GIF goes through the same renderer as the MP4, so zooms, cursor, background and trims all match, and it is capped at 15 fps and 960 px wide to keep a 20-second clip in the tens of megabytes rather than hundreds. For a README, trim to under 10 seconds or pass the result through gifsicle (below).

You can record in the free browser recorder (Chrome or Edge, any OS, zooms placed by hand) or with npx zoomcap record on macOS and Linux X11, which zooms in automatically on your clicks and typing. Everything is edited and encoded on your computer; nothing is uploaded. The free plan includes 2 exports a month with a small watermark; Pro and Lifetime ($29 once (or $12.49/month)) remove the watermark and the cap. It has no frame-rate or palette controls for GIF; if you need those, export an MP4 and use ffmpeg.

Method 3: ffmpeg (Mac, Linux, Windows)

Evidence: tested by us. If you need full control over every setting, ffmpeg is free and gives you that. Install it with brew install ffmpeg on a Mac, your package manager on Linux (for example sudo apt install ffmpeg), or a build linked from ffmpeg.org on Windows.

The command

ffmpeg -ss 2 -t 8 -i recording.mp4 \
  -vf "fps=12,scale=800:-1:flags=lanczos,split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle" \
  -loop 0 demo.gif

What each part does:

• -ss 2 -t 8: start 2 seconds in and take 8 seconds. Trimming first is the biggest single saving.
• fps=12: 12 frames per second. Use 8–10 for terminal demos.
• scale=800:-1:flags=lanczos: 800 px wide, height to match, with a sharp scaling filter that keeps text legible.
• split[a][b]: sends the frames down two paths, one to build the palette and one to apply it, so it all runs in one command.
• palettegen=stats_mode=diff: builds a 256-colour palette from the clip, weighting the parts that change. That favours the moving interface over a static background.
• paletteuse=dither=bayer:bayer_scale=5: ordered dithering that compresses well. Try dither=none for flat interfaces with no gradients.
• diff_mode=rectangle: only re-encodes the rectangle that changed between frames, which suits screen recordings where most of the screen is still.
• -loop 0: loop forever.

Cropping to the part that matters

Add a crop before the scale. crop=w:h:x:y takes the width and height of the area, then its top-left corner in the source pixels:

ffmpeg -ss 2 -t 8 -i recording.mp4 \
  -vf "crop=1440:900:0:60,fps=12,scale=800:-1:flags=lanczos,split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle" \
  -loop 0 demo.gif

This one drops a 60-pixel strip from the top (a browser tab bar, say) of a 1440-wide recording. On Windows, run the same commands in PowerShell, replacing each trailing backslash with a backtick, or put the command on one line.

Method 4: gifski for gradient-heavy clips

Evidence: from the project's documentation. gifski is a free, open-source encoder that builds an efficient palette for each frame and dithers across frames, so gradients, photos and anti-aliased text look noticeably better than with a single palette. The tradeoff is size: its GIFs are often larger than ffmpeg's at the same width and frame rate. Install it with brew install gifski on a Mac, or from the project site on Linux and Windows.

The route that works with every build is to export frames with ffmpeg, then encode them:

mkdir frames
ffmpeg -ss 2 -t 8 -i recording.mp4 -vf "fps=12,scale=800:-1:flags=lanczos" frames/f%04d.png
gifski --fps 12 --width 800 --quality 80 -o demo.gif frames/f*.png

--quality runs from 1 to 100; lowering it trades detail for size. Some gifski builds also accept a video file directly in place of the frames.

Method 5: desktop apps (Gifski, ScreenToGif)

• Mac: Gifski. The same gifski encoder with a drag-and-drop window, free on the Mac App Store. Drop in a screen recording, set width, frame rate and quality, and export. (From the project's site; not something we tested for this post.)
• Windows: ScreenToGif. A free, open-source app that records a region of the screen and opens it in a frame editor, where you can delete frames, crop and add text, then save as a GIF (or a video). (From the project's site.)
• Linux: record with ZoomCap's CLI on X11 and export the GIF from the editor (Method 2), or record with your usual tool and convert with Method 1, 3 or 4.

Still too big? Shrink it

In order of how much they save:

1. Trim. Cut the pauses before and after the action.
2. Crop to the region that changes.
3. Lower the frame rate to 10, or 8 for text.
4. Reduce the width by 100–200 px.
5. Turn dithering off for flat UI (dither=none).
6. Run gifsicle, a free GIF optimiser, with lossy compression and fewer colours:

gifsicle -O3 --lossy=80 --colors 128 demo.gif -o demo-small.gif

-O3 is its strongest lossless optimisation; --lossy (higher is smaller and noisier) and --colors trade quality for size. Install with brew install gifsicle or your Linux package manager. Check the result at 100% zoom: small text is the first thing to suffer.

Record with a GIF in mind

The cheapest bytes are the ones you never record.

• Record a small window, around 1280×800, rather than a full Retina display. Text stays readable after scaling down to 800 px.
• Use a plain background and a flat theme. Gradients, wallpapers, shadows and video content eat palette colours.
• Move the cursor deliberately and pause for a beat after each action. Fast cursor movement adds changed pixels to every frame.
• Hide what moves but doesn't matter: a blinking clock, a spinner, an animated avatar.
• For terminal demos, a text-based recorder may beat a GIF entirely; see asciinema vs VHS vs real video.

When not to make a GIF

GIF is the most compatible animated format, and the least efficient. Use a video instead when the destination can play one:

• Web pages: a muted, looping MP4 in a <video> tag autoplays in modern browsers and is usually a fraction of the size. Our website demo video guide has the embed code.
• GitHub: READMEs and issues can show uploaded MP4 or MOV videos with a player. GIF still wins when you want it to autoplay inline.
• Social and chat: X, LinkedIn, Slack and Discord play MP4 files natively.
• Long clips: anything over about 15 seconds is almost always better as video.

For the MP4 settings, see our MP4 vs MOV vs WebM guide. If the GIF looks blurry however you convert it, the problem is usually in the recording; our 12 fixes for blurry screen recordings cover the causes.

Frequently asked questions

Want the zoom and framing done for you before the GIF? Record free in ZoomCap's browser recorder and export a GIF or MP4, or get unlimited watermark-free exports and the CLI with automatic zoom for $29 once on the pricing page. Already have the video? The MP4 to GIF converter is free.