How to Use OpenFilm: The Beginner’s Guide (Skill Install, First Film, Studio Edits, and the Export Arc)
CodexFuse Team · 2026-11-02T13:39:09.747Z · 15 min read min read
OpenFilm is the open-source AI video agent that turns a coding agent’s prompt into a film made of animated web pages. This beginner’s guide covers the skill install, your first film from one prompt, hand-editing in OpenFilm Studio, provider media, and the export arc to MP4 or an NLE timeline.
What Is OpenFilm, Exactly?
Learning how to use OpenFilm starts with one idea: OpenFilm is the open-source AI video agent that turns a coding agent's prompt into a finished film — and the film is made of animated web pages you can hand-edit afterward. You describe the film to your agent (Claude Code, Codex, Cursor, or any other), the agent builds it, and you open it in the Studio editor to tweak text, clips, timing, volume, and subtitles before exporting. If you searched "openfilm tutorial" or "how to use openfilm", you are in the right place: this guide covers the October-2026 open-source AI video agent at openfilm.dev — not the old indie-film sites that share the name (more on that collision below).
The numbers tell you how fast this is moving: the GitHub repository (github.com/openfilm/openfilm, fetched for this guide on November 2, 2026) carries about 4,225 stars and 402 forks, was created October 4, 2026, and was last pushed October 31. It launched on Show HN on October 19, 2026 alongside v0.2.1/v0.2.2 (my2cents.ai), and the latest release tracked by ossradar's November-1 snapshot is v0.2.7 — treat that version number as a moving target and check the releases page at write time. The license is MIT: "The format, the CLI, Studio and the desktop app are MIT. The OpenFilm name and logo are trademarks." Because the whole flow runs through a coding agent, our Claude Code beginner guide is the natural companion to this page — Claude Code is one of the vendor's two named agents.
The mental model that makes OpenFilm click is its name: a film is literally a folder of web pages. One film.html cuts tracks of clips together; each shot is a web page that exposes a function called frame(t); and the one rule of the whole system is that "the same t always draws the same picture, whatever was drawn before" — frames get requested out of order and in parallel, so any single frame renders independently. That rule is what makes the AI-generated output deterministic and hand-editable instead of the black-box render you get from a video diffusion model.
How Does the Film-as-Web-Pages Model Actually Work?
The short answer: a film is a folder containing film.html, tracks are HTML <section> elements (the first one sits on top), and each clip is an element — a page, a video, a still picture, or a sound. Which part of a clip plays is a media fragment like #t=12,18, its start offset is the at attribute, and its position comes from ordinary CSS left/top/width/height. There is no proprietary project format; if you know web pages, you already know the film format.
The frame(t) contract is the clever part. Because "the same t always draws the same picture, whatever was drawn before", the renderer can request frame 3,412 without rendering 3,411 first — frames come out in any order, in parallel, and any frame can be re-rendered alone. That is why a hand-edit to one shot never requires re-rendering the whole film, and why the agent can fix a single scene without touching the rest. Compare that with a diffusion-video pipeline, where changing one frame means re-running the model.
| Concept | What it is in OpenFilm | Beginner's reading |
|---|---|---|
| Film | A folder containing film.html | Open the folder, you own the film — no lock-in |
| Track | A <section> in film.html; first on top | Like tracks in an NLE, just HTML |
| Clip | A page, video, still, or sound element | Which part plays = #t=12,18 fragment |
| Shot | A web page exposing frame(t) | Same t, same picture — always |
| Timing | at start offset + CSS position | When it starts, where it sits |
That table is your Rosetta stone for the rest of this guide. Every Studio control and every export option is just a friendly handle on one of these five concepts.
How Do You Use OpenFilm, Step by Step?
There is no simpler answer to "how to use openfilm" than this sequence. Follow it in order and you will have generated, edited, and exported your first AI-made film in well under an hour.
- Install the skill. Run
npx skills add openfilm/openfilmin your terminal. If your agent has no skills support, tell it: runnpx -y openfilm@latestand follow the manual it prints. - Check the requirements. You need Node 22.2+ and ffmpeg on macOS, Windows, or Linux; git is needed for Studio's saved versions; the first run downloads a headless Chromium (about 100 MB). There is also a desktop app for macOS and Windows from openfilm.dev or GitHub Releases that bundles ffmpeg and the headless browser — nothing else to install.
- Start a film from one prompt. Ask your agent to make a film, or point the CLI at the vendor's example:
npx -y openfilm@latest open https://github.com/openfilm/examples/tree/main/one-prompt. - Preview in Studio. Open the film in Studio — the editor shows the timeline of tracks and clips from the film.html you just generated.
- Hand-edit everything. Change text and layers in the picture, move clips on the timeline, adjust place, look, volume and speed, and fix the subtitles. Edits save back to the film's files, so your agent sees and keeps them; save named versions for rollback.
- Bring in media and export. Use
openfilm getto pull voice-over, music, SFX, transcripts, images, or video from your own providers, thenopenfilm renderto export MP4, GIF, stems, subtitles, stills, or a timeline for a pro editor.
What Does Your Machine Need Before You Install?
The answer depends on which door you walk through: the agent path, the from-source path, or the desktop app. The vendor's README (github.com/openfilm/openfilm, fetched November 2, 2026) is precise about all three, and installing the wrong door's requirements is the classic beginner stall.
| Path | Requirements | Best for |
|---|---|---|
| Agent skill | Node 22.2+, ffmpeg, git (for saved versions); first run downloads ~100 MB headless Chromium | Most beginners — the agent does the work |
| From source | Node 22.18+, pnpm 9, ffmpeg, git | Contributors and tinkerers |
| Desktop app | macOS or Windows; bundles ffmpeg + headless browser — nothing else to install | Non-terminal users who want Studio + chat side by side |
Two details beginners miss: first, git is not optional if you want saved versions — Studio's rollback feature leans on it, so our Git beginner guide pays for itself on day one. Second, there is a second skill pack worth grabbing: npx skills add openfilm/skills installs workflow and style briefs for different kinds of films (the vendor's skills repo at github.com/openfilm/skills, fetched this run) — quick starts per film type, not full walkthroughs. Think of the OpenFilm skills collection as per-genre briefs that keep your agent's output on-format.
How Do You Start a Film From a Single Prompt?
The answer: tell your coding agent what film you want, in plain words, and let it write the web pages. The agent builds the folder, writes film.html with tracks and clips, wires each shot's frame(t), and you preview the result in Studio. The vendor's one-prompt example (npx -y openfilm@latest open https://github.com/openfilm/examples/tree/main/one-prompt) is the fastest way to see the whole arc without writing anything yourself.
This is the part that feels like magic and isn't: the agent is not hallucinating video frames. It is writing code — HTML, CSS, and JavaScript that draw the shot for any value of t. Because of the determinism rule, the film it generates is inspectable, debuggable, and editable with the same tools you use on a website. When the agent's first draft has a shot you hate, you do not re-roll a model — you hand-edit the shot in Studio, or tell the agent to change the code.
Which Coding Agent Should You Use With OpenFilm?
The vendor names Codex and Claude Code, and says any coding agent that can run a command works; the desktop app's chat works with Claude Code, Codex, other agents, or its own agent with your key. The wider ecosystem list (opensourcealternatives.to, updated October 30, 2026) adds Cursor, GitHub Copilot, Gemini CLI, OpenCode, Windsurf, Cline, Amp, and Devin — so you are almost certainly already set up. If Cursor is your daily driver, our Cursor AI beginner guide gets you to a working agent in minutes.
The practical rule: pick the agent you already trust, not the one with the most stars. The skill teaches any of them the OpenFilm brief; what matters is that you are comfortable reviewing the files it writes, because reviewing the generated film.html is how you learn the format — and learning the format is what makes Studio editing feel natural later.
What Can You Change by Hand in Studio?
The short answer: everything — and OpenFilm Studio is where you do it. Text and layers in the picture, clips on the timeline, their place, look, volume and speed, subtitles — all of it is editable, and edits save back to the film's files so your agent sees and keeps them. That last clause is the whole point of the workflow: the Studio is not a separate app that exports a flat video for you to annotate; it edits the same files the agent wrote, so the agent's next prompt works from your corrected film, not from its own first draft.
Two Studio features deserve special attention. Named versions let you save checkpoints of a film for rollback — paired with git, this is a real version history for video. And openfilm look checks the film by rendering a contact sheet and reporting which frames changed between two shuffled renders — a determinism check that catches the exact class of bug (t-dependent randomness) that the frame(t) rule exists to prevent. Beginners should run it after every batch of hand-edits; a clean look means your edits obeyed the one rule.
Where Do the Voice-Over, Music, and Images Come From?
The answer, stated plainly by the vendor: the generated media is NOT made by OpenFilm. You connect your own provider keys — ElevenLabs, OpenAI, Google, fal — in Studio under Settings → Providers, and the openfilm get command pulls voice-over, music, SFX, transcripts, images, or video through them. Making, editing, and rendering a film needs no OpenFilm account; only the third-party media you choose to pull costs whatever that provider charges.
This is a feature disguised as a limitation. It means your voice stays with the voice provider you picked, your music licensing stays with you, and OpenFilm never becomes the middleman that bills you for a render. The beginner mistake is assuming the skill handles media — it does not; plan your provider keys (and their costs) before you need a narrator.
What Can You Export From a Finished Film?
The answer: a video (MP4), a GIF, the sound or its stems, subtitles, stills, slides, a transparent video (WebM or MOV with alpha), or the timeline itself for Final Cut Pro, Premiere Pro, and DaVinci Resolve. Render flags include --4k for resolution and --blur for motion blur. The export list is unusually wide because the source material is code: a transparent background is a CSS choice, not a chroma-key hack, and the NLE timeline export means a film you started with a prompt can finish in a professional editing suite.
| Export | What it gives you | Reach for it when |
|---|---|---|
| MP4 | The finished video (--4k for resolution) | Publishing anywhere |
| GIF | A looping clip | Previews, socials, docs |
| Stems / subtitles | Sound tracks and subtitle files | Remixing audio or accessibility |
| Stills / slides | Frozen frames, slide decks | Thumbnails, pitch decks |
| Transparent video | WebM/MOV with alpha channel | Compositing over other footage |
| NLE timeline | Timeline for Final Cut Pro, Premiere Pro, DaVinci Resolve | Hand-finishing in a pro editor |
The NLE timeline export is the beginner's safety net: if Studio ever can't do the edit you want, the film's timeline opens in the same editors professionals use every day. You are never locked into OpenFilm's tooling — the files are yours and the formats are standard.
OpenFilm vs VEED OpenEdit: What's the Real Difference?
The short answer to every openfilm vs veed open-edit search: different products in the same agent-native video category — say the distinction once and move on. VEED's OpenEdit (veed.io/tools/openedit, fetched this run) is an open-source editor under Apache-2.0 that your AI agent runs, but its renderer — VEED Engine — is closed source under PolyForm Shield 1.0.0 (you can sell what you make at no cost to VEED), with an option to render through Chrome instead. It installs as npx skills add veedstudio/open-edit, is agent-agnostic (tested with Claude Code, Codex, Gemini), runs on Apple-Silicon Macs on macOS 26 only, and is in beta. OpenFilm is fully MIT — the format, the CLI, Studio, and the desktop app — with the trademark on the name and logo. Same lane, different trade: OpenEdit gives you a big company's renderer with closed bits; OpenFilm gives you a fully open stack built on web pages.
One more disambiguation for searchers, said once: the OpenFilm name collides with older independent-film products — Openfilm.com (a video-sharing site and festival database that closed in August 2015), the Open Film Festival, and Open Film Zone. None of them is this product. This article is about the October-2026 open-source AI video agent.
7 Mistakes Beginners Make With OpenFilm
The answer to "why is my film broken" is usually one of these seven — each is a beginner trap with a one-line fix.
| Mistake | Why it breaks | The fix |
|---|---|---|
| Non-deterministic shot code | Violates "same t, same picture" — frames differ between renders | Run openfilm look after edits; keep frame(t) pure |
| Wrong Node version | Needs Node 22.2+ (agent path) or 22.18+ (from source) | Check node -v before installing |
| Skipping git | Named versions need git for saved versions | Install git first — see our Git guide linked above |
| Assuming media is included | OpenFilm makes no voice/music/images itself | Add provider keys in Studio → Settings → Providers |
| Editing the export, not the film | Edits to a rendered MP4 never reach the agent | Edit in Studio; edits save back to the film's files |
| Ignoring the Chromium download | First run fetches ~100 MB headless Chromium | Let it finish; or use the desktop app that bundles it |
| Forgetting the second skill pack | Generic prompts give generic films | Run npx skills add openfilm/skills for film-type briefs |
If you hit something stranger, the repo is the living documentation — star it, read the releases, and check the issues. The project is two weeks into its public life, so our GitHub beginner guide is worth a read if navigating a fast-moving repo is new to you.
Sources
Every fact in this guide comes from a source fetched for it on November 2, 2026 — no numbers, install strings, or claims were invented.
github.com/openfilm/openfilm (repository and README, crawled November 2, 2026, 13:35 UTC): the skill-install command npx skills add openfilm/openfilm, the npx -y openfilm@latest fallback and the manual it prints, Node 22.2+ and ffmpeg requirements on macOS/Windows/Linux, git for saved versions, the ~100 MB headless Chromium download on first run, from-source requirements (Node 22.18+, pnpm 9, ffmpeg, git), the desktop app bundling ffmpeg and the headless browser, supported agents (Codex, Claude Code, any coding agent), the film model (film.html, tracks as <section> first-on-top, clips as elements, media fragments, at offset, CSS positioning), the frame(t) rule verbatim ("the same t always draws the same picture, whatever was drawn before"), Studio hand-editing (text, layers, clips, place, look, volume, speed, subtitles; edits save back to the film's files; named versions), openfilm look, export formats (MP4, GIF, sound and stems, subtitles, stills, slides, transparent WebM/MOV, timelines for Final Cut Pro / Premiere Pro / DaVinci Resolve), render flags (--4k, --blur, --alpha), the openfilm open | look | render | get | doctor CLI, the one-prompt example URL, ~4,225 stars / 402 forks / created October 4, 2026 / last push October 31, the MIT license with trademark on the name and logo, and the provider keys (ElevenLabs, OpenAI, Google, fal) in Studio Settings → Providers with no account needed for making, editing, or rendering.
github.com/openfilm/skills (crawled November 2, 2026): the npx skills add openfilm/skills pack of workflow and style briefs for film types.
my2cents.ai/news/2026-10-20-open-source-agents: the October 19, 2026 Show HN launch alongside v0.2.1/v0.2.2 and the MIT license.
ossradar.net/repo/openfilm/openfilm (repo snapshot crawled about 23 hours before this run): the v0.2.7 latest-release figure — treated here as a moving target, not a stable fact.
veed.io/tools/openedit (crawled November 2, 2026): OpenEdit as VEED's agent-native video tool — open-source editor (Apache-2.0), closed-source VEED Engine renderer under PolyForm Shield 1.0.0 (free to sell what you make), render-through-Chrome option, npx skills add veedstudio/open-edit, agent-agnostic (Claude Code, Codex, Gemini tested), Apple-Silicon Macs on macOS 26 only, beta.
opensourcealternatives.to/item/openfilm (updated October 30, 2026): the wider agent list — Cursor, GitHub Copilot, Gemini CLI, OpenCode, Windsurf, Cline, Amp, Devin.
skillsllm.com/skill/openfilm, explainx.ai (the OpenFilm guide, about 13 days old), gittrend.io/repo/openfilm/openfilm, lockergnome.com/openfilm-coding-agent-makes-videos-as-web-pages/ (updated about October 29), and openmicrodrama.com: the fresh-SERP field for "how to use openfilm" — skill-registry pages, explainers, and listings, with no unified independent beginner walkthrough found.
en.wikipedia.org/wiki/Openfilm, shootonline.com, openfilmfest.org, filmfreeway.com: the homonym check — Openfilm.com (closed August 2015), the Open Film Festival, and Open Film Zone, all different products.
One note on verification: installation was not attempted for this guide — no local OpenFilm run or export was performed here; the install flows and commands are documented from the vendor's README as of November 2, 2026.
Frequently Asked Questions
Is OpenFilm really free and open source?
Yes. The format, the CLI, Studio, and the desktop app are MIT licensed (github.com/openfilm/openfilm, fetched November 2, 2026) — the only thing OpenFilm keeps is the trademark on its name and logo. Making, editing, and rendering a film needs no OpenFilm account. That combination makes OpenFilm the AI video agent open source builders reach for when they want a stack they can actually own. The costs you can hit are third-party: provider keys for voice-over, music, or footage (ElevenLabs, OpenAI, Google, fal) are billed by those providers.
Which coding agent works best with OpenFilm?
The vendor names Codex and Claude Code and says any coding agent that can run a command works; the ecosystem list adds Cursor, GitHub Copilot, Gemini CLI, OpenCode, Windsurf, Cline, Amp, and Devin. Pick the agent you already trust — comfort reviewing the generated film.html matters more than which brand runs it.
Do I need to install anything besides the skill?
Through the agent path: Node 22.2+ and ffmpeg, plus git if you want saved versions; the first run downloads a ~100 MB headless Chromium. If you would rather install nothing, the desktop app for macOS and Windows from openfilm.dev or GitHub Releases bundles ffmpeg and the headless browser.
Can I edit a film without touching code?
Yes — that is what Studio is for. Text, layers, clips, timing, volume, speed, and subtitles are all hand-editable, and your edits save back to the film's files so the agent keeps them. You only touch code when you want to, not when you have to.
How is OpenFilm different from VEED's OpenEdit?
Same agent-native video category, different trade: OpenFilm is fully MIT — format, CLI, Studio, and desktop app are all open source, built on web pages you own. VEED's OpenEdit pairs an open-source editor (Apache-2.0) with a closed-source renderer (VEED Engine under PolyForm Shield 1.0.0), installs as a skill, and is currently beta on Apple-Silicon Macs on macOS 26 only.
