Most AI video tools begin with an upload button.
That is convenient for the application developer, but it changes the product for the user. Raw footage can be large, personal, slow to transfer, and expensive to process repeatedly. For a video editor, uploading is not a one-time action either: every trim, caption, effect, and export can create another round trip.
I wanted to explore a different constraint: how much of an AI video-editing workflow can stay inside a modern browser?
That question became Timeline Studio, an open-source, local-first AI video editor with a multi-track timeline, captions, voiceovers, visual effects, browser AI tools, and offline export.
The interesting part was not putting a familiar editor UI on a webpage. It was making media, AI inference, model delivery, timeline state, preview, and export behave like one coherent system.
Local-first is an architectural constraint
For supported workflows, project media is processed in the browser instead of being uploaded to an editing backend. This changes several engineering decisions at once:
- inference needs browser-compatible runtimes;
- model downloads must be lazy, resumable, cached, and versioned;
- timeline operations need deterministic state rather than server-side session magic;
- preview must stay responsive while export remains reproducible;
- failures need to explain browser or hardware limitations without hiding them.
WebGPU is the main compute path for heavier models. WASM remains important for operations where it is more stable or broadly compatible. ONNX gives the project a practical interchange format, but converting a model is only the beginning. A model that technically loads can still be unusable because of memory pressure, unsupported operators, slow graph initialization, or inconsistent numerical output across execution providers.
The result is a mixed runtime rather than a single “run everything on WebGPU” switch.
Model delivery is part of the product
A local model still has to reach the user once.
Timeline Studio lazy-loads AI artifacts only when a feature is first used. The service worker owns the persistent model cache, while later runs reuse the cached files. Models are pinned to known revisions so an upstream change cannot silently alter an editing workflow.
The project also mirrors model artifacts across Hugging Face and ModelScope. Chinese and domestic sessions prefer ModelScope; other sessions prefer Hugging Face. If the preferred provider is unavailable, the application can fall back to the other mirror.
The important detail is that both providers map to one cache identity. A fallback should not create a second full copy of the same model on the user's device.
This sounds like infrastructure work—and it is—but it directly affects the editing experience. “Generate music” should not look like a fresh model download every time. A cache miss should not become a mysterious network exception. A pinned model should carry its license and source notes with it.
A responsive preview and a deterministic export are different jobs
Video editors need immediate feedback. Native media playback and a live canvas make trimming and positioning feel responsive, but they are not enough for final export.
Real-time playback can vary with decoding speed, dropped frames, tab scheduling, and device load. If final rendering simply records whatever happened on screen, two exports of the same project can drift.
Timeline Studio therefore treats the timeline as declarative project state and uses a separate offline rendering path for export. Clips, source trims, transforms, captions, overlays, audio, effects, and keyframes are evaluated against explicit timestamps. WebCodecs is used for MP4/WebM composition where available, with a compatibility path for browsers that need it.
The two paths have different performance goals:
- Preview: respond quickly enough to edit.
- Export: evaluate the same project state consistently.
They still need shared geometry, timing, interpolation, and effect definitions. Otherwise the editor develops the most damaging kind of bug: a preview that looks correct and an export that does not.
This is why small visual features can require surprisingly deep work. A timed ripple effect, for example, is not just a CSS animation. Its seeded placement, beat timing, grayscale-to-color reveal, wave propagation, and decay must all be derived from the same deterministic parameters in both preview and export.
AI output should become editable media
Another design decision was to avoid treating AI as a collection of isolated demo buttons.
Generated or analyzed results should return to the editing model:
- automatic captions become timed caption segments;
- generated voiceovers become audio clips;
- separated vocals and instrumentals become independent audio tracks;
- AI music is added to the user's assets instead of silently replacing the timeline;
- repair and subject-isolation results remain reviewable and editable;
- portable .timeline projects preserve the composition as the source of truth.
The browser currently supports workflows including multilingual voice generation, Whisper-based captions, local AI music, smart framing, object or watermark repair, restoration, vocal separation, and talking-avatar generation. Not every device will run every large model comfortably, so the UI has to expose setup progress, cancellation, caching, and compatibility honestly.
What did not fit the local-first story
There is a temptation to claim that moving inference into the browser removes every tradeoff. It does not.
The first model download may be substantial. GPU memory varies widely. WebGPU behavior still differs across browser and driver combinations. Mobile devices require more conservative paths. Some models become slower or less reliable after conversion, even when their quality looked good in the original research environment.
Local-first also does not mean “offline from the first visit.” The application shell and requested models must be downloaded before they can be cached. A more accurate promise is: supported editing workflows can run without uploading the user's project media to an editing backend.
That narrower statement is less dramatic, but it is testable.
Why open source it?
Browser media work sits at the intersection of WebCodecs, WebGPU, ONNX, audio processing, timeline UX, caching, and export. Many of the hardest problems are integration problems, and they benefit from reproducible bug reports and implementations that can be inspected.
Timeline Studio is available under the MIT License on GitHub. The repository includes the editor, multilingual documentation, portable project tooling, and an agent skill for inspecting, editing, diffing, and rendering timeline projects.
There is still plenty to improve: broader headless render parity, more reliable cross-device export, a larger versioned command registry, and better recovery when browser AI reaches hardware limits.
Launching today
Timeline Studio is launching on Product Hunt today.
If local-first creative software interests you, try the editor and share your honest feedback. I am especially interested in where the browser-local model feels clear, where setup is confusing, and which real editing workflow breaks first.
Top comments (0)