ManimCommunity/manim

This system is Manim, a Python library for creating precise mathematical animations and visualizations. It provides a comprehensive framework for defining scenes, mobjects, and animations, supporting both 2D and 3D rendering through modular Cairo and OpenGL backends. The system includes extensive tooling for graphing, typography, and code visualization, along with a modernized CLI for project scaffolding, configuration management, and rendering control.

21 changes.

This period centered on the Manim Community v0.12.0 release, featuring a comprehensive restructuring of the codebase into modular subsystems for animations, cameras, mobjects, and renderers. The work introduced dual Cairo and OpenGL rendering backends, parallel video encoding, and a unified configuration system, while establishing robust test infrastructure and modernizing development tooling with uv and Ruff.

30 changes.

This period focused on introducing a comprehensive OpenGL rendering backend for mobjects and shaders, providing a hardware-accelerated alternative to the existing Cairo renderer. The command-line interface was significantly modernized by migrating to Click and Cloup, adding new subcommands for configuration, project scaffolding, and plugin management. These major architectural shifts were supported by extensive restructuring of geometry, graphing, and text modules, alongside broad expansion of test coverage to ensure stability across the new features.

4 changes.

This period introduced the manim checkhealth CLI subcommand for installation diagnostics and expanded the library with standardized color palettes and new color constants. Concurrently, test coverage was enhanced with a Lissajous animation benchmark to stress-test the render hot path and comprehensive unit tests for the new Manager class and output path resolution logic.

This change introduces the foundational mobject classes for the library, including the base Mobject class, specialized geometry and layout mobjects (Graph, Table, Matrix), and utility trackers (ValueTracker). It also adds the ManimBanner logo mobject and provides renderer-agnostic utility functions to select the correct base class (Cairo vs. OpenGL) at runtime.

manim/mobject · high confidence

Manim now includes a complete OpenGL rendering backend for mobjects, providing a parallel implementation to the existing Cairo renderer. This change introduces a new \manim/mobject/opengl\ package containing \OpenGLMobject\ as the base class, along with specific implementations for vectorized shapes (\OpenGLVMobject\), surfaces (\OpenGLSurface\), point clouds (\OpenGLPMobject\), and images (\OpenGLImageMobject\). A \ConvertToOpenGL\ metaclass enables runtime swapping of standard mobjects to their OpenGL counterparts when the renderer is configured to use OpenGL, allowing users to leverage hardware-accelerated rendering for animations.

manim/mobject/opengl · high confidence

This release introduces a new CLI entry point in manim/\_\main\\_.py using Click and Cloup, adds a --version flag and optional splash screen, and provides a new manim cache clear command for segment cache management. It also adds a Manager class for render-flow coordination, a MethodWithArgs dataclass, and a comprehensive typing module with new type aliases. The package now declares itself as typed via py.typed, includes new Typst support, and provides new templates and configuration files for initialization.

manim · high confidence

The CLI now includes a dedicated 'manim init' command group, replacing the legacy 'manim new' functionality. This new command provides two subcommands: 'manim init project' to scaffold a new Manim project directory with a configurable 'manim.cfg' (including resolution, frame rate, and background settings) and template files, and 'manim init scene' to insert a new scene into an existing Python file or create a new one if 'main.py' is present. The project creation flow supports both interactive configuration and a '--default' flag for quick setup using predefined defaults (1080x1920 resolution, 30 fps, black background).

manim/cli/init · high confidence

The \manim/mobject/three\_d\ module now includes \Polyhedron\, \Tetrahedron\, \Octahedron\, \Icosahedron\, \Dodecahedron\, and \ConvexHull3D\ classes, allowing users to create and manipulate general and Platonic polyhedra defined by vertex coordinates and faces. Additionally, \three\_d\_utils.py\ provides helper functions for calculating 3D vector properties like corner indices and normals for 3D mobjects.

_manim/mobject/three\d · high confidence

