3b1b/manim

ManimGL is a Python library for creating mathematical animations, featuring a modern WGPU-based rendering engine and a comprehensive suite of mobject types for 2D and 3D graphics. It supports complex scene composition through an updated animation system with parallel and sequential primitives, alongside interactive editing capabilities and shader-driven visual effects. The system handles text and SVG rendering via external libraries and provides robust configuration and event handling for both scripted and interactive workflows.

10 changes.

This period centered on the complete architectural rewrite of ManimGL to version 2.0, migrating the rendering engine from OpenGL to WGPU and centralizing configuration via YAML. The work involved a comprehensive overhaul of the animation system, camera frame handling, and mobject infrastructure, while introducing new features like interactive scene editing and advanced SVG text rendering.

6 changes.

The project implemented a comprehensive shift to a wgpu-based rendering pipeline, replacing the previous preprocessor-based system with a modular WGSL shader architecture. This overhaul introduced advanced rendering capabilities for fills, strokes, and fractals, alongside a centralized event handling system for interactive scenes. The changes were supported by a new test suite to ensure visual regression stability and correct geometric behavior.

This entry introduces the ManimGL package (version 1.7.2) as a standalone installable library. It establishes the core Python 3.10+ dependency requirements (including wgpu, manimpango, and svgelements) via setup.cfg, provides the \manimgl\ and \manim-render\ CLI entry points, and includes a comprehensive set of example scenes (such as OpeningManimExample and TexTransformExample) to demonstrate the animation engine's capabilities. The release also standardizes the project structure with a MIT license, a Python .gitignore, and detailed installation documentation for Windows, macOS, and Linux.

(repo-wide) · high confidence

A new event handling subsystem has been added to manage user interactions. This includes an \EventType\ enum defining supported events (mouse motion, press, release, drag, scroll, and key press/release), an \EventListener\ class to bind callbacks to specific mobjects, and a singleton \EventDispatcher\ that routes these events. The dispatcher tracks mouse position and pressed keys, handles logic for dragging objects by checking if the mouse is touching them, and invokes registered callbacks, allowing users to attach interactive behaviors to scene elements.

_manimlib/event\handler · high confidence

This change introduces a new InteractiveScene class that allows users to select, move, resize, and color mobjects directly in the GUI during playback, along with undo/redo support and a color palette. It also refactors the SceneFileWriter to support sub-divided output (writing separate files for each play/wait call) and adds configurable saturation and gamma settings for video encoding.

manimlib/scene · high confidence

A new logo animation has been added to the library, featuring a mathematical graph visualization with secant slopes and Riemann rectangles, accompanied by the Manim text label.

logo · high confidence

The library introduces several new mobject classes: boolean operations (Union, Difference, Intersection, Exclusion) for combining 2D shapes using the pathops library; AnimatedBoundary for creating animated outline effects on VMobjects; TracedPath and TracingTail for visualizing point trajectories; and fractal generators (MandelbrotFractal, JuliaFractal, NewtonFractal) that render fractals via custom shaders. Additionally, the frame module now provides ScreenRectangle, FullScreenRectangle, and FullScreenFadeRectangle for consistent screen-sized backgrounds.

manimlib/mobject · high confidence

The library introduces several new mobject types in the \manimlib.mobject.types\ module. \DotCloud\ and its subclasses (\TrueDot\, \GlowDot\, \GlowDots\) allow rendering collections of dots with configurable radii and glow effects. \ImageMobject\ enables displaying raster images with shader-based rendering. \VideoMobject\ and \VideoSource\ provide support for playing video files, including frame caching and decoding. \Surface\ and \PMobject\ (with \PGroup\) are also included, providing base classes for 3D surfaces and point-cloud-based mobjects respectively.

manimlib/mobject/types · high confidence

The camera frame has been refactored to manage orientation using Euler angles (theta, phi, gamma) via the scipy Rotation library, replacing the previous quaternion-based system. This change introduces explicit support for configuring the camera's field of view (fovy) and allows users to reorient the camera using specific Euler axes. The CameraFrame class now exposes methods to get and set these angles, handle gimbal lock edge cases, and reorient the view with a convenient shortcut method.

manimlib/camera · high confidence

