Introduction

Murali is a modern animation engine inspired by the same spirit as Manim: mathematically precise, programmatic, GPU-accelerated animation. It takes that spirit in a Rust-native direction, with deterministic timelines, a modern wgpu backend, and a type system that helps larger animation codebases stay easier to maintain as they grow.

Unlike traditional animation tools, Murali treats animations as deterministic functions of time. Every frame is derived from a well-defined timeline, making visuals predictable, reproducible, and easy to reason about. Murali is especially shaped for workflows where animation supports an existing narrative, such as audio narration or pre-edited video, where precise timing and clean synchronization matter.

Powered by wgpu, Murali runs natively across Vulkan, Metal, and DirectX, and provides first-class support for LaTeX, Typst, and parametric geometry.

Why Murali?

Manim is powerful, but it comes with trade-offs that become more noticeable as projects grow:

• Built on OpenGL, which is deprecated on macOS
• Frame-driven animation logic, which works well for animation-first workflows, but can make narration-first or video-first workflows harder to synchronize cleanly
• Python’s dynamic typing makes large, complex scenes harder to maintain

Murali is designed to solve these at a foundational level:

• Modern GPU backend — built on wgpu (Vulkan / Metal / DX12), so Murali benefits from a modern cross-platform graphics stack instead of carrying that burden alone
• Time-driven architecture — animations are explicit functions of time, not frames
• Rust type system — enables safer, more maintainable large-scale animation code

The result is an engine that feels closer to engineering a system than scripting visuals.

Why not Murali?

Murali is a new library, with its first release in April 2026. It neither has, nor aims for, 1:1 feature parity with Manim. The APIs are still evolving, and many features are on the roadmap but not yet implemented. If you need a highly mature tool with a large ecosystem of existing content, Manim is likely the better choice today.

Murali will evolve through real-world use. The author is building it in part for aiunderthehood.com, and feedback from that work will strongly influence the direction of the library. If you have a specific use case in mind, please share it on GitHub Discussions.

Core concepts

Murali introduces a small set of composable primitives:

• Tattva — any object in a scene (shape, text, or composite). Derived from Sanskrit, meaning “element” or “essence.”
• Scene — a container for all tattvas and their timelines
• Timeline — defines how properties evolve over time
• World space — all coordinates exist in mathematical units, not pixels

These abstractions allow you to describe animations declaratively, while retaining full programmatic control.

Installation

Murali is currently available via GitHub. For the full setup flow, see Installation.

Add it to your Cargo.toml:

[dependencies]
murali = { git = "https://github.com/ravishankarkumar/murali" }
anyhow = "1.0"
glam = "0.29"

Requirements:

• Rust toolchain (1.70 or later)
• A working graphics environment (for preview mode)
• ffmpeg (optional, for video export)

Quick start:

cargo new --bin my_scene
cd my_scene
mkdir -p examples

If you want to verify optional tools like ffmpeg, latex, and dvisvgm, run:

cargo run -- doctor

What You'll Learn in 10 Minutes

By following the Your First Scene guide, you'll learn how to:

1. Create a scene and add visual objects (tattvas)
2. Position objects in 3D space using world coordinates
3. Build a timeline to schedule animations
4. Animate properties like position, scale, and opacity
5. Run your scene in preview mode or export it as video

The core workflow is simple:

Create Scene → Add Tattvas → Build Timeline → Play Timeline → Run App

Your First Scene

Here's a minimal example that draws and undraws a circle:

use murali::colors::GREEN_E;
use murali::prelude::{ORIGIN, CAMERA_DEFAULT_POS};
use murali::{App};
use murali::engine::scene::Scene;
use murali::engine::timeline::Timeline;
use murali::frontend::animation::Ease;
use murali::frontend::collection::primitives::circle::Circle;

fn main() -> anyhow::Result<()> {
    // 1. Create a scene
    let mut scene = Scene::new();
    
    // 2. Add a circle tattva
    let circle_id = scene.add_tattva(
        Circle::new(1.5, 48, GREEN_E),
        ORIGIN,
    );
    
    // 3. Position the camera
    scene.camera_mut().position = CAMERA_DEFAULT_POS;

    // 4. Create a timeline with animations
    let mut timeline = Timeline::new();
    timeline
        .animate(circle_id)
        .at(1.0)
        .for_duration(1.5)
        .ease(Ease::OutCubic)
        .draw()
        .spawn();
    
    timeline
        .animate(circle_id)
        .at(4.0)
        .for_duration(1.0)
        .ease(Ease::InCubic)
        .undraw()
        .spawn();

    timeline.wait_until(5.5);

    // 5. Play the timeline
    scene.play(timeline);

    // 6. Run the app
    App::new()?.with_scene(scene).run_app()
}

Running Your Scene

Preview mode (opens a window):

cargo run --example my_scene --release -- --preview

Export mode (creates video):

cargo run --example my_scene --release -- --export
// or
cargo run --example my_scene 

// Without preview mode, scenes export to video by default

tip

For a detailed walkthrough of building your first scene step-by-step, see the Your First Scene guide.

Learning Path

After completing your first scene, we recommend this progression:

1. Installation — Setup, prerequisites, and environment checks
2. Visual Foundations — Important utilities such as how to place an object at specified position, using colors, and more
3. Your First Scene — Step-by-step tutorial building a complete animation
4. Mental Model — Core concepts: Scene, Tattva, Timeline, and how they work together
5. Which API Should I Use? — Decision guide for common tasks
6. Animations — Complete reference for all animation verbs
7. Tattvas — Explore all available shapes, text, graphs, and components
8. Scene and App — Advanced scene management and app lifecycle

Quick navigation by use case:

• Visualizing math? → Text, Math, Graphs
• Visualizing data? → Graphs, Tables
• Explaining AI/ML? → AI Tattvas, Storytelling
• Need help? → Common First Mistakes

Why timeline-based animation?

Murali is built around a timeline-based animation model for several key reasons:

1. Determinism
   Animations are defined as explicit functions of time, making their behavior predictable and reproducible.

2. Precise temporal control
   Elements can be scheduled with exact timing—ideal for synchronizing with audio, video, or pre-defined narratives.

3. Random access (planned)
   In a timeline-based system, the state of a scene can be evaluated at any time instantly, without replaying previous frames.
   This capability is not yet implemented and will be introduced in future iterations. The current focus is on feature completeness.

4. Composability
   Animations combine naturally as independent functions of time, avoiding implicit state interactions.

Why the name “Murali”?

The name Murali comes from the flute of Lord Krishna, which, in Hindu tradition, is said to produce music so pure that it touches the soul.

The goal of this project is similar: to make visual storytelling feel effortless, so that ideas flow clearly from storyteller to viewer. Murali aims to make mathematical expression not just precise, but deeply intuitive.

---

Welcome to the community. We can't wait to see what you create.