manimgl-best-practices
adithya-s-k/manim_skill
Best practices for ManimGL (3Blue1Brown's OpenGL animation engine) with interactive development, 3D rendering, and LaTeX math.
What is manimgl-best-practices?
ManimGL is Grant Sanderson's OpenGL-based animation framework for creating mathematical visualizations. Use this skill when working with InteractiveScene, Tex, camera frames, or the manimgl CLI—not for Manim Community Edition. Covers interactive development workflows, 3D rendering, LaTeX coloring, and checkpoint-based iteration.
- Interactive development with -se flag and checkpoint_paste() workflow
- 3D scene rendering with camera control via self.frame.reorient()
- LaTeX math rendering with Tex class and tex_to_color_map (t2c) for selective coloring
- Animation classes: ShowCreation, Transform, ReplacementTransform, LaggedStart, Succession
- Mobject types: VMobject, Groups, Text, Tex, 3D surfaces (Sphere, Torus, parametric)
- Camera frame manipulation, fix_in_frame() for screen-space objects, and self.embed() debugging
How to install manimgl-best-practices
npx skills add https://github.com/adithya-s-k/manim_skill --skill manimgl-best-practices- Python 3.7+
- manimgl package installed (pip install manimgl)
- Basic understanding of Python classes and decorators
- LaTeX knowledge helpful for Tex() expressions
How to use manimgl-best-practices
- 1.Install manimgl: pip install manimgl
- 2.Create a scene class inheriting from InteractiveScene with a construct() method
- 3.Use manimgl CLI to render: manimgl scene.py MyScene
- 4.For interactive development, use -se flag: manimgl scene.py MyScene -se 15
- 5.In interactive mode, use checkpoint_paste() to run code snippets with or without animations
- 6.Consult rule files (scenes.md, animations.md, tex.md, etc.) for specific patterns
- 7.Use provided templates (basic_scene.py, 3d_scene.py, math_scene.py) as starting points
Use cases
- Creating mathematical derivation videos with animated equations and color-coded terms
- Building 3D visualizations with rotating camera angles and dynamic surfaces
- Developing animations interactively by running code snippets and previewing instantly
- Rendering educational content with synchronized text, shapes, and transformations
- Debugging animation timing and positioning using embedded IPython shells
- Mathematics educators and content creators
- 3D visualization developers
- Animation engineers working with Grant Sanderson's framework
- Researchers creating educational videos
- Anyone migrating from or comparing to Manim Community Edition
manimgl-best-practices FAQ
ManimGL uses manimlib imports, manimgl CLI, InteractiveScene, ShowCreation, and self.frame. Manim CE uses manim imports, manim CLI, Scene, Create, and self.camera.frame. They are separate packages with different APIs.
Use the t2c (tex_to_color_map) parameter: Tex(R'E = mc^2', t2c={'E': BLUE, 'm': GREEN, 'c': YELLOW}). Or use set_color_by_tex() after creation.
The -se flag (skip to end) drops you into an interactive IPython shell at a specified line number, preserving animation state. Useful for iterative development: manimgl scene.py MyScene -se 20
Use self.frame.reorient(phi, theta, gamma, center, height) to set camera angles. Animate it with self.play(self.frame.animate.reorient(...)).
In interactive mode, checkpoint_paste() runs clipboard code with animations. Use checkpoint_paste(skip=True) to run instantly, or checkpoint_paste(record=True) to record output.
Full instructions (SKILL.md)
Source of truth, from adithya-s-k/manim_skill.
name: manimgl-best-practices
description: |
Trigger when: (1) User mentions "manimgl" or "ManimGL" or "3b1b manim", (2) Code contains from manimlib import *, (3) User runs manimgl CLI commands, (4) Working with InteractiveScene, self.frame, self.embed(), ShowCreation(), or ManimGL-specific patterns.
Best practices for ManimGL (Grant Sanderson's 3Blue1Brown version) - OpenGL-based animation engine with interactive development. Covers InteractiveScene, Tex with t2c, camera frame control, interactive mode (-se flag), 3D rendering, and checkpoint_paste() workflow.
NOT for Manim Community Edition (which uses manim imports and manim CLI).
How to use
Read individual rule files for detailed explanations and code examples:
Core Concepts
- rules/scenes.md - InteractiveScene, Scene types, and construct method
- rules/mobjects.md - Mobject types, VMobject, Groups, and positioning
- rules/animations.md - Animation classes, playing animations, and timing
Creation & Transformation
- rules/creation-animations.md - ShowCreation, Write, FadeIn, DrawBorderThenFill
- rules/transform-animations.md - Transform, ReplacementTransform, TransformMatchingTex
- rules/animation-groups.md - LaggedStart, Succession, AnimationGroup
Text & Math
- rules/tex.md - Tex class, raw strings R"...", and LaTeX rendering
- rules/text.md - Text mobjects, fonts, and styling
- rules/t2c.md - tex_to_color_map (t2c) for coloring math expressions
Styling & Appearance
- rules/colors.md - Color constants, gradients, RGB, hex, GLSL coloring
- rules/styling.md - Fill, stroke, opacity, backstroke, gloss, shadow
3D & Camera
- rules/3d.md - 3D objects, surfaces, Sphere, Torus, parametric surfaces, lighting
- rules/camera.md - frame.reorient(), Euler angles, fix_in_frame(), camera animations
Interactive Development
- rules/interactive.md - Interactive mode with
-seflag, checkpoint_paste() - rules/frame.md - self.frame, camera control, reorient, and zooming
- rules/embedding.md - self.embed() for IPython debugging, touch() mode
Configuration & CLI
- rules/cli.md - manimgl command, flags (-w, -o, -se, -l, -h), rendering options
- rules/config.md - custom_config.yml, directories, camera settings, quality presets
Working Examples
Complete, tested example files demonstrating common patterns:
- examples/basic_animations.py - Basic shapes, text, and animations
- examples/math_visualization.py - LaTeX equations and mathematical content
- examples/graph_plotting.py - Axes, functions, and graphing
- examples/3d_visualization.py - 3D scenes with camera control and surfaces
- examples/updater_patterns.py - Dynamic animations with updaters
Scene Templates
Copy and modify these templates to start new projects:
- templates/basic_scene.py - Standard 2D scene template
- templates/interactive_scene.py - InteractiveScene with self.embed()
- templates/3d_scene.py - 3D scene with frame.reorient()
- templates/math_scene.py - Mathematical derivations and equations
Quick Reference
Basic Scene Structure
from manimlib import *
class MyScene(InteractiveScene):
def construct(self):
# Create mobjects
circle = Circle()
# Add to scene (static)
self.add(circle)
# Or animate
self.play(ShowCreation(circle)) # Note: ShowCreation, not Create
# Wait
self.wait(1)
Render Command
# Render and preview
manimgl scene.py MyScene
# Interactive mode - drop into shell at line 15
manimgl scene.py MyScene -se 15
# Write to file
manimgl scene.py MyScene -w
# Low quality for testing
manimgl scene.py MyScene -l
Key Differences from ManimCE
| Feature | ManimGL (3b1b) | Manim Community |
|---|---|---|
| Import | from manimlib import * | from manim import * |
| CLI | manimgl | manim |
| Math text | Tex(R"\pi") | MathTex(r"\pi") |
| Scene | InteractiveScene | Scene |
| Create anim | ShowCreation | Create |
| Camera | self.frame | self.camera.frame |
| Fix in frame | mob.fix_in_frame() | self.add_fixed_in_frame_mobjects(mob) |
| Package | manimgl (PyPI) | manim (PyPI) |
Interactive Development Workflow
ManimGL's killer feature is interactive development:
# Start at line 20 with state preserved
manimgl scene.py MyScene -se 20
In interactive mode:
# Copy code to clipboard, then run:
checkpoint_paste() # Run with animations
checkpoint_paste(skip=True) # Run instantly (no animations)
checkpoint_paste(record=True) # Record while running
Camera Control (self.frame)
# Get the camera frame
frame = self.frame
# Reorient in 3D (phi, theta, gamma, center, height)
frame.reorient(45, -30, 0, ORIGIN, 8)
# Animate camera movement
self.play(frame.animate.reorient(60, -45, 0))
# Fix mobjects to stay in screen space during 3D movement
title.fix_in_frame()
LaTeX with Tex class
# Use raw strings with capital R
formula = Tex(R"\int_0^1 x^2 \, dx = \frac{1}{3}")
# Color mapping with t2c
equation = Tex(
R"E = mc^2",
t2c={"E": BLUE, "m": GREEN, "c": YELLOW}
)
# Isolate substrings for animation
formula = Tex(R"\sum_{n=1}^{\infty} \frac{1}{n^2} = \frac{\pi^2}{6}")
formula.set_color_by_tex("n", BLUE)
Common Patterns
Embedding for debugging
def construct(self):
circle = Circle()
self.play(ShowCreation(circle))
self.embed() # Drops into IPython shell here
Set floor plane for 3D
self.set_floor_plane("xz") # Makes xy the viewing plane
Backstroke for text readability
text = Text("Label")
text.set_backstroke(BLACK, 5) # Black outline behind text
Installation
# Install ManimGL
pip install manimgl
# Check installation
manimgl --version
Common Pitfalls to Avoid
- Version confusion - Ensure you're using
manimgl, notmanim(community version) - ShowCreation vs Create - ManimGL uses
ShowCreation, notCreate - Tex vs MathTex - ManimGL uses
Texwith capital R raw strings - self.frame vs self.camera.frame - ManimGL uses
self.framedirectly - fix_in_frame() - Call on the mobject, not the scene
- Interactive mode - Use
-seflag for interactive development
License & Attribution
This skill contains example code adapted from 3Blue1Brown's video repository by Grant Sanderson.
License: CC BY-NC-SA 4.0
- Attribution required - Credit both 3Blue1Brown and the adapter
- NonCommercial - Not for commercial use
- ShareAlike - Derivatives must use the same license
See LICENSE.txt for full details.
Related skills
More from adithya-s-k/manim_skill and the wider catalog.

manim-composer
Plan educational animations scene-by-scene before coding—transforms vague video ideas into detailed Manim implementation specs.

manimce-best-practices
Best practices for Manim Community Edition animations, scenes, and LaTeX rendering.

write-xiaohongshu
Research top Xiaohongshu posts, analyze patterns, enrich with Firecrawl, then write and publish XHS notes with strict limits: title ≤20 chars, body ≤1000 chars.

analyze-and-plan
Analyzes development requirements and generates structured acceptance criteria for AEM Edge Delivery Services (EDS) tasks. Use when the user needs to define acceptance criteria, write requirements, scope work, or create a definition of done for EDS blocks, components, variants, bug fixes, or styling changes. Produces task breakdowns, identifies edge cases, and documents analysis for new blocks, variants, behavior modifications, CSS-only changes, and bug fixes.

auth
Authenticate with AEM Edge Delivery Services. Opens browser for login and captures token. Works for admin.hlx.page and Config Service APIs regardless of content source (Document Authoring, SharePoint, or Google Drive).

authoring
Generate comprehensive documentation for content authors taking over an AEM Edge Delivery Services project. Analyzes the project structure and produces a complete authoring guide with blocks, templates, configurations, and publishing workflows.