manim_skill Documentation

The manimce-best-practices skill contains detailed rules and examples for various ManimCE domains. Refer to the following categories for specific implementation guidance:

• Core Concepts: Scene structure, Mobjects, and Animation classes.
• Creation & Transformation: Using Create, Write, Transform, and ReplacementTransform.
• Text & Math: Styling Text and using MathTex for LaTeX rendering.
• Styling: Managing colors, gradients, fill, and stroke.
• Positioning: Using move_to, next_to, align_to, and VGroup for layout.
• Coordinate Systems: Working with Axes, NumberPlane, and ThreeDScene.
• Animation Control: Using Rate functions, Updaters, and ValueTracker for dynamic movement.
• Configuration: Managing manim.cfg and CLI options.

To create a camera that follows an object (like an observer) to simulate a first-person perspective, use the always.match_z method on the frame. This ensures the camera's Z position continuously tracks the target object's Z position.

frame.always.match_z(observer)

In ManimGL, camera control is managed via self.camera.frame, which is a CameraFrame object (a type of Mobject). If you are using an InteractiveScene, you can use self.frame as a convenient shortcut. You can manipulate the camera's orientation using Euler angles (theta, phi, gamma) to position the view in 3D space.

frame = self.camera.frame

# Set euler angles for 3D orientation
frame.set_euler_angles(
    theta=-30 * DEGREES,
    phi=70 * DEGREES,
)

To visualize a real-time graph of a moving object's position (e.g., $x(t)$), use a TracedPath attached to a dummy Point.

1. Create a Point object.
2. Add an updater to the Point that moves it to the coordinate corresponding to the current time and position (using axes.c2p).
3. Create a TracedPath that follows the center of that Point.

tracking_point = Point()
tracking_point.add_updater(lambda p: p.move_to(
    axes.c2p(time_tracker.get_value(), spring.get_x())
))
position_graph = TracedPath(tracking_point.get_center, stroke_color=BLUE)

Manim provides two primary ways to group mobjects, depending on the types of objects you are combining:

1. VGroup (Vectorized Group): Use this for grouping VMobjects (Vectorized Mobjects). This is the most common type of group and offers better performance and compatibility for vector-based shapes.
2. Group: Use this when you need to mix different mobject types that are not all VMobjects, such as combining a Circle (VMobject) with an ImageMobject or Text.

When you apply transformations (like .shift(), .scale(), or .set_color()) to a group, the operation is applied to all members of that group.

from manim import *

# Use VGroup for VMobjects
vgroup = VGroup(Circle(), Square(), Triangle())
vgroup.set_color(RED)

# Use Group for mixed types
group = Group(Circle(), Text("Hello"))

A Mobject (Mathematical Object) is the base class for all displayable objects in Manim. The hierarchy determines how objects are rendered and animated:

• Mobject: The base class.
• VMobject (Vectorized Mobject): The most common type, defined by Bézier curves. Includes shapes like Circle, Square, Line, Text, Axes, and the container VGroup.
• ImageMobject: Used for displaying images.
• PMobject: Used for point clouds.
• Group: A collection for non-VMobject items.

The repository supports two distinct, incompatible versions of Manim. Choosing the right one depends on your project needs:

Manim Community Edition (manim)

• Best For: Production use, educational content, and collaborative projects.
• Focus: Stable, well-documented, and community-maintained.
• CLI Command: manim
• Import Pattern: from manim import *

ManimGL (manimgl)

• Best For: Interactive development, 3D scenes, and rapid prototyping.
• Focus: Grant Sanderson's (3Blue1Brown) original version with OpenGL rendering.
• CLI Command: manimgl
• Import Pattern: from manimlib import *

Warning: Code written for one version will not work with the other without modifications.

When creating multiple Mobjects in a loop and assigning each a unique updater, you must use a closure. This ensures that each updater captures the specific state/instance of the Mobject it is intended for, rather than all updaters referencing the last object created in the loop. Inside the updater, always use the mob argument provided by the updater signature rather than the loop variable.

for i in range(n):
    dot = Dot(...)
    def make_updater():  # Closure captures current state
        def update(mob, dt):
            # use mob, not dot
            ...
        return update
    dot.add_updater(make_updater())