This change introduces new SVG-based brace mobjects (\Brace\, \BraceLabel\, \ArcBrace\, \BraceText\, \BraceBetweenPoints\) in \manim/mobject/svg/brace.py\, allowing users to create braces that adapt to the width of other mobjects. It also includes updates to \manim/mobject/svg/svg\_mobject.py\ to improve the robustness and performance of \SVGMobject\, such as adding caching for SVG imports and ensuring \stroke\_width\ defaults are handled correctly.

manim/mobject/svg · high confidence

The documentation build system now includes custom Sphinx directives located in \manim.utils.docbuild\. The \autoaliasattr\ directive automatically generates a "Type Aliases" section in the API reference by parsing module-level \TypeAlias\ definitions (including Python 3.12 \type\ statements) and cross-referencing them. The \automanimcolormodule\ directive renders a table of \ManimColor\ constants with their hex codes and appropriate font colors for readability. Additionally, the \manim\ directive allows embedding rendered Manim scenes directly into documentation pages, supporting options for quality, GIF output, and reference lists for classes and functions.

manim/utils/docbuild · high confidence

Added several new scripts to the \scripts/\ directory to support development workflows: \extract\_frames.py\ allows users to visualize test control data by extracting frames from \.npz\ files; \make\_and\_open\_docs.py\ builds the documentation and opens it in a browser, with support for specifying a custom browser; \release.py\ consolidates release management by generating changelogs from GitHub, updating \CITATION.cff\, and fetching release notes; \TEMPLATE.cff\ provides a template for citation metadata; and \template\_docsting\_with\_example.py\ offers a structured template for writing documentation with examples.

scripts · high confidence

The example\_scenes directory now includes several new demonstration files. advanced\_tex\_fonts.py showcases manual TexTemplate creation and iteration through the TexFontTemplates library for various LaTeX fonts. basic.py provides updated standard examples, including a new SpiralIn animation and demonstrations of line joint types. customtex.py and custom\_template.tex illustrate how to use custom LaTeX templates via command-line arguments or in-code configuration. opengl.py introduces scenes for testing OpenGL rendering, including interactive GUI tests and 3D mobject manipulation. Additionally, manim\_jupyter\_example.ipynb demonstrates embedding Manim animations in Jupyter notebooks, and manim.cfg provides an example of custom logger configuration.

_example\scenes · high confidence

A new \manim.mobject.graphing\ package has been introduced, consolidating graphing-related mobjects into a dedicated module. This includes \CoordinateSystem\, \Axes\, \ThreeDAxes\, \NumberPlane\, \PolarPlane\, and \ComplexPlane\ for defining coordinate spaces, alongside \ParametricFunction\, \FunctionGraph\, and \ImplicitFunction\ for rendering curves. The module also provides \NumberLine\ and \UnitInterval\ for linear scales, \SampleSpace\ and \BarChart\ for probability and statistics visualizations, and \LinearBase\ and \LogBase\ for scaling axes. This refactors previously scattered graphing logic into a structured, importable namespace.

manim/mobject/graphing · high confidence

A new \manim cfg\ command group has been added to the CLI, allowing users to manage Manim configuration files directly from the command line. This includes a \write\ subcommand that creates or updates configuration files at the user or current working directory level, and provides an option to open the generated file for editing. The implementation leverages the \cloup\ library for command grouping and integrates with the existing configuration parsing utilities to handle settings such as logger styles.

manim/cli/cfg · high confidence

A new \manim checkhealth\ command has been added to diagnose installation issues by verifying that Manim is on the system PATH, that the executable belongs to the correct library (supporting uv launcher shims), and that required dependencies like LaTeX and dvisvgm are available. The command provides specific recommendations for fixing failures and, upon successful completion, offers to render a test scene to confirm that rendering works correctly.

manim/cli/checkhealth · high confidence

