It cuts, not suggests.
Hite executes on your real timeline. Every change is an edit you can undo.
Vibe coding for video editing
Edit by saying so.
Hite is vibe coding for video editing: an AI editor that lives on your timeline. Describe the cut. Watch it happen.
The demo below is a staged project of 24 clips, 1h 23m 54s. Real tools, real commands, synthetic footage.
Your timeline. 1h 23m 54s of it.
Every edit you'll ever make is a moment in time.
A cut. A beat. A breath you took out.
Hite lays all of it flat.
Then you just tell it what you want.
It doesn't suggest. It edits.
Fade. Grade. Caption. Beat.
1h 23m 54s. One sentence.
The film
This was cut in Hite.
Twenty-one clips locked to the beat, twenty transitions, a look over all of it, and a title on the opening — then rendered by the same compositor that draws the preview. What you are about to watch is the file that came out of Export.
How it works
One sentence in. Real edits out.
Not a suggestion box. A planner that calls real tools against your footage and writes real commands onto your timeline.
It knows your footage.
Transcripts, silence, scenes, beats. Indexed when you import.
It shows its work.
Every tool call is visible, inspectable and reversible. No black box on your edit.
Under the hood
One spine. No second path.
The model and your hands go through the same door. Everything downstream is one pure function of the timeline.
- You, or the model
EditCommand[]Typed commands: trim, split, transition, speed, caption, overlay, audio bed, marker. Both doors emit the same union.
- Reducer
reduceBatch()Pure. The same commands always produce the same timeline. One undo stack for human and AI edits.
- Timeline
EDL.2The single source of truth. Integer ticks at 30,000 per second; a frame at 30 fps is 1,000 ticks.
- Compiler
edlToRenderIR()The timeline becomes a render IR, hashed so unchanged segments are never rendered twice.
- Renderer
HiteRootOne Remotion composition draws the preview in the browser and the export in the worker. No second path.
- 21tools in the planner's library, routed by tier
- 8model providers, bring your own key
- 1renderer for preview and export
- 30,000ticks per second, the timebase
- 1080pH.264 export from a Postgres-queued worker
- MITlicence for the whole repository
Go deeper
The whole thing, written down.
Every stage above has a page behind it: the command union and what each one does to the timeline, the reducer’s invariants, why time is integer ticks, how the compiler turns an edit decision list into a scene graph, and why the preview and the export are the same compositor rather than two renderers that agree most of the time. It also says plainly what the renderer cannot draw yet, and which registry entries are withheld from the model because of it.
Three signatures carry the whole product. Everything else is arranged around them.
reduceBatch(edl, batch, opts) → { edl, forwardPatches, inversePatches }The only way the timeline changes. Validates, or throws — never half-applies.
edlToRenderIR(edl, env, resolver) → RenderIRPure. The same timeline compiles to the same scene graph, every time.
ticksToFrame(t, fps, tps) → numberThe one place ticks become frames. Round-half-even, called only by the compiler.
- Edl.2
- schema
- 30,000
- ticks per second
- 15
- command variants
- 39
- catalog entries live
Questions
Straight answers.
Was Hite going to raise?
It was on the table. We chose to open-source the whole thing instead: the planner, the tool library, the reducer, the renderer and the worker are all in one MIT-licensed repository. You bring your own model key, you run it where you like, and nothing about the editor depends on us staying in business.
What does it actually do to my timeline?
The model never touches pixels. It calls analysis and advisor tools against your footage, then emits a typed batch of edit commands: trim, split, add transition, add overlay, set speed, add captions, add an audio bed, add markers. A pure reducer applies them to a real edit decision list. The same commands always produce the same timeline, and every one of them is an ordinary edit you can undo or move by hand.
Which models can I use?
Google, OpenAI, Anthropic, Groq, xAI, DeepSeek, OpenRouter, or any self-hosted OpenAI-compatible endpoint. It is bring-your-own-key: the key goes in a header on each request, there is no pool on our side, and a request without a key is refused rather than silently routed somewhere else.
Do I need an account?
No. There is no sign-up screen and nothing asks for an email. Opening the editor creates a session in the background and row-level security scopes every project to it. The trade: that session lives in your browser's cookie, so a different browser or cleared cookies starts you on an empty workbench. Export what you want to keep.
Does the export match the preview?
There is one renderer, so there is nothing for the export to disagree with. Preview and export are the same Remotion composition compiled from the same edit decision list. Export is 1920 by 1080 H.264 today, rendered by a worker process that drains a Postgres job queue.
What is not there yet?
Hite is in beta. Face detection is not wired, so nothing anchors to a person. Transitions that need two clips' pixels blended, like a true cross dissolve, are withheld rather than faked. LUTs and overlays render as approximations. Anything the renderer cannot paint is kept away from the model so it can never report a change it did not make.
Open source
Stop scrubbing. Start telling.
Vibe coding for video editing, MIT licensed. Clone it, bring your own model key, and describe the cut. The repository has the quickstart.