Remocn Studio

Ship a launch video without opening After Effects.
A macOS app where your own coding agent makes the video
as a real Remotion project you own, not a file you rent.

The pitch · Directing · The pipeline · On set · The cast · Build from source · Contributing

The pitch

Describe the video you want. A coding agent builds it as a real Remotion project. You watch the live preview change while it works, and export an mp4 when it looks right.

This isn't another AI video editor. There's no timeline, no keyframes and no track management. You write prompts, point at things and give notes.

Not a generator. Not a template. AI video tools usually make you pick one: generate pixels you can't edit, or drag in templates everyone recognizes. Remocn Studio takes a third route. The agent writes the motion design as code and takes direction as you watch.

	Pixel generators	Template editors	Remocn Studio
What you get	A video file	Someone else's layout	A Remotion project
Changing one word	Generate it again	Hunt for the layer	Say it, or click it
What it looks like	Close enough	Everyone else's video	Your brand
Where it lives	Their cloud	Their account	A folder on your disk

You direct. It shoots.

Remocn Studio puts you in the director's chair. You watch the take, then give notes:

"Fix the text here." "The animation is too fast here." "Why did everything break here?"

There are three ways to say here:

Type it. Plain words in the chat, taken exactly as you wrote them.
Point at it. Click any element in the preview. Playback pauses and the properties pane opens, with type, spacing and easing curves as controls you can drag. Every change is saved into the source. You can double-click text to rewrite it in place, or drag an object to move or resize it. Add the element to the chat and it goes along with your message as [Element #1].
Frame it. Drag a Snapshot box over the frame and the crop goes into the chat as a picture, ready to talk about.

How a video gets made

You don't get a prompt box that hopes for the best. You get a production pipeline with seven stages. At every stage the agent writes a document into your project, so you can read, edit or overrule each decision.

#	Stage	In the app you'll see	It leaves behind
1	Analysis	Analysing the material	`analysis.md`: audience, promise, format, what's missing
2	Brand	Collecting the brand	`brand.md`, plus your original logos, copied unchanged
3	Script	Writing the script	`script.md`: every shot, its message, its timing
4	Motion	Defining the motion language	`motion.md`: which component plays which shot
5	Build	Building the video	The scenes themselves, plus keyframes it rendered to check its work
6	Choreography	Choreographing the whole video	`choreography.md`: rhythm, continuity, reading time
7	Review	Reviewing the result	`review.md`: every note, closed with evidence

The agent doesn't guess what looks good. A curated set of motion design skills ships with the app: easing, pacing, typography animation, and a record of what has failed on screen before. Before calling a video done, the agent runs design_check, which measures the rendered frames for readability, timing and handoffs.

On set

Inspect & edit _{Click an element and tune its type, tracking, easing and copy. The value goes back into the code.}	Snapshot _{Drag a box over the frame. It lands in the chat as a picture.}	Assets & stock _{Save clips, images and audio once, then say "use the intro clip".}
Components _{Save an animation that works as a component and reuse it in any project. The remocn motion set comes built in.}	Project brand _{Drop in a DESIGN.md or set the name and colors once. Every new video starts on brand.}	Export _{MP4, WebM, GIF or ProRes, up to 4K, rendered by the project's own Remotion.}

Also in the kit:

Every platform's shape. Export presets for YouTube, Shorts · Reels · TikTok and Instagram Feed: wide, vertical and square.
A moodboard before a single frame. No brand yet? The agent can build a moodboard from stock photos and work from its palette and type.
Sound and music. Connect your own ElevenLabs account to generate sound effects and music from the chat. Each paid request waits for your approval.
Motion roles. Every bundled component is tagged with its job: entry, emphasis, exit, scene or transition. The agent picks the one that fits the moment.

The cast

You don't need an API key or a separate token bill. The studio drives the command-line tool of a coding agent you already use, signed in with the subscription you already pay for.

Agent	Sign in on this Mac with
Claude Code	`claude auth login` (signing in to Claude Desktop doesn't count)
Codex CLI	`codex login`
GitHub Copilot CLI	`copilot login`
Grok Build	`grok login`

You don't have to memorize these. The studio shows the exact install and sign-in commands for each agent and can open a Terminal window for you to paste them into.

It's real code, and it's yours

Every video is a standard Remotion project in a folder on your disk. You can open it in your editor, commit it to git and take it anywhere. There's no proprietary format and no lock-in.

my-launch/                          an ordinary Remotion project
├── .remocn/project.json            name, identity, brand
├── public/brand/                   your logo, copied as-is
├── src/
│   ├── Root.tsx
│   └── videos/
│       ├── registry.tsx            every video registers here
│       └── launch-teaser/
│           ├── index.tsx           the scenes: TSX you can read
│           ├── assets/
│           └── docs/               analysis → brand → script → … → review
└── package.json                    remotion, pinned

House rules

The agent stays in its folder. File edits inside your project run without interrupting you. Any shell command, or any path outside the project, gets a permission card first. You choose the mode (auto, accept edits or plan), and there's no mode that bypasses the cards.
Nothing leaves your Mac without your consent. There's no telemetry, and crash reports are opt-in.
Your agent setup stays untouched. The studio brings its own skills to every agent and never writes into ~/.claude, ~/.codex, ~/.copilot or ~/.grok.
Your project stays yours. The studio writes into your project only what a turn or one of your own actions asked for.

Requirements

macOS on Apple silicon or Intel
One of the cast, installed and signed in on this Mac

The studio's environment checklist checks both, along with the project's Remotion version and dependencies, and offers a fix for anything that's missing.

Behind the scenes

Want to build it yourself? You need macOS, Bun 1.4 (the exact version is pinned in packageManager), and the Tauri prerequisites: a Rust toolchain and the Xcode Command Line Tools.

git clone https://github.com/Remocn/remocn-studio.git
cd remocn-studio
bun install
cp .env.example .env   # optional: a Pexels key turns on stock photos
bun tauri dev

Command	What it does
`bun run check`	Format and lint in one read-only pass (what CI runs)
`bun run fix`	Apply the fixes `check` reports
`bun run typecheck`	`tsc --noEmit`
`bun run test`	The test suite: bun test, happy-dom, Testing Library
`bun run smoke:render`	Run the real renderer against a fixture project (slow, needs network)
`bun tauri build --no-sign`	A local `.app` you can run but not release

The studio has three layers. A Tauri v2 core in Rust owns the window, the keychain and the updater. The webview is a Next.js static export. A bun sidecar built on Effect runs the agents, the history, the preview host and the renderer. The map of the system and the working rules are in CLAUDE.md.

Contributing

Bug reports, fixes and ideas are welcome. Start with CONTRIBUTING.md. It covers setting up, the checks CI runs, and what a pull request needs.

What the studio does is specified in openspec/specs: one spec per capability, each written as requirements with scenarios. To change behavior, open an OpenSpec change. To ship it, record it with bun run changeset. The reasoning behind each area, including the measurements and the failed attempts, is in docs/decisions.

Found a security issue? Please report it privately through GitHub security advisories instead of opening an issue.

Built with

Credits

Rendering is powered by the open-source Remotion framework. Remotion has its own license terms, and companies may need a company license.
The motion components come from remocn

Remocn/remocn-studio

Star growth

README