Hello, how are you guys doing? This is my third video on the channel, and unlike the previous two videos, this video features a mix of math and astronomy set in a historical story format.

Of course, I'd love to hear your feedback on the video and what needs improvement, and of course, I'm counting on you: if you like the video, show some love for it and the channel ❤️

Note: There is an English Audio Track and also English subtitles

Hey everyone!

We all love 3Blue1Brown's animations and Ben Eater’s interactive demos, but local Manim rendering is slow, and web solutions are usually too heavy.

Could we use stock Manim code directly in the browser with real-time interactivity, while keeping things lightweight? I think I've found a way!

3b1b's classic Fourier transform animation recreation in wanim playground

You can check out examples at gallery, or play with it and share your creations at playground. Over at here, I recreated 3b1b's classic Fourier transform animation. After the initial animation plays, you can drag the slider to change the winding frequency and watch the live updates yourself.

Several great projects have brought Manim to the web, but they either require rewriting code in JavaScript or loading a bulky Pyodide environment.

My idea was to treat Manim code as a DSL and transpile it into JS while keeping the API compatible. It sounded crazy, but it works! more info

Thanks to its compact footprint, scenes can be embedded anywhere via web components and other formats. Looking ahead in this AI era, I also envision Manim code serving as a real-time blackboard for AI to explain concepts to people!

Huge thanks to Grant Sanderson and the Manim community, to Ben Eater, and to pioneer projects like manim-web. Also, special thanks to my good friends OpenCode Go and DeepSeek for their help throughout this complex engineering journey, which helped make all of this possible!

I’m eager to hear your feedback and see your creativity unleashed!
Github Repo: https://github.com/Acfboy/Wanim
Website: https://wanim.org/

Yes the fact I'm posting here is because MotionGfx is highly inspired by Manim (and also Motion Canvas)!

A while ago, I posted something about MotionGfx, a backend agnostic motion graphics crate written in Rust. And in that post I hinted something about an editor. Well this is it, I'm introducing Moxie, an editor built in Bevy, powered by MotionGfx! Moxie is right now in its very early phase, so not every feature is implemented yet, so expect workflow hiccups, and things not working! I'm still working on the export feature (along with many core features), so you can't directly export your animations yet!

As you may have noticed in the screenshot, Moxie is not like any of the other editors you see out there! We are integrating the command based technology that MotionGfx (and Manim/Motion Canvas) is based on into the editor. This result in a really compact timeline (vertically), easy edits (LEGO like drag & drop), and most importantly of all, propagative actions everywhere! This means your edits from the first action can and will affect the animations down the line! Ofc this is a deterministic effect, so you can reason about the change pretty easily.

In the MotionGfx's website: https://motiongfx.voxell.dev (sign up to our email list/newsletter here), I do explain about some of the concepts I mentioned above if you're familiar with command based animation workflows (like delta changes, propagative timing, action relationships, scripting, etc.).

If you're wondering will there be plugin support, yes it is planned. And yes, we will also support scripting directly in the editor in the near future!

Is there an official MCP released by the Manim community or the Manim CLI?

I compared four AI explainer-video tools on one lesson (generative models, taxonomy and history). Only one of them, make-it-click, writes real Manim scenes. The others use HTML and Remotion. Same voice for all; the clip is 30 s from each (make-it-click is 2/4).

My read: make-it-click is the closest to the 3b1b look and it was the cheapest run (~8 min, ~120k tokens). Its weak spot: some scenes open on an empty frame for a beat before anything draws.

Curious what Manim users think: what would you change in the 2/4 part?

The Riemann zeta function is defined as the sum of reciprocal powers of all positive integers for values where the real part of the input is greater than 1. When Re(s)>1 where s is a complex number the series always converges. However if we want to calculate the series for negative real values of s it gets tricky, Riemann found a formula from complex analysis and by using analytic continuation to extend the definition of the zeta function to the rest of the complex plane he was able to prove that ζ(-1)=-1/12 where ζ(-1) = 1+2+3+4+5… This would be impossible in standard arithmetic and calculus as the result would simply diverge to infinity. This is deeply connected with Ramanujan’s summation method where he reveals the same exact result. Now you might ask what significance this result has, the answer lies in when physicists perform experiments in a lab, when the measurements the physical force between the plates, it isn’t infinite, nature automatically subtracts the infinite vacuum background and leaves -1/12 behind!

And don’t forget to follow @maths.1089 & @mathematicsmadesimple.x for more videos just like this!

#math #riemann #zetafunction #analyticcontinuation #manim

Four months ago, we shared Academa Studio here, our browser editor for making Manim animations with realtime preview. At the time, the engine was private and only available through Studio. Today, we are open sourcing ManimGX, which you can install and run locally.

The GitHub repository: https://github.com/academa-labs/manimgx

ManimGX is a from-scratch implementation targeting ManimCE's Python API, with a Rust renderer built on wgpu. Most ManimCE code runs after changing the import from manim to manimgx. Our documentation covers compatibility and the places where behavior differs: https://manimgx.academa.ai

The motivation is the same as before: waiting for renders makes polishing an animation a slow process. We wanted to make that loop faster while keeping the familiar Python API.

You can install it with:

pip install manimgx

You only need Python 3.13+. All of the fonts, typesetting, and video encoding are included. So there is no separate LaTeX or FFmpeg installation required.

