🪼 Aether Renderer Core

Turn a folder (or zip) of transparent PNG frames into a WebM, MOV, GIF or MP4, with the transparency intact.

Exported an animation from Blender, After Effects, a canvas or an AI tool as a PNG sequence and need it on a website, in a video editor or in a chat? One command:

aether-renderer-core -i frames/ -o animation.webm

Project page · Download · GUI app · Changelog

✨ Features

• 🫧 Transparent output in WebM (VP9), MOV (ProRes 4444) and GIF; MP4 for when you don't need alpha
• 📦 Frames from a folder or a ZIP (macOS __MACOSX / ._ files are skipped)
• 🔢 Frames in natural order: frame_2.png comes before frame_10.png, with or without zero padding
• 🌗 Fade in / fade out that fades to transparent (or to your background color), not to black
• 🎨 Background color (--background '#1e1e1e') to flatten transparency onto a solid color, for any format
• 📊 Real progress: a frame counter with --verbose, JSON lines with --progress json, and a callback for library users
• 🎛️ Options on the command line, in a JSON or TOML config, or both (the command line wins)
• 🖼️ Preview a single frame without rendering
• 💻 macOS, Linux and Windows, with prebuilt binaries
• 🦀 Also a Rust library: the Aether Renderer GUI is built on it

Which format should I use?

The format is taken from the output file name (-o loop.gif renders a GIF), or set it with --format.

MP4 can't store transparency, so transparent areas become black. To match the page or video the clip will sit on, give it that color: --background '#1e1e1e'. The same flag works for every format and makes the output opaque; fades then go to that color.

Safari does not play transparent WebM. For transparent video on Safari, use a GIF, or serve a HEVC-with-alpha version next to the WebM (on the roadmap).

📦 Install

You need ffmpeg on your PATH:

brew install ffmpeg            # macOS
sudo apt install ffmpeg        # Ubuntu / Debian
winget install Gyan.FFmpeg     # Windows

Then either download a binary from Releases (macOS Apple Silicon and Intel, Linux, Windows), or install with Cargo:

cargo install aether-renderer-core

🔧 Usage

# folder of PNGs -> transparent WebM at 30 fps
aether-renderer-core -i frames/ -o out.webm

# from a zip, as a GIF at 24 fps
aether-renderer-core -i frames.zip -o out.gif --fps 24

# for a video editor, with a soft 1 second fade in and out
aether-renderer-core -i frames/ -o out.mov --fade-in 1 --fade-out 1

# higher quality WebM (lower crf = better, default 30)
aether-renderer-core -i frames/ -o out.webm --crf 20

# only some files, or a numbered sequence
aether-renderer-core -i renders/ -o scene1.webm --file-pattern 'scene1_*.png'
aether-renderer-core -i renders/ -o out.webm --file-pattern 'frame_%04d.png'

# check a frame first: saves the middle frame (or frame 12) as out.png
aether-renderer-core -i frames/ -o out.webm --preview
aether-renderer-core -i frames/ -o out.webm --preview 12

All options

If ffmpeg fails, the error shows ffmpeg's own explanation, and no half-written file is left behind.

Progress for other programs

With --progress json, every line on stdout is a JSON object, so a GUI or script can draw its own progress bar:

{"event":"progress","frame":0,"total_frames":360,"percent":0.0}
{"event":"progress","frame":96,"total_frames":360,"percent":26.67}
{"event":"progress","frame":360,"total_frames":360,"percent":100.0}
{"event":"done","output":"out.webm","frames":360,"warnings":[],"notes":"Video render complete."}

On failure the last line is {"event":"error","message":"..."} and the exit code is 1. Progress comes from ffmpeg about twice a second. GIFs need every frame before they can be written, so their progress mostly jumps to 100% at the end.

Config files

Every option can live in a .json or .toml file; anything you also pass on the command line overrides the file. Handy for keeping a project's settings next to its frames:

# render.toml
input = "frames"
output = "loop.webm"
fps = 24
fade_in = 0.5
fade_out = 0.5
crf = 24
background = "#1e1e1e"   # optional

aether-renderer-core --config render.toml
aether-renderer-core --config render.toml --fps 60 -o draft.mov   # override

The same in JSON: examples/example_config.json. Relative paths are relative to the folder you run the command from.

🦀 As a library

[dependencies]
aether-renderer-core = "0.6"

use aether_renderer_core::config::PartialConfig;

let cfg = PartialConfig {
    input: Some("frames".into()),
    output: Some("out.webm".into()),
    fps: Some(24),
    ..Default::default()
}
.into_config()?;

let report = aether_renderer_core::render(cfg)?;
println!("{}", report.summary());

For a progress bar, use render_with_progress:

let report = aether_renderer_core::render_with_progress(cfg, |p| {
    println!("{:.0}% ({}/{} frames)", p.percent, p.frame, p.total_frames);
})?;

RenderConfig::from_file("render.toml") loads a config file, and aether_renderer_core::preview_frame extracts a single frame.

🧪 Development

cargo test                      # ffmpeg tests are skipped when ffmpeg is missing
cargo clippy --all-targets -- -D warnings
cargo fmt

The tests render real transparent, odd-sized frames to every format and check the result with ffprobe: size, frame rate, codec and alpha. CI runs them on Linux, macOS and Windows.

Benchmark

A single frame duplicated N times, rendered to WebM:

Measured with 0.4 (VP8). 0.5 uses VP9, which in our tests takes about 20% longer and gives files about 40% smaller at better quality.

🪼 Aether Renderer GUI

Prefer drag and drop? The Aether Renderer GUI is a desktop app built on this crate.

Download the installer from the GUI releases.

📦 Example frames

Try it with sacred-stars.zip:

aether-renderer-core -i sacred-stars.zip -o stars.webm

🔮 Roadmap

• WebM with alpha, MP4, GIF
• Bitrate / CRF quality control, fades
• Preview a single frame
• GUI version with Tauri
• ProRes 4444 MOV, TOML config, config + CLI override, Windows-safe input (0.5)
• Background color for any format, real progress bar and --progress json (0.6)
• Safari-ready transparent video (HEVC with alpha) and a --format web that writes both
• Resize and crop (--width, --height)
• Frames from stdin, for piping from canvas and AI tools

Ideas and bug reports are welcome in issues.

🌿 License & author

MIT. Built and maintained by Mads Paaskesen, Hardcore Websmith at MP-IT, with 💛 from Sacred-AI.

Need custom rendering pipelines, video automation or a Rust/Node.js backend? Get in touch.