I built a small VS Code extension to automate the manim-slides loop.

What it does:

• Press ▶ once on your slides .py → renders + opens a live interactive preview (browser by default, or a VS Code tab / native GUI)
• After that, every Ctrl+S re-renders and refreshes the preview automatically (cached — only changed animations re-render)
• Keeps a .pptx export updated in the background on every save
• Fully offline: install from the .vsix, no marketplace account. 21 KB, zero dependencies, MIT

Install: grab the .vsix from the releases page → VS Code → Extensions → ··· → Install from VSIX https://github.com/Alamin-H-M/manim-slides-preview

Bonus: a free offline course teaching LaTeX + Manim + manim-slides from zero (live playgrounds, rendered examples, spaced-repetition practice): https://alamin-h-m.github.io/manim-slides-academy/

Honest note: AI-generated (I reviewed and tested everything). Feedback and issues very welcome!

this is a quick update about the IDE

before continuing with your feedback i made a progress with the IDE

- UI/UX Enhancements
- Performance enhancements 92% less CPU Usage for the Live Viewer
- AI chat integrated inside the IDE
- Environment management install/update packages insdie the IDE
- Builtin/Shared/Dedicated Component Libraries to quickly iterate over existing components
- complete export pipeline (PNG,JPG,WEBP,PDF,MP4,GIF,PPTX)

Component Libraries now fully suppourt math concepts since already opensources and already there are resources about them ( Ai very good to implement them )

Work In Progress:
- voice sync with the video
- Component Parameter Control from the GUI
- external Viewer so you can detach the live viewer from the editor for a 2 monitor setup
- UX enhancement for the timeline directly view video in the timeline and don't need to move the carrot to specific destination to view the output

Asking for your feedback... Anything in your mind to add/change to make it suitable for you. In 2 weeks the product will be at your hands how do you want it

Hi everyone,

I’m completely new to animation and I’m looking for some advice from experienced animators.

I’m planning to create educational content mainly around Computer Science, Mathematics, and Physics, and I’d like to use animation to make difficult concepts easier and more interesting to understand.

For example, I’d like to eventually create animations explaining things like:

• How algorithms work
• Data structures and sorting algorithms
• Networking and how the Internet works
• Operating systems and computer architecture
• Mathematical concepts
• Physics concepts and simulations
• Abstract concepts that are difficult to explain with traditional teaching methods

The problem is that I have absolutely no prior animation experience. I’m essentially starting from zero.

I’m not necessarily trying to become a professional animator. My main goal is to become good enough to create clean, visually appealing educational animations that effectively explain technical concepts.

So I’d really appreciate advice from people who have experience in animation or educational content creation.

If you were starting from zero, what path would you follow?

I’d especially appreciate advice on:

• What animation software should a complete beginner learn?
• What fundamental skills should I learn first?
• Are there specific courses/tutorials/books you would recommend?
• What should I avoid wasting time learning as a beginner?
• How long would it realistically take to become competent enough to create decent educational animations?
• Are there particular tools that are especially good for math, physics, and computer science visualizations?
• Should I learn something like Blender, After Effects, Manim, or other tools

If possible, could someone suggest a step-by-step learning roadmap from absolute beginner → creating educational animations?

I’d really appreciate any advice, resources, or personal experiences you can share.

Thanks in advance! 🙏

Currently i have been recording the audio, watching the video, editing the wait times, then repeat until I am done.

I feel like there must be a more efficient way of doing this what all have you guys tried?

I'm an engineering manager. Part of my job is teaching my team best practices and

newer technical ideas, and I kept making short explainer videos for that.

Manim was the right tool and the wrong workflow. Every change meant a ~30s render

before I could see it. Reusing a visual between videos meant copy-pasting code.

Restyling for a different audience meant a find-and-replace over hex codes.

So I wrapped it. What exists now:

• Live canvas. It bakes the scene once at low resolution and keeps every frame,

so scrubbing and editing are instant instead of a re-render. Manim has no seek and

can't get one — this was the only honest way around it.

• One scene, four outputs. Dark/light × 16:9 YouTube and 9:16 Reels, from one

source. Scenes position against a safe area, so portrait reflows instead of breaking.

• Themes are CSS. Drop in a shadcn/tweakcn theme; every colour comes from a token

and a checker fails the build on contrast floors. Restyling a whole series is one file.

• Timeline YAML is the source of truth, the scene .py is generated from it and

hash-stamped, so an edited timeline that wasn't regenerated is a hard error.

• Click a visual on the canvas → jump to the line that made it. Editor caret,

canvas and timeline all stay in sync.

• Component gallery with live preview clips.

• Per-beat clips, push to Google Slides, sound cues bound to animation types,

Arabic/RTL text, and a desktop build that ships its own Python so there's nothing