Manim now includes several new standardized color palettes accessible via module namespaces: AS2700 (Australian Standard), BS381 (British Standard), DVIPSNAMES (LaTeX dvips), SVGNAMES (SVG 1.1), X11, and XKCD (web comic survey). These palettes are exposed in the global namespace as modules (e.g., \from manim import XKCD; XKCD.MANGO\), allowing users to access hundreds of additional named colors beyond the existing defaults. Additionally, new pure color constants (PURE\_RED, PURE\_GREEN, PURE\_BLUE, PURE\_CYAN, PURE\_MAGENTA, PURE\_YELLOW) and corrected/added standard colors (YELLOW\_C, PURE\_CYAN, PURE\_MAGENTA, PURE\_YELLOW) are now available in the global namespace.

manim/utils/color · high confidence

The \manim/mobject/text\ package has been reorganized into a dedicated module, introducing first-class support for rendering text and math via Typst (classes \Typst\ and \MathTypst\) as an optional dependency. The package now includes a rewritten \Code\ mobject for syntax-highlighted source code listings, a \DecimalNumber\ class for formatted numeric display, and updated \Text\, \Paragraph\, \MarkupText\, \Tex\, and \MathTex\ classes. This change consolidates text-related mobjects and adds new capabilities for code visualization and alternative LaTeX rendering engines.

manim/mobject/text · high confidence

This change introduces a new module for mobject update utilities and specific animation classes. The \mobject\_update\_utils\ module adds functions like \always\, \f\_always\, \always\_redraw\, \always\_shift\, and \always\_rotate\ to continuously update mobjects based on methods or functions. It also includes \turn\_animation\_into\_updater\, which now supports a \delay\ parameter to postpone the start of the updater. Additionally, the \update\ module defines \UpdateFromFunc\, \UpdateFromAlphaFunc\, and \MaintainPositionRelativeTo\ animations, allowing for custom update logic and relative positioning during animations.

manim/animation/updaters · high confidence

The manim/opengl package is now initialized with a dedicated \_\init\\_.py that exposes the core OpenGL mobject classes (dot cloud, image, mobject, point cloud, surface, three dimensions, and vectorized mobject) along with shader and utility modules. It also includes a conditional import of dearpygui, enabling OpenGL rendering support when the library is available.

manim/opengl · high confidence

The geometry mobject module has been reorganized from a single monolithic file into a package with dedicated submodules (arc, boolean\_ops, labeled, line, polygram, shape\matchers, tips). This change improves code maintainability and allows for more granular imports, while preserving the existing public API through the updated \\init\\_.py which re-exports all classes from the new submodules.

manim/mobject/geometry · high confidence

The rendering subsystem has been restructured into a modular package under \manim/renderer\, separating the Cairo and OpenGL rendering engines into distinct modules (\cairo\_renderer.py\, \opengl\_renderer.py\) and establishing a shared \protocol.py\ for renderer capabilities. This change introduces a new \Window\ class for OpenGL interactive previews, implements shader management via \shader.py\ and \shader\_wrapper.py\, and adds specific rendering logic for vectorized objects in \vectorized\_mobject\_rendering.py\. Users benefit from a cleaner internal structure that supports distinct rendering backends and improved OpenGL features like interactive windowing and shader-based rendering.

manim/renderer · high confidence

The specialized mobject base classes have been moved into a new \manim/mobject/types\ package, introducing \image\_mobject.py\, \point\_cloud\_mobject.py\, and \vectorized\mobject.py\ alongside a new \\\init\\_.py\ that exposes these modules for documentation. This change consolidates the implementation of \ImageMobject\, \PMobject\ (and its subclasses like \PointCloudDot\), and \VMobject\ (including \VGroup\ and \DashedVMobject\) into a single, structured location, improving code organization without altering the public API surface.

manim/mobject/types · high confidence

