NAMSSN UI Chapter

• • Laptop (recommended long-term): install Python and Manim once, then run from your terminal.
• • Online notebook: use a shared Jupyter / Google Colab notebook where Manim is pre-installed.

For a student community, a shared notebook can be a gentle starting point, while those who want full control set up Manim locally using the detailed setup guide.

The exact commands depend on operating system and Python version, but the rough pattern is:

# 1. Create a virtual environment (optional but recommended)
python -m venv manim-env
# Activate the environment (on Windows)
manim-env\Scripts\activate
# or (on macOS / Linux)
source manim-env/bin/activate

# 2. Install Manim Community Edition
pip install manim

After installation, you should be able to run a command like manim -h in your terminal and see Manim’s help text. The full step-by-step version, including screenshots ideas and troubleshooting, lives in the Manim setup guide.

Suppose you save a file called hello_manim.py containing one Scene class. A typical command to render it looks like:

manim hello_manim.py HelloWorld -pqh

• • HelloWorld is the name of the Scene class.
• • -p opens the video after rendering.
• • -q sets quality (e.g. -ql for low, -qh for high).

The editor on this page helps you write the code. To actually see the animation, you copy it into a .py file or notebook and run Manim there.

from manim import *

class HelloWorld(Scene):
    def construct(self):
        text = Tex("Hello, NAMSSN UI!")
        self.play(Write(text))
        self.wait(1)

This creates a white screen, writes the text, and holds for one second.

You will see three recurring types of objects:

• • Scenes — containers for animations (subclasses of Scene).
• • Mobjects — “mathematical objects”: text, shapes, graphs, etc.
• • Animations — actions that move or transform mobjects (Write, FadeIn, Transform, …).

Think of it as: define mobjects → choose animations → play them in order. The detailed story, with more labelled examples, is in Basics Module A.

title = Text("ODE–Integration Bee 2.0")
equation = MathTex(r"\int_0^1 x^n\,dx = \frac{1}{n+1}")

• • Text handles regular words.
• • MathTex (or Tex) handles LaTeX maths strings.

title.to_edge(UP)
equation.next_to(title, DOWN, buff=0.5)

Common positioning helpers: to_edge, next_to, shift, scale.

A typical slide-like scene: a title at the top, an equation in the centre, a short remark below. The full explanation with diagrams is under Basics Module C.

square = Square().set_fill(color=BLUE, opacity=0.5)
circle = Circle().set_stroke(color=YELLOW, width=4)
circle.next_to(square, RIGHT)

You can change set_fill, set_stroke, and use colours like BLUE, GREEN, RED, GOLD, …

line = NumberLine(x_range=[-1, 4, 1])
dot = Dot(color=RED).move_to(line.n2p(0))

self.play(Create(line))
self.play(FadeIn(dot))
self.play(dot.animate.move_to(line.n2p(3)))

This simple idea (a moving point on a line) already gives you a nice way to demonstrate limits, sequences, or “time” along a process.

axes = Axes(
    x_range=[-2, 2, 1],
    y_range=[-1, 4, 1],
    x_length=6,
    y_length=4,
)

graph = axes.plot(lambda x: x**2, color=GREEN)
self.play(Create(axes), Create(graph))

k = ValueTracker(1)

def get_graph():
    return axes.plot(lambda x: x**2 + k.get_value(), color=BLUE)

graph = get_graph()
self.play(Create(axes), Create(graph))

for new_val in [0, 2, -1]:
    self.play(
        k.animate.set_value(new_val),
        Transform(graph, get_graph()),
        run_time=1.2
    )

ValueTracker + Transform is a powerful pattern for “live” mathematics. The projects page builds on this to create full clips.

from manim import *

class IntegralStory(Scene):
    def construct(self):
        title = Text("A friendly integral").to_edge(UP)
        eq1 = MathTex(r"\int_0^1 x^n\,dx").next_to(title, DOWN)
        eq2 = MathTex(r"= \frac{1}{n+1}").next_to(eq1, DOWN)

        self.play(Write(title))
        self.play(Write(eq1))
        self.wait(0.5)
        self.play(Transform(eq1, eq2))
        self.wait(1)

Once you are comfortable, you can use self.camera.frame to zoom into part of the screen, or move attention across a long derivation. This is more advanced and can be explored from the Manim documentation and shared example files linked from NAMSSN resources.

For NAMSSN UI, it is enough in the first year if students can produce clear, static scenes with clean animations. Camera tricks can come later.