Drawbly

From an idea to a short explanation

Make a video people can follow.

Pick one idea. Show the detail that matters. Add drawings, captions and a voice to help people understand it.

Start with your own marks in the browser, or give a coding agent the instructions to put a narrated video together.

Free canvas and local renderer. No Drawbly signup needed to start.

Earthrise example from our channel. Photography: NASA / Bill Anders. Includes multiple scenes and assembled motion.

Your drawing. Your voice.

Draw and record.

Open the canvas, add an image if you want, and draw over it. Use Video to record while you explain, or replay your marks as an animation.

See how to record →

Works in a supported browser. Microphone access is your choice.

A photo, a script, a finished file.

Build it with a coding agent.

Give an agent your topic and the prompt below. It can prepare scenes, generate narration, render Drawbly annotations and join the result into an MP4.

Get the prompt →

Needs an agent with local file and terminal access. Ordinary chat can help plan the video.

Make a narrated explanation

Give your agent a clear starting point.

Use a coding agent such as Codex or Claude Code on your computer. Start with one scene; add more once the first video works.

1

Choose your idea.

Describe the one thing someone should understand. Add a photo you can use, or ask for a simple diagram.

2

Copy the instructions.

The agent uses Drawbly’s renderer for the visuals and local speech tools for narration. Review the proposed script before it renders.

3

Review and make it yours.

Watch the MP4, listen to the voice, and change what feels off. Keep the editable drawing files for later.

This stays on this page. It is added to the prompt, not sent to an agent.

Copy includes your topic. The saved template has a placeholder for you to replace.

A few things to know.

Where each part happens

Your agent writes the script and prepares scene recipes. Drawbly’s local renderer draws the labels and annotations, adds captions and supplied narration, and produces MP4 files. Local Kokoro tools can generate the voice. For several scenes, the agent joins the MP4s with FFmpeg. The website’s canvas also lets you draw and record directly.

The channel’s richer clips include custom scene layouts and extra motion. The starter kit gives you the drawing and narration tools; reproducing every effect needs additional work by your agent.

Setup and voice

The local video route needs Node.js 22.14+, FFmpeg with ffprobe, and Python 3.11 for optional local narration. Let the agent check your computer first and guide any missing setup. The kit includes the narration scripts and a model downloader.

In the extracted kit folder, the documented Windows commands are:

npm install
python -m venv .local/voice-env
.local/voice-env/Scripts/python.exe -m pip install -r voice-requirements.txt
.local/voice-env/Scripts/python.exe download-voice.py .local/kokoro-model
.local/voice-env/Scripts/python.exe speak-neural.py story-example.json first-video --models .local/kokoro-model
node time-story.mjs story-example.json first-video
node render-recipe.mjs first-video/input.recipe.json first-video/final.mp4

On macOS/Linux, use .local/voice-env/bin/python instead. Keep speech models downloaded once, and use a fresh output folder for each version. Read the current renderer reference.

Cost and files

The free local renderer includes Drawbly credit. Drawing and recording in the free canvas do not require a subscription. Your coding agent or chosen hosted voice service may charge separately. Local Kokoro narration has no per-request speech API fee, but needs model downloads and computer time.

Keep the MP4, recipes, original images, narration and editable drawing files together. They stay on your device through this workflow; publishing is a separate step. Drawbly Plus offers paid cloud drawing saves, optional credit removal and AI image enhancement. It is not required for this local video workflow.

Make several scenes

Create one short story file per scene. Use the same canvas dimensions, framing, fonts and voice throughout. Generate each scene’s narration, measure its timing, render the matching recipe, then join those MP4s with FFmpeg. Re-encode to a consistent frame rate, size and audio format when necessary.

A full scene video must fit the renderer’s 120-second limit. Keep the final Short short enough for the format you intend to publish. Photos remain imported images; save the Drawbly annotations and labels as editable files. Custom camera motion needs a separate animation or editing step.

Full renderer reference: recipes and browser tools

Try it in the browser

  1. Open Drawbly → Video → Video recipe → Try example, or Open recipe.
  2. Choose any requested image and narration files. Preview and scrub to check timing.
  3. Create video, then save the MP4 (or WebM in browsers without MP4 encoding), recipe and editable drawing.

Download the example recipe. The current canvas stays unchanged. Recipes and audio are held in memory until saved; keep narration beside the recipe. Export runs in real time, with this tab open.

Local command-line renderer

For a still PNG and editable drawing without FFmpeg, start with the agent quick start. For video, agents with terminal access can use the same kit.

For agents with terminal access, the local renderer kit contains the same drawing engine. Extract it, install Node.js 22.14+ and FFmpeg (including ffprobe), then run:

npm install
node render-recipe.mjs example.video.json output.mp4

In a source checkout: npm run render:recipe -- recipe.video.json output.mp4. Output includes a captioned H.264/AAC MP4, portable recipe with embedded background, and editable .drawing.json. Keep the original narration file alongside any recipe you move. Existing outputs are never overwritten. FFmpeg and fonts must be installed locally; set FFMPEG_PATH and FFPROBE_PATH if needed. Installing dependencies requires internet; rendering does not.

