🌟 Overview

Animora is to Manim what Seaborn is to Matplotlib.

Instead of manually calculating pixel coordinates, managing low-level point arrays, and choreographing dozens of vector mobjects, Animora enables you to write clean, declarative, and composable animations for educational videos, computer science lectures, technical presentations, and data stories.

from animora.core import Scene
from animora.datastructures import BST
from animora.theme import ModernDark, use_theme

class BinarySearchTreeDemo(Scene):
    def construct(self) -> None:
        with use_theme(ModernDark):
            # 1. Declaratively initialize a Binary Search Tree
            bst = BST([50, 30, 70, 20, 40])
            self.play(bst.animate_create())

            # 2. Insert key with animated comparison path: 50 -> 30 -> 40 -> 35
            self.play(bst.animate_insert(35))

            # 3. Search target key with instant visual highlight
            self.play(bst.animate_search(35))

💡 Why Animora?

🚀 Quick Start

1. Installation

Install Animora from PyPI:

pip install animora

(Optional: Install with development dependencies)

pip install "animora[dev]"

2. Verify Your Environment

Animora includes a built-in doctor to verify Python, Manim, and FFmpeg installations:

animora doctor

============================================================
 Animora System & Environment Diagnostics
============================================================
[PASS]   Python       : Python 3.11.8 (>= 3.10 supported)
[PASS]   Animora      : Animora 0.1.0 installed
[PASS]   Manim        : Manim Community 0.18.1 (compatible)
[PASS]   NumPy        : NumPy 1.26.4 installed
[PASS]   NetworkX     : NetworkX 3.2.1 installed
[PASS]   FFmpeg       : FFmpeg binary found at /usr/bin/ffmpeg
============================================================
Status: Environment is fully ready for Animora visualizations.

🛠️ CLI Tooling

Animora comes with a dedicated CLI for rapid prototyping and production export:

# 1. Scaffold a starter scene from template
animora new my_scene.py

# 2. Fast low-quality preview (instant rendering for iterative design)
animora preview my_scene.py --open

# 3. Full production quality render (1080p 60fps or 4K)
animora render my_scene.py --quality high

📦 Features & Examples

1. Visual Primitives & Container Panels

Compose shapes, text, arrows, and containers with semantic state animations:

from animora.core import Scene
from animora.components import Text, Shape, Panel, Arrow
from animora.theme import ModernDark, use_theme

class PrimitivesScene(Scene):
    def construct(self) -> None:
        with use_theme(ModernDark):
            title = Text("Visual Primitives", font_size=36)
            circle = Shape.circle(radius=0.6, fill_color="#38BDF8")
            rect = Shape.rounded_rectangle(width=2.0, height=1.2, corner_radius=0.15)
            card = Panel(circle, rect, title="Component Container")

            self.play(title.animate_fade_in())
            self.play(card.animate_create())
            self.play(circle.animate_highlight())

2. Automatic Layout Solvers

Pure geometric layout engines that automatically arrange collections of components:

from animora.components import Group, Shape
from animora.layout import GridLayout, CircularLayout

nodes = [Shape.circle(radius=0.3) for _ in range(8)]
group = Group(*nodes)

# Arrange in a 2x4 Grid
group.arrange(GridLayout(columns=4, col_spacing=0.5, row_spacing=0.5))

# Rearrange into a Circle
group.arrange(CircularLayout(radius=2.0))

3. Data Visualization

Mathematically rigorous chart components featuring dual-correctness:

from animora.core import Scene
from animora.dataviz import BarChart, Table

class ChartScene(Scene):
    def construct(self) -> None:
        chart = BarChart(
            data=[("MergeSort", 45), ("QuickSort", 30), ("BubbleSort", 120)],
            bar_width=0.7,
        )
        self.play(chart.animate_grow())
        self.play(chart.animate_highlight_bar(1, color="#10B981"))

4. Algorithm Visualizations & Tracing

Generate step-by-step algorithm animations directly from real execution traces:

from animora.core import Scene
from animora.datastructures import Array
from animora.algorithms import quick_sort

