diffusionstudio/editor

The professional video editor built for agents

npx skills add diffusionstudio/skills

Diffusion Studio

Edit videos with Codex, Claude Code, OpenCode, or Pi. Refine any output in a fully featured editing environment.

Every edit you make is written to real code, so the agent always sees the latest version. A headless mode is available too.

What people do with it

Drop your raw footage and files into a folder, then ask for the video you want. That's it.

The agent handles everything from there:

• Cuts the clips
• Removes filler words
• Adds subtitles
• Applies color correction and filters
• Handles animations
• Renders the final video

• Motion graphics: explainers, promos, and title sequences
• Generative assets: images, video, and voiceover, declared in code and composited into the timeline
• Clipping: highlights from a long video, reformatted for social
• Video understanding: summaries, scene search, quotes with timestamps

Getting started

Download the desktop app, it walks you through setting everything up:

Use with Claude Code, Codex, Cursor, Copilot, or Gemini CLI. The app registers its MCP server with your agent, so just ask for what you want in plain language. Every session's instructions carry the editing and watching skills, so the agent reads the guidance it needs up front. dapi is the same set of tools as a CLI.

Prompt examples

Create a ~20-second promo for vercel-labs/native in Vercel's presentation style. Research its official website, GitHub, and brand guidelines; use authentic assets and verified product features, with crisp typography, polished motion, and a strong final CTA.

Recreate the 3blue1brown animation from https://youtu.be/HEfHFsfGXjs, closely matching its visual style, pacing, framing, colors, labels, and transitions. Use the exact collision mathematics from Gregory Galperin's original paper, do not approximate the physics.

Edit the footage in /path/to/folder

Turn this footage into a polished YouTube video. Add readable captions and an attention-grabbing graphic in the opening to give viewers a strong visual hook.

Can you pull the best 30-second moment from https://youtu.be/MtQ0qxyf-Ds and make a vertical version for social?

Make a 15-second version of this launch video. https://x.com/claudeai/status/2045156267690213649

In three bullets, explain what starts the conflict. Include timestamps. https://youtu.be/aqz-KE-bpKQ

Name three recurring locations and give one visual cue that distinguishes each. https://youtu.be/dQw4w9WgXcQ

Made with Diffusion Studio

Both were created by prompting. The compositions are published in diffusionstudio/open-projects:

| Launch video | Raise announcement | | --- | --- | | | |

How it works

Diffusion Studio uses SolidJS modules as the document source. Think IDE, but it renders a video canvas instead of text.

Editing works both ways: change something on the canvas and the code updates; change the code and the canvas redraws.

The desktop app includes command-line tools that let agents watch and listen to footage, edit it on a timeline, and render the result.

Compositions as code

A project is a folder of that JSX: open a folder once (dapi open from a shell), then edit the files. Saving recompiles the entry file and mounts it directly into the editor's ECS.

Every element carries an id, which is how the write-back finds its target: a rect dragged on the canvas, a clip trimmed on the timeline, or a retyped line lands as a prop on the element that authored it.

The root is a ` holding one ` per frame you cut in:

import { For } from "solid-js";
import { generate } from "@diffusionstudio/jsx";
const hero = generate.image({ prompt: "A neon city at night, cinematic", aspectRatio: "16:9" });
const motion = generate.video({ prompt: "slow camera push-in", startFrame: hero, duration: 5 });
const TITLES = [
  { text: "The Grid", start: 0, end: 2.5 },
  { text: "Neon Nights", start: 2.5, end: 5 },
];
export default function Project() {
  return (
    
      
        

Everything a mount produces stays a first-class editor node, so a person can pick up in the UI exactly where the script left off.

Seeing and hearing the media

Cutting footage requires understanding it. The app exposes the inspection tools an agent needs to work with media it cannot watch — as MCP tools, and as the same commands in a shell:

dapi media probe clip.mp4                                # container + codec metadata, like ffprobe
dapi media grab clip.mp4 -t 0 12 45                      # decode frames to PNGs
dapi media filmstrip clip.mp4                            # grid of video frames
dapi media waveform track.mp3                            # audio waveform, silence flagged
dapi media transcribe interview.wav                      # timed, word-level transcript
dapi media listen interview.mp4 -p "what is said in the intro?"   # ask a multimodal model
dapi capture intro -t 0 2 4                              # the frames a render would produce, by scene id

Each command is the MCP tool of the same name: dapi media grab is media_grab, --per-sheet is perSheet.

| Command | Purpose | | --- | --- | | dapi open | Launch the app and open (or create) a project folder, anywhere on disk | | dapi context | Summary of app state | | dapi capture | Render frames of a scene, as an export would, to a labelled contact sheet or one PNG per position | | dapi check | Check a node's subtree for structural mistakes (black-frame gaps, never-visible nodes, failed sources) and report subtree stats | | dapi media … | Inspect a file by id or path: probe, grab, filmstrip, waveform, transcribe, listen | | dapi models / dapi voices / dapi fonts | Discover generation models, speech voices, local fonts | | dapi screenshot / dapi logs | The app itself: capture the window, read recent console output | | dapi whoami | The authenticated account | | dapi report | Report a bug in the tools or the app: diagnostics bundled, filed as a GitHub issue via gh |

Conventions throughout: every result is one JSON object, the same structured content the MCP tool returns; errors go to stderr with exit code 1. Everything is built to be piped, grepped, and driven by a program.

Documentation

• Tool reference: every tool and CLI command, its options, and its output
• JSX reference: the composition markup with elements, timing, paints, generative assets, and captions
• Examples: runnable compositions, from basic scenes and generative assets to three.js and raw WebGPU

Repository layout

| Path | Package | What it is | | --- | --- | --- | | apps/web | @diffusionstudio/web | The editor UI (Solid + Vite) | | apps/desktop | @diffusionstudio/desktop | Electron shell hosting the editor | | apps/cli | @diffusionstudio/cli | The dapi CLI: a client of the app's MCP server | | packages/runtime | @diffusionstudio/runtime | Headless editor runtime: the koota world, traits, actions, systems, media decoding, capture. No DOM, no Solid | | packages/reconciler | @diffusionstudio/reconciler | Evaluates a compiled project bundle and reconciles its element tree onto runtime entities, via Solid's universal renderer | | packages/jsx | @diffusionstudio/jsx | The authoring API: element vocabulary, types, and generated assets (generate.*) | | packages/assets | @diffusionstudio/assets | A project's asset library: the assets.yml manifest, content hashing, probing, resolution | | packages/encoder | @diffusionstudio/encoder | Offline video/audio/image encoding over runtime worlds (mediabunny) | | packages/koota-solid | @diffusionstudio/koota-solid | Solid bindings for koota, ported from @koota/react |

Contributing / local setup

Requirements: Node 20+ and npm.

git clone https://github.com/diffusionstudio/editor.git
cd editor
npm install
cp apps/web/.env.example apps/web/.env   # required: the app won't run without it
npm run dev

To put dapi on your PATH (macOS/Homebrew layout; adjust the link target for other setups), link it once:

npm run symlink:create --workspace=@diffusionstudio/cli

The link points at the CLI build, which npm run dev:desktop refreshes on every start, so the linked dapi always runs the latest code.

Before sending a PR:

npm run check    # typecheck all workspaces
npm run lint     # lint all workspaces

License

MPL-2.0

The brand assets in apps/desktop/assets are not covered by this license. Copyright (c) Diffusion Studio Inc. All rights reserved.