2 - Manim

Manim, short for Mathematical Animation Engine, is an open-source Python library created by Grant Sanderson in 2015. Sanderson is the creator of the math YouTube channel 3Blue1Brown, which is centered on the visual approach that can be taken when teaching math [29].
The idea behind Manim is to make it possible to create precise animations programmatically. Animating through code makes sense when we are dealing with repeated animations which it would not not make sense to animate manually over and over. Furthermore, programmatic animations work best when the math we want to visualize can be precisely described through code [1].
Figure 2.1 shows an example of a simple animation that can be produced by writing a few lines of code (Code 2.3) using Manim.

Figure 2.1 - Simple scene created with Manim, in which we animate the transformation of a circle into a square.

Manim Community

When Sanderson first created Manim, he did not aim at the creation of a professionally maintained tool for others to use. He initially created the library with the purpose of creating animations for his own 3Blue1Brown channel, with video-specific code available on GitHub [18].
In the year 2020, a group of developers got together and forked it into the community edition, with the purpose of making it more stable, more tested, better documented, faster to respond to community contributions and easier to get started with [6].
The idea of rewriting Manim first came up in November 2019 as an issue on the Manim repository on GitHub [12]. The discussion kept happening on the Manim Discord Server until May 2020, when a small team was assembled to create a community version of Manim [17].

Figure 2.2 - Manim Community logo manim.mobject.logo.ManimBanner

For all the reasons stated above, Sanderson himself suggests to anyone looking to get started with Manim to begin with the community version.
Therefore we decided that all the code written for this thesis should follow the version of the Manim Community. The way our work is documented also follows the community standards, as described in Chapter 4.

Getting started with Manim

In the context of this thesis, there is no point in going into details about the installation process of Manim. There are indeed many ways to approach the installation, which often require operating system specific instructions.
According to our experience, the easiest way to install Manim and its dependencies on Windows is by using the package manager Chocolatey [4]. However, we recommend having a look at the Manim Community documentation before choosing among the different options [13].
Once Manim has been successfully installed, we are ready to produce our first scene. First we need to create a file named example.py with the structure shown in Code 2.1.

Code 2.1 - Manim scene structure.

To run our code, we navigate to the directory containing the desired file using the command line, then we enter a command with the following structure:

  • -m manim, which locates the module manim on the Python module path and executes it as a script;
  • example.py, which is the file that contains our scenes.
Optionally, we can also specify:
  • SceneName, that indicates which scene to run. If not specified, we will be asked to select the scene from a list by entering the corresponding number;
  • -p, which stands for preview, will make the video automatically play when it is done rendering
  • -ql, which stands for low quality. This command make sense when we want a faster rendering. Other options are -qm, -qh and -qk, for medium, high, and 4k quality, respectively.
A complete list of optional commands can be found in the Manim Community documentation [9]. Hence, to produce the scene of Code 2.1 in high quality and with the preview, we execute the following command: python -m manim example.py SceneName -p -qh

Manim components

As seen in Code 2.1, we write the code for creating an animation inside the construct() method of a class that derives from Scene.
Let us look at Code 2.3 that produces the animation of the transformation of a circle into a square presented in Figure 2.1.

Code 2.3 - Code that produces the transformation of a circle into a square (Figure 2.1)

In this simple example we find the main components of Manim:

  • Mobject (Mathematical objects), that is the base objects that can be displayed on screen, such as Circle and Square (lines 5-6) [14];
  • Animation, that can be applied to Mobjects to display a continuous transformation between them, such as Create, ReplacementTranform, Uncreate (lines 8-9-10)
    • [7];
  • Scene, that is where the every Mobject gets added or removed and where every Animation gets played (self.play(), lines 8-9-10).

Let us go into more details about how to deal with Mobjects.
The Mobject class is an abstract class that acts as the base for objects that can be displayed on screen. We do not create Mobjects directly, but rather instances of its derived classes, such as Line, Circle, Square and Text (see Figure 2.3).

Figure 2.3 - Manim most common Mobjects: Line, Circle, Square and Text

By default, Mobjects gets placed at the center of the screen when they are first created. We can move them in different ways, for example by using the methods move_to() or next_to(). The first takes as inputs absolute units with respect to the origin, while the second takes relative units with respect to the Mobject passed as the first argument.

To understand how these units behave, we need to address Manim coordinate system. Different positions on the grid are recalled using a numpy array in the form of (x, y, z). To make the use of these coordinates less cumbersome, Manim provides aliases for the most common ones, which are defined in the file constants.py. The following (Code 2.4) are the ones that we use the most.

Code 2.4 - Aliases for the most common coordinates provided by Manim.

More aliases are available in the documentation [10].

To change the visual aspect of Mobjects we can call methods like set_stroke() or set_fill(), that change respectively the style of the outline and of the inside of the Mobject.

As anticipated, Animations can be applied to Mobjects to produce continuous transformations between them. For example, FadeIn starts by displaying the transparent version of the chosen Mobject and animates the transformation to the fully opaque version of it by gradually increasing the opacity.
A second example is ReplacementTransform, which transforms a Mobject into a target Mobject by creating an interpolation between the two, as seen in Figure 2.1 and Figure 2.3.

More Mobjects and Animations are introduced throughout Chapter 3.

Lastly, Scene is where we add Mobjects and where we play Animations.
To display a Mobject on the screen without animating it, we call add(), which is a method of Scene. In the same way, to remove an object we call remove().
To play Animations we pass them to the method play(), while to set a time interval with no Animations we call the method wait(). The default time duration of these methods is one second, but we can change it through the parameter run_time.