The animation subsystem has been reorganized into distinct modules (animation, composition, creation, fading, growing, indication, movement, numbers, rotation, transform, update) with a unified base Animation class that now supports animation overrides via the @override\_animation decorator and the .animate syntax. Fading animations (FadeIn, FadeOut) now accept multiple mobjects, and composition classes (AnimationGroup, Succession, LaggedStart) have been refactored to handle timing and sub-animation lifecycle more robustly. Several new animations were added, including SpiralIn, AddTextLetterByLetter, RemoveTextLetterByLetter, AddTextWordByWord, TypeWithCursor, UntypeWithCursor, AnimatedBoundary, and TracedPath, while deprecated classes like ShowCreation and ShowCreationThenFadeOut were removed in favor of Create and Uncreate. Type annotations were added throughout, and OpenGL compatibility was improved for core animation classes.

manim/animation · high confidence

Manim now automatically discovers and loads plugins registered under the 'manim.plugins' entry point group, replacing the previous dynamic import mechanism. Users can now list available plugins using the new CLI command, and the system will warn if requested plugins are missing from the environment.

manim/plugins · high confidence

The command-line interface has been reorganized into distinct subcommands, introducing a new 'manim plugins' command to list available plugins and splitting the main 'manim render' command into modular option groups (global, output, render, and ease-of-access). This change also adds a 'seed' option for reproducible outputs, allows specifying the input file via a config file, and implements a version check that notifies users if an outdated Manim version is installed.

manim/cli/render · high confidence

The command-line interface has been refactored to use the Click and Cloup libraries, replacing the previous Argparse-based implementation. This change introduces a new CLI structure defined in the \manim/cli\ module, including a custom \DefaultGroup\ that allows \manim\ to act as \manim render\ by default when no subcommand is specified. Users will experience this as a modernized CLI with improved help page styling and consistent command handling, while the underlying argument parsing logic has shifted from standard library tools to the Click ecosystem.

manim/cli · high confidence

The camera subsystem has been reorganized into a modular package with dedicated files for base, moving, mapping, multi, and 3D cameras. The base Camera class now reads pixel dimensions and frame settings from the central configuration object, introducing default values for pixel height and width. The MovingCamera class gains an auto\_zoom method, allowing users to automatically frame specific mobjects without requiring an animation wrapper.

manim/camera · high confidence

The scene module has been restructured to improve rendering performance and code organization. The core rendering logic now delegates to a dedicated Manager, and video segment encoding is offloaded to background threads via the new VideoSegmentEncoder and \_PartialMovieEncodeJob classes, allowing for parallel processing of partial movie files. Several specialized scene classes have been introduced or reorganized: MovingCameraScene for camera movement, ThreeDScene for 3D rendering, VectorScene and LinearTransformationScene for vector spaces, and ZoomedScene for zooming effects. The SceneFileWriter has been decoupled from renderer state and now consumes immutable \_SceneFileWriterSettings, while the Section class provides a new API for segmented video output.

manim/scene · high confidence

The project has introduced a comprehensive set of configuration files to standardize development workflows and improve code quality. This includes migrating the linting and formatting tooling from flake8/black to Ruff, configuring pre-commit hooks for automated checks, and setting up mypy for static type analysis. Additionally, the repository now supports the uv package manager via a new lockfile, integrates with ReadTheDocs for documentation builds, and establishes community standards through a Code of Conduct, CITATION file, and Crowdin configuration for translations.

(repo-wide) · high confidence

The configuration subsystem has been reorganized into distinct modules to improve clarity and maintainability. A new \output.py\ module defines the \OutputFormat\ enum and \OutputSpec\ dataclass to strictly validate and represent render artifacts (e.g., MP4, PNG, GIF) and their properties. Output path resolution is now handled by \output\_plan.py\, which computes exact file locations for videos, images, and logs based on the resolved output spec. Logging has been moved to \logger\_utils.py\, utilizing the \rich\ library for styled console output and JSON-formatted file logs, with theme settings configurable via the \\[logger\]\ section in \manim.cfg\. CLI help formatting is now managed by \cli\_colors.py\, which parses \CLI\CTX\ settings to customize the appearance of the command-line interface using \cloup\. The core configuration logic remains in \utils.py\ (exporting \ManimConfig\), but it now delegates specific concerns to these new modules, and \\\init\\_.py\ initializes the global \config\ and \logger\ objects using this new structure.

