OpenFilm: an open source video agent with a real editor

The pitch in three phrases

The README states the idea in a line, one HTML file, one function, one real editor, and each phrase carries a decision. The HTML file is the film, a folder containing a page called film.html in which tracks of clips are cut together, so the artefact is something an agent can write with the same fluency it has for any other web page, and nothing new has to be learned. The function is the drawing primitive, because each shot is a page that can draw any moment of itself through a single function, and the README is explicit that this is not a framework, that there is no template project to fill in and no component model to adopt, and that anything a browser can draw is fair game, from canvas and SVG to WebGL, CSS animation, video and more. The editor is the third phrase, because an agent that produces a video you cannot change is a demo, and Studio is a real editor that runs on your machine.

The file format, and how a shot is placed

A film is a folder, and inside it the sections of the page are the tracks of the timeline, in the order the timeline shows them with the first on top. A clip is an element, and it can be a page, a video, a still picture or a sound, and every sound is a clip of its own. The markup is deliberately plain:

<section>
  <video src="assets/footage.mp4#t=12,18" at="4" speed="0.5" class="card" style="left: 160px; top: 90px; width: 1600px; height: 700px"></video>
</section>

The fragment on the source selects which part of the file plays, the attribute says where the clip starts on the timeline, the style says where it sits and how big it is, and the class and the stylesheet decide how it looks. The pieces fit together the way ordinary HTML does, which is the point. A separate mechanism holds the changes a person makes, so an agent editing the same film later keeps the human adjustments instead of overwriting them.

The one rule, and why it exists

Each page exports an object with a function that draws the complete picture at a given moment, and the contract has a single hard requirement: the same moment must always draw the same picture, whatever was drawn before it. The reason is stated plainly, and it is a good one. The renderer asks for frames out of order, in parallel, and between frames when motion blur is enabled, so a page that keeps state, or that depends on a previous frame, will render differently depending on the order the machine happened to ask, and will render differently on another machine. The optional properties of the object cover the rest, a duration for a page that has its own length, a promise for fonts, images, models and data, and a width and height for a page that is only part of the picture. The README is clear that the alternatives, Python, Blender, a video model, come in as video or images rather than as live drawing.

Where the effort goes: checking the film

The most interesting sentence in the README says that OpenFilm spends its effort where models fail, which is checking the film. The command that does it is called look, and its approach is unusually direct. It draws every frame of the contact sheet twice, in two shuffled orders, and then names any frame that changed between the two passes, which is exactly the symptom of a page that broke the determinism rule. The same pass reports the other things that go wrong in practice, page errors, fonts that failed to load, sound files that are missing, and text that is cut off by the frame boundary. A model will happily produce a film that renders, and occasionally produce one that renders differently depending on when you ask, and this command is the mechanism for noticing. It is a small idea with a large payoff, and it is the piece of the project worth copying even if you use a different renderer.

Studio, and why the preview can be trusted

Studio runs in your browser on your machine, and the README is explicit about the browser it wants, one built on Chromium such as Chrome or Edge, because that is the engine the films are drawn and exported with, and therefore the preview is what you export. Everything in the film can be changed, the text and the layers inside a picture, the clips on the timeline, their position, their look, their volume and their speed, and the subtitles. The changes are written back into the film's files, so the agent sees them and keeps them on its next edit, and named versions can be saved to go back to. The export list is long, video, a GIF, the sound or its stems, subtitles, stills, slides, a transparent video, and the timeline itself in a form that Final Cut Pro, Premiere Pro and DaVinci Resolve can open, which is a thoughtful answer to the question of what to do with a film after you are happy with it.

Commands, providers and the agent contract

The command line is small and its design goal is that an agent can drive it. Running the tool with no arguments prints a manual that the agent then reads, and the manual is the same file in the repository, so the instructions the model works from are the instructions you can read. The other commands cover opening a film, checking it, rendering it with options for 4K output, motion blur and transparency, fetching generated media, and a doctor command that reports what the machine has available, which is designed to be pasted into a bug report. Generated voice, music, images and video are not included: you connect the services you use, with your own keys, in the settings. The project is also distributed as a skill through a package manager command, and a desktop application wraps Studio with a chat beside it for the agents you already have.

Where the approach strains, and the state of the project

The limitations follow from the design. Everything is rendered by a browser, so the output depends on a headless Chromium and on the fonts that happen to be installed, and the tool is honest that a font failing to load is one of the things it checks for. Motion blur asks for frames between frames, which multiplies the work and multiplies the chances of hitting a page that is not deterministic. The model does not create the footage, so the media comes from your own accounts and your own keys, and the tool is a compositor and an editor rather than a generator. The format is young as well, with the releases at 0.2.0, 0.2.1 and 0.2.2 in the space of three days in October 2026, and the mitigation is that a specification is published for anyone who wants to build their own player, renderer or editor. From source the requirements are Node 22.18 or later, pnpm 9, ffmpeg and git, and the repository is a pnpm workspace with the package, the desktop application, the skills and the scripts, a changelog driven by changesets, and a set of audit scripts for the published surface.

Editorial conclusion

OpenFilm fits a team that already uses a coding agent and wants it to produce a launch film or a demo video with the same tooling it uses for code, and it fits a motion designer who wants to hand-edit the result rather than prompt for it again. It does not fit a pipeline that expects the model to generate the footage, because the media comes from your own provider keys, and it does not fit a project that cannot accept a Chromium-based rendering step. Before adopting it, read the specification and try the look command on a film you make yourself, because the determinism rule is the whole contract and a page that breaks it will not fail loudly.

Frequently asked questions

Official sources

1. License: MIT
2. openfilm/openfilm on GitHub
3. Project website
4. README
5. Releases