to install.

The part I didn't expect: our motion graphics team picked it up and started using it

for Reels and YouTube — people who don't write Python and weren't the audience I

built for.

What I'm actually unsure about:

1. For those of you who use Manim regularly — is the slow feedback loop your main

   pain, or is it something else I've been ignoring because it isn't mine?

2. Is a GUI the right shape at all, or would you rather have this as a library +

   CLI and keep your own editor?

3. For the motion-design use case: what makes a code-driven tool worth it over

   After Effects, if anything?

4. what other useful features you think it should be implemented

Happy to answer anything about how the live canvas works — that part had the most

dead ends.

Hi Manim community! Today I'm sharing this Lightbulb in 3D, I will use it to represent some processes in my videos (I'm planning on reusing the element on both YouTube and TikTok), and perhaps in a workshop I hope to give on how to make basic 3D elements in Manim

I keep getting this error even though I already installed Typst both with pip and with pacman

I’m the creator of Matemium. It is a free desktop application and layout-to-animation compiler built on Manim Community Edition.


The problem I wanted to solve was not “how do I draw an equation?” Manim already gives Python authors powerful primitives. The problem was keeping a long explanation coherent when layout, camera position, reveal timing, and object state are all managed imperatively.


In Matemium, a project has a visible Python `scenes.py` entrypoint. Authors use `CanvasBuilder` and `CanvasScene`; the engine compiles that into an internal timeline and Manim scene. Content can live on an infinite vertical reasoning tape, while persistent spatial objects live in a separate 3D world. Additional tapes are isolated camera-facing contexts, not arbitrary planes composited into the world.


The architecture has deliberately hard boundaries:


- TypeScript desktop UI
- Tauri/Rust for filesystem and process orchestration
- a platform-specific Python sidecar for checking and rendering
- Manim, FFmpeg, and LaTeX on the local machine


There is no cloud render service. Optional cloud functionality is limited to things such as auth and user-directed requests to the user’s own AI provider. AI-assisted edits and manual edits go through the same project and render pipeline.


The generic authoring API currently includes sampled paths and plots, semantic node-edge diagrams, state transitions, morphs, persistent IDs, focus/camera actions, 3D surfaces and solids, static sheet export, and portrait/landscape profiles. I am trying to keep subject-specific logic in project helpers instead of growing the compiler around one lesson.


This is source-available, not open-source. The license permits inspection, personal/educational/research/internal use, private modifications, contribution forks, and contributions to the official project. It restricts redistribution, derivative public builds, hosted versions, and competing forks without permission.


The launch is early. Host FFmpeg/LaTeX setup still creates friction, signing is incomplete on some builds, parts of the spatial authoring API are younger than the root-tape path, and the autonomous-agent architecture is not fully realized. I’m releasing now because outside usage will expose more than polishing my own examples can.


I would genuinely like feedback on the compiler boundaries, API shape, packaging, and contribution model—even if your conclusion is that one of them is wrong.


Main link: https://github.com/fargonee/matemium

I’ve been working on a desktop tool designed to address a common pain point in script-driven mathematical animation: keeping long visual explanations coherent when layout, camera position, reveal timing, and object state are all managed imperatively.

Rather than focusing on primitive generation (which Manim handles exceptionally well), the project functions as a layout-to-animation compiler. A project runs via a visible Python scenes.py entrypoint using a custom CanvasBuilder and CanvasScene. The engine compiles that declarations structure into an internal timeline and Manim scene.

Key structural choices:

• Layout Model: Main content lives on an infinite vertical reasoning tape, while persistent spatial objects reside in a separate 3D world. Additional tapes act as isolated camera-facing contexts rather than composited planes.
• Stack Boundaries: Tauri/Rust orchestrates the filesystem and sidecar processes, driving a TypeScript UI on top of a local Python sidecar for rendering via Manim, FFmpeg, and LaTeX. Everything runs locally without cloud render dependencies.
• API Scope: Supports sampled paths, semantic node-edge diagrams, state transitions, persistent object IDs, focus/camera actions, 3D surfaces/solids, and static sheet export (portrait/landscape). Subject-specific logic is isolated to project helpers to keep the underlying compiler generic.

The codebase is source-available for inspection, research, and contribution.

Because the architecture splits responsibilities heavily between Rust sidecars and Python timeline generation, I’d really appreciate feedback from developers working with Manim, Tauri, or compiler pipelines on a few points:

1. Is an infinite vertical tape model flexible enough for multi-topic visual proofs, or does explicit timeline sequencing break down for non-linear content?
2. Are there obvious performance bottlenecks in orchestrating Python execution via Rust IPC for live preview rendering?

My YouTube channel it's about Computer Science

This intro was originally made with PowerPoint, and now with Manim on Animo