repository·master·Indexed 13 days ago
https://github.com/3b1b/manimA programmatic animation engine designed by 3Blue1Brown for creating precise mathematical explanatory videos. ManimGL uses Python and OpenGL to leverage the GPU for higher efficiency, faster rendering speeds, and support for real-time rendering and interactive sessions.
Manim requires the following system-level dependencies:
PyOpenGL Python package.The manimlib/ directory contains the core logic of the library. Key subdirectories and files include:
scene/: Contains the base classes for creating animations, such as Scene (the basic class) and ThreeDScene.mobject/: Contains all mathematical objects (Mobjects). This includes VMobject (vectorized mobjects), PMobject (point-based mobjects), SVGMobject, and specialized objects like Tex and Text.animation/: Contains the logic for animating Mobjects, categorized by type (e.g., creation.py, movement.py, rotation.py, transform.py).camera/: Handles the Camera and CameraFrame logic.shaders/: Contains GLSL scripts used for rendering, including vertex and fragment shaders for surfaces, images, and curves.utils/: A collection of utility functions for colors, bezier curves, file operations, and more.default_config.yml: The default configuration file for the library.config.py: Handles the processing of CLI flags.tex_templates/: Preset LaTeX templates for rendering mathematical text.There are two primary versions of Manim available. Choosing between them depends on your rendering needs and community preference:
3b1b/manim (the version this documentation refers to): Maintained by Grant Sanderson. It utilizes OpenGL and GLSL to leverage the GPU for rendering. This version is optimized for higher efficiency, faster rendering speeds, and supports real-time rendering and interactive sessions.
ManimCommunity/manim: Maintained by the Manim Community Dev Team. It uses multiple backend rendering options and features more extensive documentation and an open contribution community.
Several constants in manimlib/constants.py are dynamically determined by your configuration files (default_config.yml or custom_config.yml).
Frame and Pixel Shape (determined by camera config):
ASPECT_RATIOFRAME_HEIGHT, FRAME_WIDTHFRAME_Y_RADIUS, FRAME_X_RADIUSDEFAULT_PIXEL_HEIGHT, DEFAULT_PIXEL_WIDTHDEFAULT_FPSBuffs (determined by size config):
SMALL_BUFF, MED_SMALL_BUFF, MED_LARGE_BUFF, LARGE_BUFFDEFAULT_MOBJECT_TO_EDGE_BUFFDEFAULT_MOBJECT_TO_MOBJECT_BUFFAnimations in Manim are used to change the state of Mobjects over time. They are located in manimlib/animation/ and include:
Create).transform.py, transform_matching_parts.py).Manim uses three-dimensional coordinates represented as numpy.ndarray. You can use these constants to position Mobjects relative to the origin, axes, or frame edges.
Directional Vectors:
ORIGIN: (0, 0, 0)UP, DOWN, LEFT, RIGHT, IN, OUTX_AXIS, Y_AXIS, Z_AXISDiagonal Abbreviations:
UL (Upper Left): UP + LEFTUR (Upper Right): UP + RIGHTDL (Down Left): DOWN + LEFTDR (Down Right): DOWN + RIGHTFrame Edges:
TOP: Top edge of the frameBOTTOM: Bottom edge of the frameLEFT_SIDE: Left edge of the frameRIGHT_SIDE: Right edge of the frame# Example usage of coordinate constants
obj.move_to(UP * 2 + RIGHT)
obj.move_to(UL)
obj.move_to(TOP)The Axes class allows you to create a coordinate system for placing Mobjects. You can define ranges for the x and y axes, set dimensions, and configure the appearance of the axes using axis_config or specific axis configurations like y_axis_config.
Key features include:
axes.c2p(x, y) (short for coords_to_point) to convert mathematical coordinates to screen points, and axes.p2c(point) (short for point_to_coords) to do the reverse.axes.add_coordinate_labels() to add numerical labels to the axes.axes.get_h_line(point) and axes.get_v_line(point) to create horizontal and vertical lines relative to a point. Wrapping these in always_redraw ensures they update as the point moves.Axes, you can use ThreeDAxes, NumberPlane, and ComplexPlane.axes = Axes(
x_range=(-1, 10),
y_range=(-2, 2, 0.5),
height=6,
width=10,
axis_config={
"stroke_color": GREY_A,
"stroke_width": 2,
},
y_axis_config={
"include_tip": False,
}
)
axes.add_coordinate_labels(font_size=20, num_decimal_places=1)
dot = Dot(fill_color=RED)
dot.move_to(axes.c2p(0, 0))
# To keep lines attached to a moving dot:
h_line = always_redraw(lambda: axes.get_h_line(dot.get_left()))
v_line = always_redraw(lambda: axes.get_v_line(dot.get_bottom()))You can enable an interactive IPython terminal session at the end of your scene by calling self.embed() inside the construct() method. This allows you to execute commands live while the OpenGL window is open.
When in interactive mode, self.play can be abbreviated to play.
Example interactive commands:
play(circle.animate.stretch(4, dim=0))play(Rotate(circle, TAU / 4))play(circle.animate.shift(2 * RIGHT), circle.animate.scale(0.25))play(circle.animate.apply_complex_function(lambda z: z**2))exit() to close the session.from manimlib import *
class SquareToCircle(Scene):
def construct(self):
circle = Circle()
self.add(circle)
# ... other code ...
self.embed()Updaters allow you to run code every frame to ensure a Mobject responds to changes in other objects or its own properties.
.add_updater(func): The most direct way. The function func is called every frame. It can take one argument (the mobject itself) or two (the mobject and the time elapsed since the last frame).
mob1.add_updater(lambda mob: mob.next_to(mob2))always(f, x): A convenience function that executes f(x) every frame. This is useful for positioning.
always(label.next_to, brace, UP)f_always(f, g): Similar to always, but it executes f(g()) every frame. This is useful when the argument to the function is itself a method call that needs to be re-evaluated.
f_always(number.set_value, square.get_width)always_redraw(func, *args): Creates a new Mobject from scratch every single frame. This is ideal for complex shapes (like a Brace) that need to be recalculated based on the geometry of another object.
# 1. always_redraw for a brace that follows a square
brace = always_redraw(Brace, square, UP)
# 2. always for positioning a label
always(label.next_to, brace, UP)
# 3. f_always for updating a value based on a method call
f_always(number.set_value, square.get_width)
# 4. Manual add_updater for custom logic
square.add_updater(lambda m: m.set_width(w0 * math.cos(self.time - now)))Mobjects (Mathematical Objects) are the building blocks of Manim. They are organized into several types within manimlib/mobject/:
vectorized_mobject.py).point_cloud_mobject.py), which are composed of points.tex_mobject.py) or standard text implemented via ManimPango (text_mobject.py).ParametricFunction, NumberLine, VectorField, and Matrix.Before contributing, determine which version of Manim your changes are intended for:
ManimCommunity/manim for broad community features, packaging changes, or beginner-oriented documentation. This version has a larger contributor workflow and more active community review.Coordinate systems (including Axes, ThreeDAxes, NumberPlane, and ComplexPlane) and NumberLine no longer use individual min/max parameters. Instead, use the x_range and y_range parameters.
These parameters must be a numpy.array containing three values: [Minimum, Maximum, Step Size].
Example for Axes:
axes = Axes(x_range=[ -5, 5, 1], y_range=[ -3, 3, 0.5])For NumberLine, the x_range follows the same [min, max, step] format. Note that tip_width and tip_height have been replaced by a tip_config dictionary.
axes = Axes(x_range=[-5, 5, 1], y_range=[-3, 3, 0.5])