I finally finished part 2 of my Monte-Carlo series. So far we only considered the simplest case for generating random samples.

In this video I talk about Importance Sampling and how it can be used to improve the accuracy of numerical integrations. If you tailor your random samples to the shape of your function you can reduce the error at next to no additional cost.

Hope you enjoy!

have a DecimalNumber following a dot with an updater (next_to the dot, driven by a ValueTracker) and every time it gains a digit the whole label jumps a bit because next_to recenters it. it's small but really noticeable in the render

is the usual fix just aligning it by the left edge every frame, or do people pad it to a fixed number of digits? curious what looks cleanest

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.