The SVG and text mobject system has been significantly restructured to improve performance, consistency, and usability. The core \SVGMobject\ now leverages the \svgelements\ library for parsing and implements a global hash-based caching mechanism (\SVG\_HASH\_TO\_MOB\_MAP\) to avoid redundant file I/O and parsing. Text rendering has been split into two distinct paths: \Tex\ (for LaTeX) now inherits from a new \StringMobject\ base class that uses a labelled-SVG technique for robust substring isolation, while \Text\ (for plain/markup text) utilizes \manimpango\ for direct rendering. The \StringMobject\ base class introduces a unified \Selector\ type (supporting strings, regex, and spans) for the \isolate\ parameter, replacing the previous \substrings\_to\_isolate\ convention. Additionally, the \Brace\ and \BraceLabel\ classes have been refactored to use the new \Text\ and \Tex\ mobjects, and \MarkupText\ has been added to support Pango markup strings.

manimlib/mobject/svg · high confidence

ManimGL has been rewritten from the ground up as version 2.0, introducing a major shift in how the library is configured, rendered, and structured. Configuration is now centralized in a new \default\_config.yml\ file (accessible via \manim\config\), replacing hardcoded constants and allowing users to customize directories, camera settings, colors, and key bindings without code changes. The rendering engine has migrated from OpenGL to WGPU (via \rendercanvas\ and \glfw\), providing a modern, cross-platform graphics backend that handles window management and frame presentation more robustly. The library structure has been reorganized into a clean \manimlib\ package with explicit universal imports in \\\init\\_.py\, separating concerns into dedicated modules for config, scene extraction, module loading (with improved autoreload support), and typing. This rewrite also introduces a new \InteractiveScene\ base class, supports inline scene embedding with line-number targeting, and standardizes video output to a \videos\ directory by default.

manimlib · high confidence

The \manimlib/shaders/inserts\ directory now contains a collection of WGSL shader snippets (e.g., \clip\_test\, \fill\_color\, \project\_point\, \surface\_mesh\) that implement core rendering behaviors such as clipping, color interpolation, point projection, and surface mesh generation. These inserts replace the previous preprocessor-based inclusion mechanism with a manual text-replacement strategy, allowing shaders to share common logic without a preprocessor. This change introduces the underlying rendering primitives for the new wgpu-based renderer, including support for complex number arithmetic, frame-uniform handling, and data reading from storage buffers.

manimlib/shaders/inserts · high confidence

The rendering engine has been updated to use a new set of WGSL shaders for core visual elements. Fills now use a winding-number stencil approach to correctly handle complex paths, while strokes are drawn as quad strips with improved joint rounding and anti-aliasing. New fractal shaders (Mandelbrot, Julia, Newton) allow for pixel-level mathematical visualization, and video playback is now handled via a dedicated shader that samples from a texture array. This shift replaces the previous rendering implementation with a more robust, shader-driven pipeline.

manimlib/shaders · high confidence

The \manimlib/utils\ package has been reorganized into a flat structure of dedicated modules (e.g., \bezier.py\, \color.py\, \cache.py\, \structured\_array.py\) replacing the previous hierarchy. This introduces disk caching for expensive operations like LaTeX-to-SVG conversion via \diskcache\, changes color interpolation to use the square of RGB values for perceptual uniformity, and implements a \StructuredArray\ class that tracks write versions to optimize shader data updates. Additionally, file finding now supports downloading remote URLs, and rotation operations have been refactored to use \scipy.spatial.transform.Rotation\.

manimlib/utils · high confidence

The animation module has been completely rewritten to use a new, simpler \Animation\ base class that manages interpolation, timing, and mobject state (such as suspending updaters) more robustly. This change introduces new composition primitives: \AnimationGroup\ for parallel execution, \Succession\ for sequential execution, and \LaggedStart\/\LaggedStartMap\ for staggered animations. Several existing animations have been reimplemented or replaced, including \Write\, \DrawBorderThenFill\, \FadeIn\, \FadeOut\, \Transform\, and new additions like \TransformMatchingParts\ and \Flash\. The new structure allows for better handling of submobjects, rate functions, and scene cleanup, while maintaining backward compatibility through aliases like \OldLaggedStart\.

manimlib/animation · high confidence

The renderer has been reorganized to align with the underlying wgpu API, introducing a new modular structure with dedicated files for GPU management, drawing logic, materials, and pipelines. This change includes the addition of a new \Gpu\ class to handle device and buffer management, a \Drawing\ class to represent individual mobject rendering states, and a \Material\ class to manage shared shader modules and bind groups. The rendering process now uses a \PipelineState\ to define fixed-function behavior and supports bundling of draw calls for improved performance when scenes remain static. Additionally, the renderer now handles z-indexing and can group consecutive mobjects for batched drawing, optimizing the rendering of complex scenes.

