Live preview for manim-slides in VS Code.
50-second demo video

Press the run button once. After that, every Ctrl+S re-renders your changes and refreshes the interactive presentation in a browser tab, a VS Code tab, or the native presenter window. A PowerPoint copy is kept up to date in the background. No terminal commands.

The extension is a single 28 KB file with zero runtime dependencies and zero telemetry. Everything runs locally: the generated presentation bundles Reveal.js, so it works without internet.

New to LaTeX, Manim, or manim-slides? The free offline course Manim Slides Academy teaches the whole stack around this workflow.

1. Requirements
2. Install
3. First presentation
4. The workflow
5. Coming from plain Manim
6. What the extension replaces
7. Presenting
8. How it stays fast
9. Commands
10. Settings
11. Troubleshooting
12. Building from source
13. Credits

One-time setup per machine:

FFmpeg is not required. Manim CE ≥ 0.19 encodes video through its bundled PyAV library. The ffmpegPath setting exists only for older Manim versions and plugins that call an ffmpeg binary directly.

You need one file: manim-slides-preview-1.7.4.vsix (from Releases). No marketplace, no internet.

Per user. In VS Code: Extensions panel → ··· menu → Install from VSIX… → select the file. Or from a terminal:

code --install-extension manim-slides-preview-1.7.4.vsix

All users on a shared Windows machine. Run in an admin PowerShell:

Get-ChildItem C:\Users -Directory | ForEach-Object {
  $code = "$($_.FullName)\AppData\Local\Programs\Microsoft VS Code\bin\code.cmd"
  if (Test-Path $code) { & $code --install-extension "C:\path\to\manim-slides-preview-1.7.4.vsix" }
}

All users on Linux/macOS:

sudo -u <username> code --install-extension manim-slides-preview-1.7.4.vsix

Success indicator: a Manim Slides item appears in the status bar whenever a Python file is open.

1. Open a folder in VS Code and create a .py file:

from manim import *
from manim_slides import Slide

class Demo(Slide):
    def construct(self):
        title = Text("Manim Slides Preview", font_size=48)
        self.play(Write(title))
        self.next_slide()          # presentation pauses here

        circle = Circle(color=BLUE, radius=1.5).shift(DOWN * 0.5)
        self.play(title.animate.to_edge(UP), Create(circle))
        self.next_slide()

        self.play(FadeOut(circle), Unwrite(title))

2. Click the run button (▶) in the editor title bar, or press Ctrl+Shift+B. If the file has several scenes, a picker appears once and the choice is remembered. The Output panel shows every animation's progress live.
3. A browser tab opens with the interactive presentation. Advance with Space or →, go back with ←, fullscreen with F. The pauses are your next_slide() calls, exactly as your audience will see them.
4. Edit the code and press Ctrl+S. Only the changed animations re-render, then the tab refreshes itself.

A Demo.pptx also appears next to your file and is silently kept up to date on every save. A larger example ships with the repo: example/test_deck.py, a ~20-slide deck covering every major animation family plus a 3D scene.

1. Click the run button once.
2. Wait for the render. The interactive preview opens.
3. Edit your code, press Ctrl+S.
4. Repeat.

Saving while a render is still running is safe in both directions:

• A real code change stops the now-obsolete render and starts the new code immediately. Truncated partial files are discarded so the cache never reuses a corrupt file. Disable with restartOnEdit: false.
• A save with no actual change never interrupts anything. If the file and settings are identical to the last successful render, Manim is not invoked at all.

A slide deck is your existing Manim code plus pauses. The migration is three edits:

from manim import *
from manim_slides import Slide          # 1. add this import

class Demo(Slide):                      # 2. Scene -> Slide
    def construct(self):
        circle = Circle(color=BLUE)
        self.play(Create(circle))
        self.next_slide()               # 3. pause point for presenting

        square = Square(color=RED)
        self.play(Transform(circle, square))
        self.next_slide()

        self.play(FadeOut(circle))

Slide is a Scene subclass, so every animation, mobject, and helper you already use works unchanged. Two rules:

• Combining with special scene types: Slide goes first — class X(Slide, MovingCameraScene). The reverse order with a bare Scene, class X(Scene, Slide), is a Python MRO error. The extension detects that statically and reports the fix before wasting a render.
• Everything between two next_slide() calls plays as one slide.

Your plain-Manim files keep working: if the Manim Sideview extension is installed, the run button detects files with only Scene classes and hands them to Sideview, including on every Ctrl+S. The routing corrects itself: add a Slide import and the next save comes back to this extension. Disable with routePlainManim: false.

The terminal workflow, per edit, for each preview target:

Browser tab (default). Detach the preview tab into its own window, snap it with Win+←/→, or press F for fullscreen. Share the tab in any video-call tool or drag it to the projector. Every Ctrl+S refreshes it silently, and you stay on the slide you were viewing.

VS Code tab. Set openIn to vscode for a preview beside your code.

Native window. Run Manim Slides: Present in Native Window (GUI), or set openIn to gui to make the window part of the save loop. This is manim-slides present: a resizable, OS-snappable PySide6 window with full presenter hotkeys. Pass flags with guiArgs, for example ["--fullscreen"] or ["-S","2"] for a second monitor.

Any combination works: browser+gui, all, none, and so on.

Four layers, all automatic:

1. Partial-movie cache. Manim hash-matches every animation; only edited ones re-render. Cache files live in .manim-slides-preview/cache/, not in your project root.
2. Render daemon. A persistent background Python process imports Manim once and renders every save in-process, removing interpreter startup and import cost per save. It frees memory after each request, exits after 10 idle minutes, restarts on demand, and falls back to a plain subprocess if anything goes wrong. A watchdog restarts it if a render produces no output for stallTimeout seconds, so a stuck render never requires closing VS Code.
3. Convert-skip cache. If a render produced identical slides, the HTML conversion and browser reload are skipped.
4. Source fingerprint. A byte-identical save skips Manim entirely. This is the only guard that works for updater/ValueTracker animations, which Manim cannot hash-cache.

Open the palette with Ctrl+Shift+P:

All keys are prefixed manimSlidesPreview.:

Generated files land in .manim-slides-preview/ at the workspace root; add it to .gitignore. Manim's own media/ and slides/ folders behave exactly as with terminal use. The extension writes no registry entries and makes no network calls.

npm install -g @vscode/vsce
cd manim-slides-preview
vsce package        # -> manim-slides-preview-1.7.4.vsix

MIT licensed.

Concept, design & testing — Alamin Maruf. He spotted the gap this extension fills, specified every feature, made every product decision, and battle-tested each build on a real Windows + Manim CE setup. Nothing shipped without being run against a live manim-slides project first.

Code — AI-generated. The implementation was written by an AI assistant working under Alamin's direction, iterating on his bug reports and feature specs. Found a bug? Open an issue — a human reads them.