class SortingScene(Scene):
    def construct(self) -> None:
        arr = Array([45, 12, 89, 33, 7, 56])
        self.play(arr.animate_create())

        # Returns a sequence of step-by-step animations (compares, swaps, highlights)
        self.play(*quick_sort(arr))

5. Multi-Theme Scoping

Dynamically switch between built-in design systems (ModernDark, PaperLight, Cyberpunk, Monokai):

from animora.components import Text, Shape, Panel
from animora.theme import Cyberpunk, PaperLight, use_theme

with use_theme(Cyberpunk):
    neon_box = Panel(Shape.circle(), title=Text("Cyberpunk"))

with use_theme(PaperLight):
    clean_box = Panel(Shape.circle(), title=Text("Paper Light"))

🏗️ Architecture & Escape Hatch

Animora follows a strict 4-layer decoupled architecture:

┌────────────────────────────────────────────────────────┐
│ Layer 4: Algorithms & Data Visualization               │
│          (Sorting, Pathfinding, Charts, Trees, Tables) │
├────────────────────────────────────────────────────────┤
│ Layer 3: Layout Engines & Theme System                 │
│          (Grid, TreeLayout, ModernDark, Cyberpunk)     │
├────────────────────────────────────────────────────────┤
│ Layer 2: Visual Primitives & Containers                │
│          (Text, Shape, Connector, Arrow, Group, Panel) │
├────────────────────────────────────────────────────────┤
│ Layer 1: Core Abstractions & Manim Bridge              │
│          (Component, Scene, Animation, .manim_object)  │
└────────────────────────────────────────────────────────┘

The Native Manim Escape Hatch

You are never locked into Animora's abstractions. Every single component exposes its underlying Manim vector entity through .manim_object:

import manim
from animora.components import Shape

circle = Shape.circle(radius=1.0)
native_mobject = circle.manim_object  # Access raw Manim VMobject

# Use raw Manim shaders, gradients, or updaters freely
native_mobject.set_color_by_gradient(manim.BLUE, manim.PINK)

🎨 Example Gallery

Check out runnable examples located in the examples/ directory:

• 01_basics_and_shapes.py — Visual primitives & container panels.
• 02_layout_and_grouping.py — Automatic layout solvers.
• 03_themes_and_styling.py — Multi-theme scoping.
• 04_dataviz_charts.py — Bar charts & data visualization.
• 05_datastructures_bst.py — Binary Search Tree with path tracing.
• 06_algorithms_sorting.py — Quick Sort animation.
• 07_pathfinding_dijkstra.py — Dijkstra graph shortest path.

🤝 Contributing

We welcome community contributions! Please read our Contributing Guide and review our Code of Conduct before submitting pull requests.

Development Setup

git clone https://github.com/himanshu-jadhav108/Animora.git
cd Animora
pip install -e ".[dev]"
pytest
ruff check src/
mypy src/

👤 Creator

Animora was created by Himanshu Jadhav and is developed as an open-source Python animation framework for educational, mathematical, algorithmic, and technical visualization.

Himanshu Jadhav Artificial Intelligence & Data Science Engineer Passionate about computer vision, mathematical animation engines, declarative developer tooling, and high-performance algorithms.

📄 License & Intellectual Property

Animora's source code is released under the MIT License.

• Copyright Notice: COPYRIGHT.md — Copyright © 2026 Himanshu Jadhav.
• Brand & Fork Policy: TRADEMARKS.md — Guidelines for project branding, naming forks, and derivative works.
• Third-Party Notices: THIRD_PARTY_NOTICES.md — Dependency attributions and upstream license details.
• Security Policy: SECURITY.md — Vulnerability reporting guidelines and security procedures.

(The MIT License applies to the source code and does not grant permission to use the Animora name, logo, or branding in a way that implies official affiliation or endorsement.)

💖 Acknowledgements

• Manim Community for the foundational vector graphics and mathematical animation engine.
• NumPy for high-performance numerical computing and array operations.
• NetworkX for graph data structures and force-directed spring layout algorithms.
• FFmpeg for specialized media demuxing and video stream encoding.
• MkDocs Material for modern, responsive documentation tooling.
• The open-source mathematical visualization and computer science community.

Animora — Declarative Animation Engine for Python