To preview an existing scene:

manimgx preview scene.py

The preview reloads whenever you save your scene.

A few other things ManimGX supports:

• The API is fully statically typed, including keyword arguments and .animate chains.
• Built-in voiceover synchronization.
• Browser execution through Pyodide and WebGPU, with an npm package for embedding animations in your website without a render server.
• manimgx inspect creates storyboards, timelines, and layout feedback for coding agents. This aims to speed up the writing and polishing loop.

The gallery has examples together with their Python source. If you just want to play around with it in the browser, you can still find it in Studio.

Credit to Grant Sanderson and the Manim Community contributors whose work this builds on. Happy to answer questions in the comments, and we'd love to hear how it works with your scenes.

I used a custom Python compositor for the finished film. Sharing for feedback on the mathematical storytelling.

The roughly 13-minute sequence goes from the power-series solution to ladder operators, then to stationary states, superpositions, and coherent states: https://youtu.be/7_DcdXVh5mc

A central visual distinction is between the changing phase of an energy eigenstate and its stationary probability density. The coherent-state sequence then gives a different kind of motion to compare with it.

For people who animate mathematics, how would you judge the pacing between derivation and visualization here? I would especially value feedback on whether the transitions make the connection between the algebra and the plotted states clear.

This video visualizes the complex function f(z)=z^4 in three-dimensional space. Let z=x+yi. The video explores how the complex function transforms the input complex plane and presents the resulting geometric structure through 3D visualization.

Hello once again guys!

I just wanted to share a quick ManimWire update: I've started putting together a YouTube playlist covering the fundamentals of the app.

I've uploaded the first 5 videos so far, aimed at helping people get started with the basics. From here, I'm planning to add more videos every weekend, gradually covering more advanced features and increasingly complex workflows.

Additionally, ManimWire now supports GPU-accelerated previews and rendering through OpenGL on compatible systems.

If you're following the project or trying out ManimWire, I hope these make it a little easier to get started!

This is the playlist: https://www.youtube.com/watch?v=DIn7ff8lPDQ&list=PLPuFhG43QEO8&index=1

I've also prepared installers for MacOS and Windows, you can download them from this page: https://shiftabit.com/manimwire/

Note: The installers bundle the required dependencies, except LaTeX, which you’ll need to install separately for LaTeX-based text and equations.

GitHub repo: https://github.com/Sidsector9/ManimWire

This video presents a geometric visualization of the complex function f(z)=z^3. A complex number z=(x+yi) two dimensions: the real part and the imaginary part. The function value f(z) is also a complex number. Through a three-dimensional representation, we can visually observe the geometric transformation produced when the complex plane is mapped by the complex function z^3. This video is part of my ongoing project on visualizing the four-dimensional mathematical structure of complex functions in three-dimensional space. The theoretical foundation behind the output visualization of the complex functions presented in these videos comes from my own mathematical paper. I included a link to the paper in the descriptions of the previous videos, so I will not repeat the link here. I sincerely hope that someone will take the time to read my paper and understand the ideas behind it. I have put a great deal of time, effort, and passion into this work, and I would truly hate to see it disappear without being noticed. The mathematics in the paper is actually quite straightforward. I believe that once you start reading it, the main ideas are not difficult to understand. I hope this work can reach someone who is willing to read it, understand it, and perhaps see the ideas from a different perspective.

so im coding with manim using computer modern font (cmu) and for some reason when the text size is small (ex: 12pt) the letter spacing is all over the place. its only avoidable with the default manim font, any other font would reproduce this problem.

If you have a forecast for realized volatility, should you delta hedge using that or should you delta hedge using implied volatility? What are the implications of each choice? And how does stochastic volatility impact the outcome of that decision?

I hope you guys are enjoying these videos on volatility trading, even though they are lighter on pure math/science than most posted here. Do you find videos that focus more on the applications of math than the math itself still interesting? This is the only place where I get downvotes when I post, although I do get more upvotes. Kinda ironic since this is exactly where you're supposed to post Manim videos and my videos are 100% made with Manim.

Spending 2 weeks on vesuialising and explaining the doppler effect to get a full 10 minutes of manim mnimation , i love doing that creating animation and explaining something but if I can't get only 1 k view i think i should stop posting this and keep it to my self , can you just whatch thi video and tell me where is the error

Hi all!

I published my first proper manim video!!

It starts with the sentence “My favourite rock band is…” and follows its journey inside an LLM, all visually animated!

https://youtu.be/ikdxxeIn4HQ?si=8AwWyxQERo_R2n6B

I tried to make the video as beginner friendly as possible but still detailed enough to give a good overview for how an LLM works end to end and how the LLM “finds out” my favourite band. Or at least how some of the earlier models…

My aim is to help people that are not just curious about AI but also want a deeper dive into the magic “Black box”, or people that want to get started but doesn’t know how!

This is my first attempt at the topic, so any kind of feedback is welcomed and will be greatly appreciated as it will help me improve over time, and hopefully on other videos.    

I really hope it can help someone with their AI/ML journey!

P.S. Most of what I learned about Manim was with this really nice chap that runs a channel called "TheoremOfBeethoven". I got all his courses and even had a couple of 1-2-1 with him!! It really paid off!! So thanks for the classes Alex!

And thank you all involved in the manim community that made such an incredible and accessible framework!! It is really appreciated!! :)

Thanks!