Video editing is the hardest app to reimplement because it is really three apps stacked: an editing database, a media decoder zoo, and a rendering engine. FilmCraft, from the ArtCraft family on getartcraft.com, takes all three head-on in pure Rust. It is a clean-room reimplementation of the Adobe Premiere Pro workflow in the storytold/filmcraft repository, version 0.5.0 under MIT OR Apache-2.0, and the headline fact is on its formats page: no FFmpeg inside. The H.264, HEVC, ProRes, DNxHD/DNxHR, AV1, AAC and Opus decoders, plus the containers they ship in, are all written from the public ITU-T, ISO and IETF specifications in this one workspace, and tested frame by frame against ffmpeg purely as an external oracle. unsafe_code = "forbid" applies across the workspace.

The second headline is timing. Every edit in FilmCraft is computed on integer ticks, 254,016,000,000 per second, a rate chosen because it divides evenly by every common frame rate and audio sample rate, so 23.976 and 29.97 drop-frame are exact rather than approximate. The third is that every menu item, button, slider and drag is a command with an id, typed parameters and an enabled state; there are more than 650 of them, dispatched through one Session::execute entry point that the egui UI, the CLI, a JSON control channel, and an MCP server all share. The documentary cuts and grades shown in the project README were built by an agent driving the running app, command by command.

The overview: all frontends enter through the engine, which edits the project copy-on-write; the edit algebra rewrites sequences in exact tick time; two compositors share the same semantics; and agents use the same commands you do.

Reading the overview from left to right:

• The desktop app in apps/filmcraft/src, the CLI in apps/filmcraft-cli/src, and the WebAssembly build in apps/filmcraft-web are three shells over one core; the UI itself is a swappable crate, crates/ui-egui/src.
• The engine in crates/engine/src holds the registry, undo, jobs, autosave and the session; the project is an Arc<Project> edited copy-on-write, so undo keeps whole-project snapshots cheaply through structural sharing.
• The timeline layer spans crates/project/src, crates/edit/src, crates/time/src, crates/format/src and crates/interchange/src.
• Rendering pairs the CPU reference compositor in crates/render/src with a wgpu GPU compositor in crates/gpu/src that samples YUV straight from the decoder and blends in linear light.
• The media layer is the codec zoo: crates/codecs/src dispatching into h264, hevc, prores, av1, vp9, aac, opus and the isobmff, matroska, mxf and mpegts containers, all under crates/bitstream/src.
• The automation layer in crates/automation/src exposes the same commands over MCP and JSON lines.

Why You Need This

First, the editing model is algebra you can trust. The edit crate in crates/edit/src documents Premiere’s semantics precisely: overwrite replaces whatever is under the new item; insert pushes material right on target tracks and every sync-locked, unlocked track; lift leaves a gap and extract closes it; ripple delete fails if a sync-locked track would lose sync. Every function validates first, or works on a clone, leaving the sequence untouched on error, and tests check that track items never overlap. On top of that sit the trims pros live in, ripple, roll, slip, slide and rate stretch, plus dynamic trimming that trims live during playback and commits as one undo step, and three-point editing with insert and overwrite onto patched tracks.

Second, your timelines are not hostages. crates/interchange/src moves edits between FilmCraft and every other NLE through Final Cut Pro 7 XML, the format Premiere and Resolve exchange, FCPXML 1.9 through 1.11, OpenTimelineIO with round-tripping through its metadata, CMX 3600 EDL with drop-frame timecode and M2 speed changes, AAF Edit Protocol for Media Composer and Pro Tools, and OMF 2.0 for audio post. Import merges bins, media and sequences into your project as one undoable step and relinks each file it finds on disk. Combined with its own project format in crates/format/src, atomic saves, a rolling auto-save set, and a crash-recovery journal written about a second after each edit, the storage story is designed against lock-in and data loss at the same time.

Third, the whole NLE is agent-drivable at three levels. Through the control channel or MCP, an agent issues commands like timeline.place with source in-points expressed in ticks, sets Lumetri parameters per clip, or takes a screenshot to see the result; every widget also has an automation id, so an agent can click, drag and type like a person; and filmcraft-cli commands lists the entire command catalogue. For developers the same discipline pays off differently: crates/render/src renders monitors, thumbnails and exports from one code path and serves as the oracle that the GPU path in crates/gpu/src is tested against, while the codec crates are validated bit-exactly against conformance streams, H.264 on 37-plus, HEVC on 41, VP9 on 50-plus, and AV1 bit-exact with libdav1d on the libaom vectors.

The detail view: commands dispatch into clip operations, the timeline crates carry tick math and interchange, the render layer spans compositing, text, captions and DSP, and the codec zoo feeds the frame buffers.

The detail diagram repays study in the render layer, which is really four subsystems. Compositing: crates/render/src evaluates a sequence bottom track to top, applying per-item effects, then fixed Motion and Opacity transforms, then blending transitions. Graphics: crates/text/src is a real text engine with OpenType shaping, kerning, ligatures, and bidirectional text, drawn in linear light and sharp at any scale. Captions: crates/captions/src handles SRT, WebVTT and SCC with frame-exact timing and CEA-608, CEA-708 and Teletext track types, burnable into exports. Audio: crates/audio-dsp/src provides the parametric EQ, dynamics, true-peak limiter, reverb and DeHummer behind mixer effects that stay continuous across scrubbing, playback and export with latency compensated, plus ITU-R BS.1770 and EBU R128 loudness meters whose integrated reading matches ffmpeg’s ebur128 filter to a tenth of a LU.

The media layer is where the clean-room claim gets teeth. crates/codecs/src routes media to decoders built on crates/bitstream/src and container parsers like crates/isobmff/src with fragmented MP4, edit lists and timecode tracks; crates/frame/src holds the YUV and linear float buffers; crates/media/src manages probing, relinking and low-resolution proxies; and crates/speech/src is the optional, off-by-default speech-to-text that can feed captions. On output, crates/export/src runs background jobs with progress and cancel, and caches rendered previews by content so an edit only invalidates what it touches.

From Install to First Cut

Get started with cargo run --release -p filmcraft for the desktop app with a demo project, or cargo run --release -p filmcraft -- --control 9876 to also open the JSON-lines control server; the workspace needs Rust 1.95 or newer on edition 2024. List the whole command surface with cargo run --release -p filmcraft-cli -- commands, and serve MCP headless with cargo run --release -p filmcraft-cli -- mcp. A first agent session can place a clip with timeline.place, grade it by setting Lumetri parameters, add a cross dissolve, and export an H.264 MP4 with the project’s own encoder, checking the result with ui.screenshot. Interchange works in both directions: export your sequence as OpenTimelineIO, hand it to Resolve, and import an AAF back with embedded audio extracted.

Honest limits: the roadmap tracks the feature checklist at about 87 percent of Premiere and readiness for real work at 50 to 60 percent. Speed on big footage is the main gap, Lumetri, keys and export rendering still run on the CPU while blend modes and common effects run on the GPU; H.264 is the only software delivery-codec export, with HEVC export hardware-only; there is no plugin hosting for VST3, Audio Units or OpenFX; and wild camera files are less tested than conformance streams. Even so, the foundation is unusual in the field: bit-exact own codecs, exact time, one command surface for humans and agents, and timelines that leave whenever you ask.

Enjoyed this post? Never miss out on future posts by following us