Recipe contract · version 1

{
  "kind": "drawbly-video", "version": 1,
  "title": "Explain this photo", "canvas": [1000, 700],
  "duration": 12, "framing": "portrait",
  "background": {"file": "photo.jpg"},
  "narration": {"file": "narration.wav", "at": 0},
  "events": [
    {"at": 1, "duration": 1.5, "object": {
      "type": "arrow", "color": "#e32d38", "width": 6,
      "points": [[100, 100], [300, 250], [500, 250]]
    }},
    {"at": 3, "duration": 0, "object": {
      "type": "text", "text": "Look here", "color": "#292d32",
      "x": 500, "y": 300, "fontSize": 40
    }}
  ],
  "captions": [{"at": 0, "end": 4, "text": "Here is the detail to notice."}]
}
  • Time is in seconds. Canvas coordinates are pixels, with the origin at top left. The photo fits centered without cropping; place annotations accordingly.
  • Strokes use pen, arrow or translucent shade; supply the actual points, color and width. Text appears at its start time. Marks remain visible; array order controls layering. Events may overlap.
  • Text supports fontFamily: sans, serif or mono, and optional wrapWidth. Font sizes are 8–240; stroke widths 0.5–120. Recipe strokes preserve supplied points without smoothing.
  • Duration: 1–120 seconds. Canvas: 320–4096 per side. Framing: original, portrait or square. Output fits within 1280 pixels per side. At most 500 events, 50,000 total points and 200 non-overlapping captions of up to 140 characters.
  • Background and narration are optional. Local asset names must be simple filenames beside the recipe, not URLs or paths. PNG/JPEG/WebP backgrounds can also be embedded as {"src":"data:image/png;base64,...","width":1000,"height":700}, up to 1 million characters. Browser image import normalizes larger files.
  • Narration: mono/stereo WAV, MP3, M4A, Ogg or WebM, at most 30 MB and no longer than the remaining video duration. Short audio is followed by silence. Browser codec support varies; WAV is a useful fallback.
  • Captions are burned into the video. Keep captions short for phone screens. All free output includes Drawbly credit. Generated marks are not a claim of human authorship.

Browser agent tools

Where WebMCP is supported, the drawing page exposes prepare_video_recipe({recipe}), read_video_recipe_status({}), render_video_recipe({}), and cancel_video_recipe({}). Preparation does not edit the user's canvas. Referenced files must be selected through the visible file pickers; agents cannot read arbitrary device files through these tools.

After preparation, check imageReady/audioReady, start rendering, and poll phase until ready. Download through the visible Save MP4/WebM link. Rendering failure or cancellation returns to prepared with an explanatory message. A browser may require a user click on Create video to unlock audio; terminal agents should use the local renderer for unattended exports.

Start with a technical explanation

The template library includes API request flow, RAG pipeline and software architecture examples. Each has a preview, editable drawing and timed video recipe. The local renderer kit includes the three recipes in its templates folder. Change their labels and timing, then render a new explanation locally.

Run the public API request-flow example on GitHub. It includes a sample recipe and helper that creates a captioned MP4, preview PNG and editable drawing using the downloadable Drawbly kit, Node.js 22.14+ and local FFmpeg with ffprobe. This sample does not call a hosted AI service or upload your drawing.

Local neural narration

The renderer kit now includes optional Kokoro neural speech tools. They run on your computer with Python 3.11 and FFmpeg. Download the model once, then generate narration offline. Start with the af_heart voice at speed 1.0. The website accepts the resulting audio; it does not run a hosted voice service.

python -m venv .local/voice-env
# Windows; on macOS/Linux use .local/voice-env/bin/python
.local/voice-env/Scripts/python.exe -m pip install -r voice-requirements.txt
.local/voice-env/Scripts/python.exe download-voice.py .local/kokoro-model
.local/voice-env/Scripts/python.exe speak-neural.py story-example.json output-001 --models .local/kokoro-model
node time-story.mjs story-example.json output-001
node render-recipe.mjs output-001/input.recipe.json output-001/final.mp4

Edit story-example.json for each video. Each segment contains speech, a caption and optional annotations positioned as fractions of that segment's measured duration. The tools generate narration, synchronized captions and a renderable recipe. Use a new output directory for each attempt. The included VIDEO-PRODUCTION.md covers setup, photo sourcing, the sample-video workflow, quality checks, and a batch/scheduling handoff for agents. The kit generates files; scheduling and posting require your own tools.

Voice and cost

The browser does not generate speech or call an LLM. Supply narration recorded by a person, synthesized with the local neural tools, or created using your own chosen provider. Offline rendering and speech have no per-request API fees. Cloud agents and hosted voice services can still charge their user; running a client locally does not make a remote model free. Drawbly's ordinary website hosting remains separate.

For an offline Windows narration file, use the included speak-local.ps1 with an installed Windows voice. Other systems can supply a WAV from their local speech software. Label AI-generated narration where applicable. Review facts, timing, pronunciation and image-use rights before sharing.

powershell -NoProfile -File speak-local.ps1 -TextFile script.txt -Output narration.wav