_manim/\config · high confidence

The output configuration system has been refactored to improve how media files are managed and accessed. The \manim/utils/file\_ops.py\ module now includes functions to add version stamps to output filenames and to locate template files. The \manim/utils/commands.py\ module introduces a new \get\_video\_metadata\ function that uses the \av\ library to extract video properties, replacing previous external process calls. Additionally, the \manim/utils/caching.py\ module now provides utilities to prune and clear the segment cache based on file access times, and the \manim/utils/config\_ops.py\ module adds recursive dictionary merging utilities to support the new configuration structure.

manim/utils · high confidence

The OpenGL renderer's shader pipeline has been completely rewritten to use a new set of GLSL files for rendering vectorized mobjects. This change introduces dedicated shader programs for quadratic bezier fill and stroke, including geometry shaders that generate anti-aliased pentagons around curves and handle joint types (round, bevel, miter). It also adds support for lighting and shading via a new \finalize\_color\ include, enabling gloss and shadow effects on surfaces and strokes. The update includes new shaders for images, textured surfaces, and true dots, along with helper utilities for coordinate transformations and normal calculations.

manim/renderer/shaders · high confidence

2 commits adding/updating tests in tests/test\_graphical\_units/control\_data/composition, tests/test\_graphical\_units/control\_data/movements, tests/test\_graphical\_units/control\_data/numbers; 3 commits adding/updating tests in (repo-wide); Added Lissajous animation benchmark; Added OpenGL renderer test suite; Added comprehensive test coverage for text mobject classes; Added comprehensive test coverage for the animation module; Added comprehensive test suite for Mobject core behaviors; Added comprehensive test suite for scene rendering and video encoding; Added comprehensive test suite for utility modules; Added regression tests for vectorized mobject fixes; Added test coverage for graphing module components; Added test coverage for scene core features; Added test for version consistency; Added test helper utilities for graphical and video unit tests; Added tests for CLI cache, health check, and init commands; Added tests for Manim logging functionality; Added tests for SVGMobject color, opacity, and path parsing behavior; Added tests for plugin installation and warning behavior; Added tests for the new render-flow Manager and output path resolution logic; Added unit tests for geometry mobjects; Expanded test coverage for the OpenGL renderer; New frames\_comparison testing utility for visual regression tests; New graphical unit test suite for Manim; New test infrastructure and expanded test coverage; New test utilities for logging, video, and polylabel validation.

The project has switched its build backend from Poetry to uv (uv\_build), requiring uv \>=0.10.0 for development and packaging. Core runtime dependencies have been updated to newer versions, including numpy \>=2.1, av \>=15.0, and pillow \>=11.0, while dropping support for Python versions below 3.11. Documentation dependencies in docs/requirements.txt and pyproject.toml have been refreshed to use Sphinx \>=7.3/7.4.7, furo, and typst \>=0.14 for optional Typst rendering support.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 49 → 66 (+16.3)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 93 → 88 (-5.4)
• Architecture 94 → 100 (+5.9)
• Maturity 58 → 51 (-7.1)
• Readiness 35 → 84 (+49.0)
• Security 50 → 71 (+20.6)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (10 lines × 2) (example_scenes/opengl.py)
• Duplicated block (10 lines × 2) (manim/mobject/three_d/polyhedra.py)
• Duplicated block (10 lines × 2) (manim/mobject/three_d/three_dimensions.py)
• Duplicated block (13 lines × 2) (manim/mobject/graphing/coordinate_systems.py)
• Duplicated block (18 lines × 2) (manim/mobject/text/text_mobject.py)
• Duplicated block (9 lines × 2) (manim/mobject/text/text_mobject.py)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 29 more

