VidNo is not a single model. It is a pipeline of specialized systems that each handle one stage of video production. Understanding that pipeline helps you get better results and troubleshoot when output is not quite right.

Here is the full sequence, from raw recording to published YouTube video.

Stage 1: Frame Analysis and OCR

VidNo samples your screen recording at configurable intervals (default: 1 frame per second) and runs OCR on every frame. But it is not just extracting text -- it classifies what is on screen. Terminal output, code editor content, browser windows, documentation pages, file trees -- each gets tagged differently.

This classification matters because the scripting engine needs context. "The developer opened a terminal" is different from "the developer switched to the browser to check API documentation." VidNo's frame analyzer knows the difference.

Stop editing. Start shipping.

VidNo turns your coding sessions into YouTube videos — scripted, edited, thumbnailed, and uploaded. Shorts included. One command.

Try VidNo Free

For code editor frames, VidNo also performs syntax-aware extraction. It identifies the programming language, tracks which file is open, and notes line numbers. This feeds directly into the script generation stage.

Stage 2: Git Diff Integration

If your recording session corresponds to git commits (and VidNo can detect the repo automatically), it pulls the diffs for every commit made during the recording window. These diffs are the highest-signal input for script generation.

Consider the difference: OCR sees "text appeared on screen." Git diffs see "a new async function called fetchUserData was added to api/users.ts that calls the /v2/users endpoint with pagination support." That level of semantic understanding is what makes VidNo's scripts technically accurate rather than superficially descriptive.

// VidNo detects this diff automatically
+ export async function fetchUserData(page: number = 1) {
+   const res = await fetch(`/api/v2/users?page=${page}&limit=20`);
+   if (!res.ok) throw new ApiError(res.status);
+   return res.json() as Promise<PaginatedUsers>;
+ }

Stage 3: Scene Segmentation

Using the OCR data and frame classifications, VidNo divides the recording into logical scenes. A scene boundary occurs when:

  • The active application changes (editor to terminal, terminal to browser)
  • The open file changes within the editor
  • There is a significant pause (configurable threshold, default 8 seconds)
  • A git commit boundary is detected

Each scene gets a summary of what happened: what code was written, what commands were run, what was browsed. This scene list becomes the skeleton of the video script.

Stage 4: AI Script Generation

VidNo sends the scene summaries, git diffs, and relevant OCR extracts to the Claude API. The prompt engineering here is specific -- Claude is instructed to write a developer tutorial script, not a generic voiceover. It knows to:

  • Explain the why behind code changes, not just the what
  • Reference specific function names, variable names, and file paths
  • Call out potential gotchas and alternative approaches
  • Maintain a conversational but technical tone
  • Generate chapter markers for YouTube

The generated script is saved as a JSON file. You can review and edit it before rendering -- see the script editing guide for details.

Stage 5: Voice Synthesis

VidNo uses a local voice cloning model (running on your GPU) to generate narration. You train it once with a 60-second sample of your voice. From then on, every script is narrated in your voice with natural pacing and emphasis.

The voice model runs entirely locally. Your voice data never leaves your machine. Processing time depends on your GPU -- an RTX 4090 handles a 10-minute script in about 90 seconds. See the GPU guide for benchmarks.

Stage 6: Smart Editing and Rendering

An FFmpeg pipeline assembles everything:

  1. Dead time (silence, idle cursor, thinking pauses) is cut or compressed
  2. The narration audio is synced to the corresponding screen footage
  3. Zoom effects highlight relevant code sections during explanations
  4. Transitions are added at scene boundaries
  5. Chapter markers are embedded in the video metadata
  6. Four output formats are rendered: full tutorial, quick recap, highlight reel, and a vertical YouTube Short

Stage 7: Thumbnail Generation

VidNo generates a code-focused thumbnail from the video content automatically. It selects a visually compelling frame, overlays readable text and relevant code snippets, and produces a thumbnail sized for YouTube. No Canva, no Figma, no manual screenshot cropping.

Stage 8: YouTube Upload

The final stage uploads everything directly to YouTube via the API. Title, description, tags, chapter timestamps, and the generated thumbnail are all set automatically based on the AI-generated script and code context. You can schedule publishing for a specific date and time, or publish immediately. Playlist assignment is automatic based on content category. The video goes from your screen recording to live on YouTube without you ever opening a browser.

The entire pipeline -- from raw recording to published YouTube video -- typically takes 4-10 minutes depending on recording length and GPU performance. Compare that to the 4-6 hours of manual editing plus upload time it replaces.

For a hands-on walkthrough, check the getting started guide. To understand the FFmpeg layer in detail, see how FFmpeg powers VidNo's editing.