Screen Recording to GIF

100%

Screen Recording to GIF

✓ Published0🌍 Public

Last edited Apr 16, 2018

Created on Sep 4, 2015

This example demonstrates a command-line workflow for converting a QuickTime screen recording into an optimized GIF. It first uses ffmpeg to extract frames at 24 fps, then ImageMagick’s `convert` to build a palette from the first frame, remap all frames with `-remap` for color reduction, and finally gifsicle with `--optimize=3` to compress the output. A resize option via gifsicle shows how to scale the final image, while the code notes alternative tools like LICEcap and the trade-offs of uploading MOV files to Twitter.

AI-generated description

If you haven’t already: brew install ffmpeg gifsicle imagemagick.
Open QuickTime Player.
File > New Screen Recording.
Record.
Save as recording.mov.

    ffmpeg -i recording.mov -r 24 recording-%03d.png &&
    convert recording-001.png palette.gif && 
    convert -dither none -remap palette.gif recording-*.png recording-uncompressed.gif &&
    gifsicle --optimize=3 --delay=4 < recording-uncompressed.gif > recording.gif

To resize:

gifsicle recording.gif --resize 375x375 > 375.gif

licecap is also nice, but you don't have control over the framerate. mov files can now be directly uploaded to twitter, but can get downsampled pretty aggressively. asdf

Similar vizzes

Loading thumbnail…

Screen Recording to GIF

This example shows how to convert a screen recording into an animated GIF using command-line tools. It first generates a color palette from the video with FFmpeg’s `palettegen` filter, then applies that palette with `paletteuse` to produce a high-quality GIF. The workflow also supports optional frame dropping via `fps` and cropping through FFmpeg’s `crop` filter. The code relies solely on FFmpeg and Gifsicle, with QuickTime Player used for the initial recording.

Mmbostock

89% match

Loading thumbnail…

Gist 57367d54143770b7c1d534cbfe002cd9

This example shows a Python script that combines multiple video clips into a single montage, resizing each to a fixed 460×720 resolution and concatenating them in sequence. The code uses MoviePy’s `VideoFileClip`, `concatenate_videoclips`, and `write_videofile` functions, along with its `vfx` module for potential filters. It saves the final output with a timestamped filename and writes it as an MP4 using the H.264 codec. The rendering approach relies on MoviePy’s FFmpeg backend, processing clips in sequential order without additional data sources.

CConorAspell

59% match

Loading thumbnail…

Bash script to process frames and convert then to a video format with ffmpeg

This example demonstrates how to assemble a sequence of numbered JPEG frames into a single video file. It relies on the Bash script to orchestrate the conversion, calling ffmpeg with a specified framerate of 30 frames per second. The command uses the libx264 codec with high profile settings, a constant rate factor of 18, and the yuv420p pixel format to ensure broad compatibility. The input pattern `path_to_file_%04d.jpeg` indicates that frames are named with four-digit zero-padded numbers, which ffmpeg then reads sequentially to produce the final `output.mp4`.

LLuisSevillano

58% match

Loading thumbnail…

Gist 86435

This example demonstrates a command-line tool for capturing full-page screenshots of websites using MacRuby and WebKit. It shows a configurable web capture system that loads a URL, optionally resizes the viewport, waits for a specified delay, and saves the rendered page as a PNG. The code relies on the WebKit framework’s WebView and frame load delegation, alongside NSBitmapImageRep to rasterize the view’s content. Users specify options like width, height, output filename, and delay via Ruby’s OptionParser.

CCaged

58% match

Loading thumbnail…

Generate a MP4 Video for your Git project commits using Gource!

This example generates a video of a Git project’s commit history as an animated tree visualization. Gource parses the repository’s log data and renders contributors, files, and directories as moving nodes and edges against a black background. The output, at 1920×1080 resolution, is piped as a PPM stream from Gource into ffmpeg, which encodes it as an H.264 MP4 file using the libx264 codec with ultrafast preset and a constant rate factor of 1. A secondary ffmpeg pass compresses the result into a smaller `reposm.mp4` file.

FFrozenfire92

55% match

Loading thumbnail…

Gist de36ebb099ca71e1ac63f67335f7e71e

This example shows an automated pipeline that fetches the most popular Twitch clips of the week, concatenates them into a single video, and uploads the result to Streamable and Reddit. It uses the Twitch Kraken API to retrieve clip metadata and download the actual video files, then MoviePy to resize and concatenate the clips with a fixed intro. The script relies on the `requests` library for HTTP calls, `praw` for Reddit posting, and the `pystreamable` API for uploads. Environment variables supply authentication keys and configuration, while the final video is saved with a timestamped filename before being shared.

CConorAspell

54% match

Loading thumbnail…

Twitter video handbrake settings

This visualization shows the exact encoding settings used in a HandBrake preset named “Twitter,” displaying the video and audio parameters as a structured plist. It maps the key-value pairs from the XML Property List file, including H.264 video encoding, 128 kbps AAC audio, 1280×720 resolution at 30 fps, and specific x264 options like the “fast” preset and “fastdecode” tune. The code parses the plist using Apple’s PropertyList API and renders the hierarchical dictionary as an interactive tree diagram with collapsible nodes.

MMattieTK

54% match

Loading thumbnail…

Gist 77c69eeb802c8bd617a1f30df0f71e93

This example shows an automated video-pipeline system that fetches video content, edits it, and distributes the result to multiple platforms. The code’s main script orchestrates three distinct stages: retrieving source videos via `get_videos`, processing them through `edit_video`, and finally uploading the finished output—first to Streamable through `upload_to_streamable` and then to Reddit via `upload_to_reddit`. No visualization libraries are used; instead, the concrete APIs are the custom modules `get_videos`, `edit_videos`, and `upload_video`, which handle data acquisition, editing logic, and remote uploads. The gist demonstrates a file-based workflow, with no graphical rendering or interactive charts.

CConorAspell

53% match