manim-fundamentals

name	manim-fundamentals
description	Core Manim concepts including Scene lifecycle, Mobject hierarchy, coordinate systems, animation lifecycle, and rate functions.

Manim Fundamentals

Core concepts for Manim Community Edition v0.20.1.

Scene Lifecycle

Scene Structure

class MyScene(Scene):
    def setup(self):
        """Called once before construct()
        - Initialize instance variables
        - Create shared objects
        - Set up tracking systems
        """
        self.tracked_objects = []

    def construct(self):
        """Main scene logic
        - Create mobjects
        - Define animations
        - Control timing
        """
        circle = Circle()
        self.play(Create(circle))

    def tear_down(self):
        """Called after construct()
        - Cleanup (rarely needed)
        """
        pass

Scene Types

Scene Type	Use Case	Camera
Scene	Standard 2D animations	Static
MovingCameraScene	2D with zoom/pan	Movable 2D
ThreeDScene	3D animations	3D rotation
ZoomedScene	Picture-in-picture zoom	Zoom inset

Mobject Hierarchy

Base Classes

Mobject (base)
├── VMobject (vector)
│   ├── VGroup
│   ├── Text, Tex, MathTex
│   ├── Circle, Square, Rectangle
│   ├── Line, Arrow, DashedLine
│   ├── Axes, NumberPlane
│   └── Graph, BarChart
├── ImageMobject
├── Group
└── ValueTracker

VGroup - Container for VMobjects

# Create VGroup
group = VGroup(circle, square, triangle)

# Access elements
group[0]  # first element
group[-1]  # last element

# Add/remove
group.add(new_element)
group.remove(element)

# Arrange
group.arrange(DOWN, buff=0.5)
group.arrange_in_grid(rows=2, cols=3)

Common Mobject Methods

# Positioning
obj.move_to(point)           # Absolute position
obj.next_to(other, RIGHT)    # Relative to object
obj.to_edge(UP, buff=0.5)    # Screen edge
obj.to_corner(UL)            # Screen corner
obj.shift(UP * 2)            # Relative shift
obj.align_to(other, LEFT)    # Align edges

# Transformations
obj.scale(0.5)               # Scale uniformly
obj.stretch(2, dim=0)        # Stretch in x
obj.rotate(PI/4)             # Rotate radians
obj.flip()                   # Mirror

# Appearance
obj.set_color(RED)
obj.set_fill(BLUE, opacity=0.5)
obj.set_stroke(WHITE, width=2)

# Information
obj.get_center()
obj.get_width()
obj.get_height()
obj.get_corner(UR)

Coordinate Systems

Default Frame

Frame dimensions: 14.22 x 8 units
Origin: center of screen
+X: right, +Y: up, +Z: out of screen

config.frame_width   # ~14.22
config.frame_height  # 8

Direction Constants

UP    = [0, 1, 0]
DOWN  = [0, -1, 0]
LEFT  = [-1, 0, 0]
RIGHT = [1, 0, 0]
UL = UP + LEFT      # Upper left
UR = UP + RIGHT     # Upper right
DL = DOWN + LEFT    # Down left
DR = DOWN + RIGHT   # Down right
ORIGIN = [0, 0, 0]

Axes Coordinate System

axes = Axes(
    x_range=[-3, 3, 1],   # [min, max, step]
    y_range=[-2, 2, 0.5],
    x_length=8,           # Screen units
    y_length=5,
)

# Convert between coordinate systems
point = axes.c2p(x, y)        # Axes coords → screen point
x, y = axes.p2c(point)        # Screen point → axes coords

# Plot function
graph = axes.plot(lambda x: x**2, color=BLUE)

# Get point on graph
point = graph.get_point_from_function(x_value)

Animation Lifecycle

Basic Animation

self.play(animation, run_time=1)  # Default 1 second
self.wait(duration)                # Pause

Animation Parameters

self.play(
    Create(circle),
    run_time=2,              # Duration in seconds
    rate_func=smooth,        # Timing curve
    lag_ratio=0.5,           # For composed animations
)

Animation Sequencing

# Simultaneous
self.play(anim1, anim2)

# Sequential in one play
self.play(Succession(anim1, anim2, anim3))

# Staggered start
self.play(LaggedStart(anim1, anim2, anim3, lag_ratio=0.3))

# With waits between
self.play(anim1)
self.wait(0.5)
self.play(anim2)

Rate Functions

Rate functions control animation timing curves.

Built-in Rate Functions

# Linear (constant speed)
rate_func=linear

# Smooth (ease in/out)
rate_func=smooth           # Default

# Rush functions
rate_func=rush_into        # Accelerate at end
rate_func=rush_from        # Decelerate from start

# There and back
rate_func=there_and_back   # Go and return
rate_func=there_and_back_with_pause

# Exponential
rate_func=exponential_decay

# Step functions
rate_func=lingering        # Slow at end
rate_func=running_start    # Overshoot at start

# Double smooth
rate_func=double_smooth    # Extra smooth

Custom Rate Function

def my_rate_func(t):
    """
    t: progress from 0 to 1
    return: modified progress 0 to 1
    """
    return t ** 2  # Quadratic ease-in

self.play(Create(circle), rate_func=my_rate_func)

Configuration

Config Object

from manim import config

# Frame settings
config.frame_width   # Width in units
config.frame_height  # Height in units
config.pixel_width   # Output width in pixels
config.pixel_height  # Output height in pixels

# Quality presets
config.quality      # "low_quality", "medium_quality", etc.
config.frame_rate   # FPS

# Colors
config.background_color  # Scene background

Quality Settings

Quality	Resolution	FPS
low	480p	15
medium	720p	30
high	1080p	60
fourk	2160p	60

Key Imports

from manim import *  # Import everything

# Or selective imports
from manim import (
    Scene,
    Circle, Square, Rectangle,
    Text, Tex, MathTex,
    VGroup,
    Create, Write, FadeIn, FadeOut,
    Transform, ReplacementTransform,
    Axes, NumberPlane,
    ValueTracker,
    always_redraw,
    config,
    UP, DOWN, LEFT, RIGHT, ORIGIN,
    BLUE, RED, GREEN, YELLOW, WHITE,
)

Common Patterns

Add Then Animate

# Create and add
circle = Circle()
self.add(circle)

# Then animate changes
self.play(circle.animate.shift(RIGHT * 2))
self.play(circle.animate.scale(0.5).set_color(RED))

Animate Method

# .animate creates animation from property changes
self.play(
    obj.animate.shift(UP * 2),        # Move
    obj.animate.scale(1.5),           # Scale
    obj.animate.set_color(RED),       # Color
    obj.animate.rotate(PI/4),         # Rotate
)

# Chain multiple changes
self.play(
    obj.animate.shift(UP).scale(0.5).set_color(BLUE)
)

Copy Pattern

# Create a copy to transform
copy = original.copy()
self.play(Transform(original, target))

# Or for cleaner replacement
self.play(ReplacementTransform(original, target))