• AliasAttrDocumenter.run (cognitive 37) (manim/utils/docbuild/autoaliasattr_directive.py)
• Angle.init (cognitive 34) (manim/mobject/geometry/line.py)
• Code.init (cognitive 35) (manim/mobject/text/code_mobject.py)
• Code.init (cyclomatic 23) (manim/mobject/text/code_mobject.py)
• CoordinateSystem.get_riemann_rectangles (cognitive 18) (manim/mobject/graphing/coordinate_systems.py)
• CoordinateSystem.plot (cognitive 27) (manim/mobject/graphing/coordinate_systems.py)
• DashedVMobject.init (cognitive 33) (manim/mobject/types/vectorized_mobject.py)
• DashedVMobject.init (cyclomatic 17) (manim/mobject/types/vectorized_mobject.py)
• Dependency hygiene PARTLY measured — Python dependencies read, no exact pin to grade for currency
• Duplicated block (10 lines × 2) (manim/mobject/geometry/arc.py)
• Duplicated block (10 lines × 2) (manim/mobject/mobject.py)
• Duplicated block (11 lines × 2) (manim/mobject/mobject.py)
• Duplicated block (11 lines × 2) (manim/mobject/opengl/opengl_vectorized_mobject.py)
• Duplicated block (11–12 lines × 3) (manim/mobject/graphing/coordinate_systems.py)
• Duplicated block (11–14 lines × 2) (manim/mobject/mobject.py)
• Duplicated block (12 lines × 2) (manim/mobject/graphing/coordinate_systems.py)
• Duplicated block (12 lines × 2) (manim/scene/scene.py)
• Duplicated block (13 lines × 2) (manim/mobject/geometry/arc.py)
• Duplicated block (13 lines × 2) (manim/mobject/opengl/opengl_point_cloud_mobject.py)
• Duplicated block (14 lines × 2) (manim/mobject/mobject.py)
• …and 311 more

• 51 commits — 29 feature/other, 22 fixes

• manim/mobject — 20 commits
• docs/source — 8 commits
• manim/utils — 7 commits
• (root) — 5 commits
• manim/scene — 3 commits
• manim/_config — 2 commits
• tests/module — 2 commits
• benchmarks/bench_lissajous.py — 1 commit
• manim/animation — 1 commit
• manim/camera — 1 commit
• tests/test_scene_rendering — 1 commit

• fix: Fix AUTO cap style and joint type inheriting the previous mobject's style in Cairo renderer (#5016)
• fix: Fix BarChart ignoring include_numbers in y_axis_config (#5015)
• fix: Fix LaggedStartMap unpacking submobjects with the default arg_creator (#4965)
• fix: Fix OpenGLMobject.get_boundary_point (#4956)
• fix: Fix dim of OpenGLMobject.stretch_to_fit_depth (#4955)
• fix: Fix is_closed misclassifying closed curves in negative coordinate space (#5010)
• fix: Fix opengl_mobject.is_off_screen right-bounds check (#4953)
• fix: Fix: Allow Graph Mobject to be initialised with an empty list of vertices (#4946)
• fix: Fix: Include moving mobject ancestors to prevent duplication at animate time (#4936)
• fix: Fix: Make normalize properly check for a fallback when vector norm is 0 (#5001)
• fix: Fix: skip hidden files and tolerate vanishing files when cleaning the partial movie cache (#4954)
• fix: fix flaky example in rendered docs (#4967)
• fix: fix(code): inherit container background and adjust line number color (#4816)
• fix: fix(config): restore renderer class bases on config update (#4958)
• fix: fix(scene): preserve z-index ordering in animation groups (#4918)
• fix: fix(space_ops): flip the axis when angle_axis_from_quaternion folds the angle (#4980)
• fix: fix(svg): ignore point-less shape elements (#4917)
• fix: fix: change TypstMath -> MathTypst in release changelog too
• fix: fix: normalize Code baseline alignment in Paragraph (#4692)
• fix: fix: np.sum deprecation for generators (#4962)
• …and 31 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

ManimCommunity/manim was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.