manimlib/renderer · high confidence

Added a comprehensive set of tests to verify core library behavior. The suite includes visual regression tests (render\_compare.py) that compare rendered frames against reference images to catch renderer changes, and specific functional tests for bounding box corner integrity after transforms, correct ordering of transparent surfaces, and proper frame readback to video files. It also adds unit tests for coordinate system point lookups and 2D/3D vector rotation, plus integration tests ensuring preview windows correctly present frames to the display device.

tests · high confidence

The documentation build system has been updated to use Sphinx 8+ with the Furo theme, replacing the previous pinned versions to resolve compatibility issues with Jinja2. Core library dependencies have also been refreshed, including upgrades to manimpango (\>=0.6.0), svgelements (\>=1.8.1), and ipython (\>=8.18.0), alongside the addition of new packages such as rendercanvas, skia-pathops, and wgpu to support modern rendering and text capabilities.

(dependencies) · high confidence

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

• CAI 58 → 63 (+4.9)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 86 → 93 (+6.4)
• Architecture 100 → 97 (-3.1)
• Maturity 53 → 53 (-0.2)
• Readiness 52 → 60 (+8.0)
• Security 57 → 73 (+15.9)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (19 lines × 2) (manimlib/config.py)
• Duplicated block (6 lines × 2) (manimlib/mobject/vector_field.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)
• Hotspot: manimlib/renderer.py (manimlib/renderer.py)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• No exposed public API
• Off-boarding risk: anonymized user #1
• Only Sphinx version 3.0.3 and two dependencies (sphinx-copybutton, furo) are listed, but the requirements file itself contains no installable package; it is a metadata stub rather than an actual dependency list. (docs/requirements.txt)
• Renderer.use (cognitive 20) (manimlib/renderer.py)
• Test reliability not included
• render_compare.run (cognitive 44) (tests/render_compare.py)
• render_compare.run (cyclomatic 24) (tests/render_compare.py)

• Change coupling: interactive.py ↔ scene.py (manimlib/mobject/interactive.py)
• Dependency hygiene PARTLY measured — Python dependencies read, no exact pin to grade for currency
• Duplicated block (26–30 lines × 2) (manimlib/config.py)
• Duplicated block (6 lines × 2) (manimlib/mobject/vector_field.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)
• Hotspot: manimlib/mobject/svg/string_mobject.py (manimlib/mobject/svg/string_mobject.py)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• No ADRs found
• No dependency advisory monitoring
• Off-boarding risk: anonymized user #1
• …and 18 more

• 71 commits — 64 feature/other, 7 fixes

• manimlib/mobject — 19 commits
• manimlib/renderer — 11 commits
• (repo) — 6 commits
• (root) — 6 commits
• manimlib/animation — 5 commits
• manimlib/camera — 4 commits
• manimlib/utils — 4 commits
• manimlib/shader_wrapper.py — 3 commits
• docs/source — 2 commits
• manimlib/renderer.py — 2 commits
• manimlib/scene — 2 commits
• manimlib/shaders — 2 commits
• .github/workflows — 1 commit
• manimlib/default_config.yml — 1 commit
• manimlib/draw_list.py — 1 commit
• tests/preview_window.py — 1 commit
• tests/render_compare.py — 1 commit

• fix: Fix LaTeX compilation check on Windows where exit code is non-zero even on success (#2463)
• fix: Fix LaggedStart time_spans (#2511)
• fix: Fix batched 2D vector rotation (#2501)
• fix: Fix graph point lookup outside unit x ranges (#2502)
• fix: Fix stale separator records between merged mobjects
• fix: Fix updater in animation issue (#2505)
• fix: Fixed pegging CPU Core Issue (#2485)
• change: Add Animation. get_interpolation_ends (#2494)
• change: Add Linux installation instructions (#2467)
• change: Add VideoMobject and Sprite (#2521)
• change: Added zoom scroll inversion option to config settings (#2507)
• change: Ask a program to draw a mobject, rather than each mobject a wrapper
• change: Ask a surface about its opacity only when its opacity may have moved
• change: Ask for rendercanvas by name, and let the plan go
• change: Ask the array how long it is rather than the wrapper
• change: Blend a whole record at once, rather than field by field
• change: Clean Animation.begin (#2492)
• change: Close a fill's border around its own subpaths
• change: Compare a frame's uniforms in one pass, and let can_follow read it
• change: Count writes made through a view rather than asking callers to remember
• …and 51 more

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

3b1b/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.