manim-mcp 0.1.0

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "manim-mcp",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "MCP server for generating 3Blue1Brown-style math animation videos with AI narration in Claude",
+  "main": "dist/index.js",
+  "files": [
+    "dist/index.js",
+    "dist/server.js",
+    "dist/mcp-app.html",
+    "dist/demo.mp4",
+    "references"
+  ],
+  "scripts": {
+    "build": "tsc --noEmit && cross-env INPUT=mcp-app.html vite build && tsc -p tsconfig.server.json && npx esbuild server.ts --bundle --platform=node --format=esm --outfile=dist/server.js --external:@modelcontextprotocol/sdk --external:@modelcontextprotocol/ext-apps --external:express --external:cors --external:zod && npx esbuild main.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:./server.js --external:@modelcontextprotocol/sdk --external:@modelcontextprotocol/ext-apps --external:express --external:cors --external:zod --banner:js='#!/usr/bin/env node'",
+    "dev": "cross-env NODE_ENV=development concurrently \"cross-env INPUT=mcp-app.html vite build --watch\" \"npx tsx --watch main.ts\"",
+    "start": "node dist/index.js --stdio",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/ext-apps": "^1.0.0",
+    "@modelcontextprotocol/sdk": "^1.24.0",
+    "cors": "^2.8.5",
+    "express": "^5.1.0",
+    "zod": "^4.1.13"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.0",
+    "@types/node": "22.10.0",
+    "concurrently": "^9.2.1",
+    "cross-env": "^10.1.0",
+    "esbuild": "^0.27.3",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vite": "^6.0.0",
+    "vite-plugin-singlefile": "^2.3.0"
+  },
+  "bin": {
+    "manim-mcp": "dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zcsabbagh/manim-mcp.git"
+  },
+  "homepage": "https://github.com/zcsabbagh/manim-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/zcsabbagh/manim-mcp/issues"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "manim",
+    "3blue1brown",
+    "animation",
+    "math",
+    "video",
+    "education",
+    "claude",
+    "ai"
+  ],
+  "license": "MIT",
+  "author": "Zane Sabbagh",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/references/composer/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: manim-composer
+description: |
+  Trigger when: (1) User wants to create an educational/explainer video, (2) User has a vague concept they want visualized, (3) User mentions "3b1b style" or "explain like 3Blue1Brown", (4) User wants to plan a Manim video or animation sequence, (5) User asks to "compose" or "plan" a math/science visualization.
+
+  Transforms vague video ideas into detailed scene-by-scene plans (scenes.md). Conducts research, asks clarifying questions about audience/scope/focus, and outputs comprehensive scene specifications ready for implementation with ManimCE or ManimGL.
+
+  Use this BEFORE writing any Manim code. This skill plans the video; use manimce-best-practices or manimgl-best-practices for implementation.
+---
+
+## Workflow
+
+### Phase 1: Understand the Concept
+
+1. **Research the topic** deeply before asking questions
+   - Use web search to understand the core concepts
+   - Identify the key insights that make this topic interesting
+   - Find the "aha moment" - what makes this click for learners
+   - Note common misconceptions to address
+
+2. **Identify the narrative hook**
+   - What question does this video answer?
+   - Why should the viewer care?
+   - What's the surprising or counterintuitive element?
+
+### Phase 2: Clarify with User
+
+Ask targeted questions (not all at once - adapt based on responses):
+
+**Audience & Scope**
+- What math/science background should I assume? (e.g., "knows calculus" or "high school algebra")
+- Target video length? (short: 5-10min, medium: 15-20min, long: 30min+)
+- Should this be self-contained or part of a series?
+
+**Focus & Depth**
+- Any specific aspects to emphasize or skip?
+- Proof-heavy or intuition-focused?
+- Real-world applications to include?
+
+**Style Preferences**
+- Color scheme preferences?
+- Narration style? (casual, formal, playful)
+- Any specific visual metaphors you have in mind?
+
+### Phase 3: Create scenes.md
+
+Output a comprehensive `scenes.md` file with this structure:
+
+```markdown
+# [Video Title]
+
+## Overview
+- **Topic**: [Core concept]
+- **Hook**: [Opening question/mystery]
+- **Target Audience**: [Prerequisites]
+- **Estimated Length**: [X minutes]
+- **Key Insight**: [The "aha moment"]
+
+## Narrative Arc
+[2-3 sentences describing the journey from confusion to understanding]
+
+---
+
+## Scene 1: [Scene Name]
+**Duration**: ~X seconds
+**Purpose**: [What this scene accomplishes]
+
+### Visual Elements
+- [List of mobjects needed]
+- [Animations to use]
+- [Camera movements]
+
+### Content
+[Detailed description of what happens, what's shown, what's explained]
+
+### Narration Notes
+[Key points to convey, tone, pacing notes]
+
+### Technical Notes
+- [Specific Manim classes/methods to use]
+- [Any tricky implementations to note]
+
+---
+
+## Scene 2: [Scene Name]
+...
+
+---
+
+## Transitions & Flow
+[Notes on how scenes connect, recurring visual motifs]
+
+## Color Palette
+- Primary: [color] - used for [purpose]
+- Secondary: [color] - used for [purpose]
+- Accent: [color] - used for [purpose]
+- Background: [color]
+
+## Mathematical Content
+[List of equations, formulas, or mathematical objects that need to be rendered]
+
+## Implementation Order
+[Suggested order for implementing scenes, noting dependencies]
+```
+
+## 3b1b Style Principles
+
+Apply these principles when composing scenes:
+
+### Visual Storytelling
+- **Show, don't just tell** - Every concept needs a visual representation
+- **Progressive revelation** - Build complexity gradually, don't show everything at once
+- **Visual continuity** - Transform objects rather than replacing them when possible
+
+### Pacing & Rhythm
+- **Pause for insight** - Give viewers time to absorb key moments
+- **Vary the pace** - Mix quick sequences with slower explanations
+- **End scenes with resolution** - Each scene should feel complete
+
+### Mathematical Beauty
+- **Emphasize elegance** - Highlight when math is surprisingly simple or beautiful
+- **Connect representations** - Show the same concept multiple ways (algebraic, geometric, intuitive)
+- **Embrace abstraction gradually** - Start concrete, then generalize
+
+### Engagement Techniques
+- **Pose questions** - Make viewers curious before revealing answers
+- **Acknowledge difficulty** - "This might seem confusing at first..."
+- **Celebrate insight** - Make the "aha moment" feel earned
+
+## References
+
+### Core References
+- [references/narrative-patterns.md](references/narrative-patterns.md) - Common 3b1b narrative structures (Mystery, Build-Up, Two Perspectives, Wrong->Right, Specific->General, History, Tourist's Guide, Puzzle)
+- [references/visual-techniques.md](references/visual-techniques.md) - Effective visualization patterns, animation timing, color palettes, scene composition layouts
+- [references/scene-examples.md](references/scene-examples.md) - Example scenes.md excerpts from dot product, Fourier, transformations, transformers, Bayes, and Galton board
+
+### Video Planning References
+- [references/3b1b-series-patterns.md](references/3b1b-series-patterns.md) - Proven series structures: EoLA (11 ch), EoC (11 ch), Neural Networks (4 parts), DiffEq (5 parts), Transformers (6+ parts), Laplace (5+ parts). How series build progressively.
+- [references/opening-patterns.md](references/opening-patterns.md) - How 3b1b opens videos: Opening Quotes (with full EoLA quote list), Mystery First, Physical Scenario, Question-Driven, Pi Creature Classroom, Historical Narrative, Result Preview
+- [references/scene-archetypes.md](references/scene-archetypes.md) - Reusable scene templates: TeacherStudentsScene, OpeningQuote, Grid Transformation, Equation Derivation, Side-by-Side Comparison, Phase Space, Progressive Build, Proof, Simulation, Data Visualization, 3D Surface, Quiz/Reveal, Taxonomy
+- [references/pacing-guide.md](references/pacing-guide.md) - Detailed timing: overall video structure, scene-level pacing, animation run_time values, wait/pause patterns, lag_ratio guidelines, the "earned wait" principle
+- [references/mathematical-storytelling.md](references/mathematical-storytelling.md) - Narrative craft: start with questions not definitions, show the wrong approach first, physical analogy before formal math, specific cases before general formula, multiple perspectives, aha moment placement, broader connections
+
+### Domain-Specific Planning
+- [references/domain-planning-guides/linear-algebra-planning.md](references/domain-planning-guides/linear-algebra-planning.md) - EoLA structure, grid transformation as core visual, basis vector color coding (GREEN/RED), eigenvalue visualization, change-of-basis pattern
+- [references/domain-planning-guides/calculus-planning.md](references/domain-planning-guides/calculus-planning.md) - EoC structure, geometric vs algebraic approach, Riemann rectangle progression, circle area derivation, "nudge" language, the Car metaphor
+- [references/domain-planning-guides/probability-planning.md](references/domain-planning-guides/probability-planning.md) - Bayesian reasoning structure, population grid visualization, CLT dice progression, Beta distribution updating, simulation speed-up pattern
+- [references/domain-planning-guides/physics-planning.md](references/domain-planning-guides/physics-planning.md) - Phase space dual view, vector fields and stream lines, simulation design (spring-mass, SIR, sliding blocks), wave physics, celestial mechanics
+- [references/domain-planning-guides/ml-planning.md](references/domain-planning-guides/ml-planning.md) - Neural network visualization, transformer architecture breakdown, weight matrix coloring, live model integration, attention arc animation, auto-regression loop
+- [references/domain-planning-guides/number-theory-planning.md](references/domain-planning-guides/number-theory-planning.md) - Prime visualization (YELLOW), zeta function spirals, complex plane phase coloring, Moser's circle problem, Pascal's triangle, modular arithmetic patterns
+
+## Templates
+
+- [templates/scenes-template.md](templates/scenes-template.md) - Blank scenes.md template

package/references/composer/references/3b1b-series-patterns.md

@@ -0,0 +1,217 @@
+# 3Blue1Brown Series Structures
+
+Proven multi-part series structures from actual 3b1b videos (2015-2026). Use these as blueprints when planning multi-video series.
+
+---
+
+## Essence of Linear Algebra (2016) -- 11 Chapters + 2 Footnotes
+
+The gold standard for a "core concept" series. Each chapter opens with a quote from a mathematician, establishing intellectual gravitas.
+
+### Chapter Progression
+
+| Ch | Title | Core Concept | Builds On |
+|----|-------|--------------|-----------|
+| 0 | Preview | Why linear algebra matters, series roadmap | -- |
+| 1 | Vectors, what even are they? | Three perspectives: physics (arrows), CS (lists), math (abstract) | -- |
+| 2 | Linear combinations, span, bases | Scaling + adding vectors, span as reachable space | Ch 1 |
+| 3 | Matrices as linear transformations | Grid transformation, basis vectors determine everything | Ch 1-2 |
+| 4 | Matrix multiplication as composition | Applying two transformations = multiplying their matrices | Ch 3 |
+| 5 | Three-dimensional linear transformations | 3x3 matrices, 3D grid, same intuition in higher dimension | Ch 3-4 |
+| 6 | The determinant | Area/volume scaling factor, sign = orientation flip | Ch 3-5 |
+| 7 | Inverse matrices, column space, null space | When transformations are reversible, what space gets squished | Ch 3-6 |
+| 8 | Nonsquare matrices as transformations between dimensions | Mapping 3D to 2D and vice versa, rank | Ch 7 |
+| 8.5 | Cross products in the light of linear transformations | Cross product as determinant with one variable column | Ch 6-8 |
+| 9 | Dot products and duality | Why component multiplication relates to projection | Ch 3, 8 |
+| 10 | Change of basis | "Your coordinates vs Jennifer's coordinates" | Ch 3, 9 |
+| 11 | Eigenvectors and eigenvalues | Vectors that stay on their span, diagonal matrices | Ch 3-10 |
+| Fn1 | Abstract vector spaces | Functions as vectors, axioms, the "abstractness" debate | Ch 1-11 |
+| Fn2 | Cramer's rule, geometrically | Solving systems via transformed parallelepipeds | Ch 6-7 |
+
+### Design Principles from EoLA
+
+1. **"Three perspectives" framing**: Introduce concepts through physics student, CS student, mathematician perspectives (chapter 1). This humanizes abstract ideas.
+2. **Opening quotes from real mathematicians**: Jean Dieudonne (ch0), Hermann Weyl (ch1), Angus K. Rodgers (ch2), Morpheus (ch3 -- yes, The Matrix), Emil Artin (ch4), Richard Hamming (ch5), Georg Cantor (ch6), Jeff Lagarias (ch8), Pierre Deligne (ch8.5), Henri Poincare (ch9), Serge Lang (ch10), Vladimir Arnold (ch11).
+3. **Progressive complexity with constant callbacks**: Each new concept is explained by transforming familiar objects from earlier chapters.
+4. **The grid is sacred**: The NumberPlane grid transformation is THE core visual. It appears in nearly every chapter.
+5. **Footnotes for depth**: Side topics that would break the main flow get their own videos (Cramer's rule, abstract spaces).
+
+### Series Structure Pattern
+
+```
+Ch 0: What is this series? (preview/motivation)
+Ch 1-2: Foundation vocabulary (vectors, combinations)
+Ch 3-5: Core mechanism (transformations, composition, 3D)
+Ch 6-9: Derived properties (determinant, inverses, nonsquare, dot product)
+Ch 10-11: Advanced applications (change of basis, eigenvectors)
+Footnotes: Deep dives on side topics
+```
+
+---
+
+## Essence of Calculus (2017) -- 11 Chapters + 1 Footnote
+
+### Chapter Progression
+
+| Ch | Title | Core Concept | Builds On |
+|----|-------|--------------|-----------|
+| 1 | The essence of calculus | Area of circle via rings = derivative/integral preview | -- |
+| 2 | The paradox of the derivative | Instantaneous rate of change, limits informally | -- |
+| 3 | Derivative formulas through geometry | Power rule, sum rule via geometric areas | Ch 2 |
+| 4 | Visualizing the chain rule and product rule | Nested boxes for chain rule, rectangle for product | Ch 3 |
+| 5 | What's so special about Euler's number? | e^t derivative = itself, natural log | Ch 2-4 |
+| 6 | Implicit differentiation | Multivariable chain rule on curves | Ch 4-5 |
+| 7 | Limits | Epsilon-delta, L'Hopital's | Ch 2-6 |
+| 8 | Integration and the fundamental theorem | Antiderivatives, area accumulation | Ch 1-7 |
+| 9 | What does area have to do with slope? | Why FTC works, lower bound sliding | Ch 8 |
+| 10 | Higher order derivatives | Curvature, Taylor preview | Ch 2-8 |
+| 11 | Taylor series | Polynomial approximations, convergence | Ch 10 |
+| Fn | L'Hopital's rule | Geometric proof via parametric curves | Ch 7 |
+
+### Design Principles from EoC
+
+1. **Start with geometry, not formulas**: Chapter 1 derives the circle area formula using concentric rings -- you SEE why 2*pi*r integrates to pi*r^2 before any formal calculus.
+2. **"Car on a road" metaphor**: A recurring Car mobject with position s(t), velocity v(t) makes derivatives tangible (chapter 2).
+3. **Area rectangles as the fundamental visual**: Riemann rectangles appear in multiple chapters with progressively finer dx.
+4. **Deliberate avoidance of epsilon-delta until chapter 7**: Build intuition first, rigor later. When limits finally appear, the viewer already has strong geometric intuition.
+5. **The "nudge" language**: Instead of "infinitesimal," Grant uses "tiny nudge dx" -- accessible language for the same concept.
+
+---
+
+## Neural Networks (2017) -- 4 Parts
+
+### Chapter Progression
+
+| Part | Title | Core Concept | Builds On |
+|------|-------|--------------|-----------|
+| 1 | But what is a neural network? | Layers, neurons, weights, biases, activation | -- |
+| 2 | Gradient descent, how neural networks learn | Cost function, gradient, learning rate | Part 1 |
+| 3 | What is backpropagation really doing? | Chain rule through the network, sensitivity | Part 1-2 |
+| 4 | Backpropagation calculus | The actual math of backprop derivatives | Part 3 |
+
+### Design Principles from NN Series
+
+1. **Concrete problem first**: Start with MNIST digit recognition, not abstract NN theory.
+2. **Pixels as input**: Uses `PixelsAsSquares` to show raw pixel data flowing into the network.
+3. **Visualization of activations**: Dot opacity represents activation level -- you see the network "light up."
+4. **Cost function before optimization**: Spend a full video establishing what "good" means before showing how to get there.
+5. **Progressive formalism**: Part 1 is almost formula-free. Part 4 is full calculus. The viewer is gradually brought along.
+
+---
+
+## Differential Equations (2019) -- 5 Parts
+
+### Chapter Progression
+
+| Part | Title | Core Concept | Builds On |
+|------|-------|--------------|-----------|
+| 1 | Differential equations, a tourist's guide | Pendulum, phase space, vector fields | -- |
+| 2 | But what is a partial differential equation? | Heat equation, temperature evolution | Part 1 |
+| 3 | Solving the heat equation | Boundary conditions, Fourier's insight | Part 2 |
+| 4 | But what is a Fourier series? | Rotating vectors, complex exponentials, epicycles | Part 3 |
+| 5 | Understanding e to the i pi in 3.14 minutes | Euler's formula as rotational dynamics | Part 4 |
+
+### Design Principles from DiffEq Series
+
+1. **Physical system first**: Part 1 opens with a pendulum, not an equation. The ODE emerges from the physics.
+2. **Phase space as the key visual**: The pendulum's theta-vs-omega phase portrait IS the video -- this dual representation (physical system + phase space side-by-side) is a signature technique.
+3. **Vector fields as flows**: `StreamLines` and `AnimatedStreamLines` show solutions as trajectories through a vector field.
+4. **The "tourist's guide" framing**: Explicitly sets expectations: we're surveying, not proving. This liberates the narrative.
+5. **Each part stands alone but connects**: Each video has its own hook and resolution, but also sets up the next.
+
+---
+
+## Transformers / Deep Learning (2024) -- 6+ Parts
+
+The most architecturally complex series. Files span `attention.py`, `embedding.py`, `mlp.py`, `network_flow.py`, `auto_regression.py`, `generation.py`, plus `helpers.py`, `chm.py`, `supplements.py`, `ml_basics.py`.
+
+### Chapter Progression
+
+| Part | Topic | Core Concept | Key File |
+|------|-------|--------------|----------|
+| 1 | What is a transformer? | High-level architecture, token flow | `network_flow.py` |
+| 2 | Attention | Query-key-value, dot product attention, softmax | `attention.py` |
+| 3 | Embeddings | Tokenization, word2vec, semantic directions | `embedding.py` |
+| 4 | MLP layers | Non-linear transformations, parameter counts | `mlp.py` |
+| 5 | Auto-regression | Next-token prediction, probability distributions | `auto_regression.py` |
+| 6 | Generation | Live GPT-2/GPT-3 inference, temperature, sampling | `generation.py` |
+
+### Design Principles from Transformer Series
+
+1. **Custom mobjects for domain concepts**: `WeightMatrix`, `NumericEmbedding`, `EmbeddingArray`, `NeuralNetwork`, `MachineWithDials`, `Dial` -- each concept gets its own visual class.
+2. **Live model inference**: Actual GPT-2 and GPT-3 produce predictions IN the animation. This grounds abstract architecture in real behavior.
+3. **The 3D block metaphor**: Transformer blocks rendered as `VPrism` objects with depth, rotation, and shading create a visceral sense of data flowing through architecture.
+4. **Color-coded matrix values**: `value_to_color()` maps positive values to blue, negative to red, creating instant visual feedback about what matrices "contain."
+5. **Arc-based attention visualization**: `ContextAnimation` uses curved arcs between token positions, colored and weighted by attention strength. This became an iconic representation.
+6. **Progressive depth across videos**: Start with black-box overview, then open each box (attention, embedding, MLP) in subsequent videos.
+
+---
+
+## Laplace Transform (2025) -- 5+ Parts
+
+### Chapter Progression
+
+| Part | Topic | Core Concept | Key File |
+|------|-------|--------------|----------|
+| Prequel | Exponentials as building blocks | Why e^st matters for DiffEq | `exponentials.py` |
+| 1 | Main equations | The transform formula, converting ODEs | `main_equations.py` |
+| 2 | Derivatives | Why derivatives become multiplication by s | `derivatives.py` |
+| 3 | Integration | Integration in s-domain | `integration.py` |
+| 4 | Spring-mass system (SHM) | Solving a real ODE with Laplace | `shm.py` |
+
+### Design Principles from Laplace Series
+
+1. **Consistent color coding**: `S_COLOR = YELLOW` (frequency domain), `T_COLOR = BLUE` (time domain) used in every equation via `t2c` mapping.
+2. **Commutative diagrams**: Time-domain operations (top row) connected to s-domain operations (bottom row) by vertical Laplace transform arrows.
+3. **Complex surface visualization**: `ParametricSurface` colored by phase (`z_to_color`) for showing the Laplace transform as a 3D landscape over the complex s-plane.
+4. **Interactive pole manipulation**: `ComplexValueTracker` with `TrueDot` + `GlowDot` pairs for dragging poles on the s-plane and watching the impulse response change.
+5. **Physical simulation payoff**: The spring-mass `SrpingMassSystem` with real physics integration provides the tangible "this is what it's for" moment.
+
+---
+
+## Series Design Meta-Patterns
+
+### The Universal Series Arc
+
+```
+Video 1: What is [concept]? (Motivation, big picture, preview of payoff)
+Video 2-3: Core mechanism (The main ideas, with visual intuition)
+Video 4-N: Applications and depth (Use the tools, go deeper)
+Optional: Footnotes, supplements (Side topics, corrections, extras)
+```
+
+### How Series Build Progressively
+
+1. **Vocabulary first**: Early videos establish visual vocabulary (vectors, matrices, neurons, tokens). Later videos can use these freely.
+2. **Each video has its own complete arc**: Even within a series, each video has hook -> investigation -> resolution. A viewer should feel satisfied after one video.
+3. **Forward references create anticipation**: "We'll see in the next chapter why this matters..." builds series loyalty.
+4. **Backward references create depth**: "Remember how we saw that transformations preserve grid lines? Well..." rewards returning viewers.
+5. **Increasing abstraction**: Concrete -> specific pattern -> general principle -> abstract framework.
+6. **Shared helper files**: Every series has a `helpers.py` with custom mobjects and utility functions reused across videos.
+
+### Series Length Guidelines
+
+| Series Type | Typical Length | Example |
+|-------------|---------------|---------|
+| Core curriculum | 10-12 chapters | EoLA, EoC |
+| Focused topic | 4-6 parts | Neural Networks, Transformers, Laplace |
+| Mini-series | 2-3 parts | Bayes, Convolutions |
+| One-off with follow-up | 1 + footnote | Wordle, Newton's Fractal |
+
+### The "Essence of" Formula
+
+When creating an "Essence of X" series:
+1. Ch 0: Preview -- show the beautiful result, explain why X matters, outline the journey
+2. Ch 1-3: Build the fundamental objects and operations
+3. Ch 4-6: Derive key properties from those operations
+4. Ch 7-9: Connect to other areas, show surprising applications
+5. Ch 10+: Advanced topics, unifying themes
+6. Each chapter: Opening quote -> Main content -> Pi creature interludes -> Implications
+
+### Supplement and Footnote Patterns
+
+Most major series include supplementary content:
+- **`supplements.py`**: Additional scenes, B-roll, Pi creature reactions, thumbnail generation
+- **`wordy_scenes.py`** or **`pi_scenes.py`**: TeacherStudentsScene interactions for emotional beats
+- **Footnotes**: Corrections, deeper dives, alternative proofs
+- **Thumbnails**: Custom thumbnail scene classes

package/references/composer/references/domain-planning-guides/calculus-planning.md

@@ -0,0 +1,188 @@
+# Calculus Video Planning Guide
+
+Based on the Essence of Calculus series (2017), alternative calculus approach (`_2018/alt_calc.py`), and related content across the 3b1b codebase.
+
+---
+
+## Core Visual Language
+
+### The Riemann Rectangle Progression
+
+The fundamental calculus visual: rectangles under a curve that get thinner.
+
+```python
+# Progressive refinement
+rects = axes.get_riemann_rectangles(graph, x_min=0, x_max=4, dx=0.2)
+rects.set_submobject_colors_by_gradient(BLUE, GREEN)
+rects.set_opacity(1)
+rects.set_stroke(BLACK, 1)
+
+# Animate decreasing dx
+for new_dx in [0.1, 0.05, 0.01]:
+    new_rects = axes.get_riemann_rectangles(graph, dx=new_dx)
+    self.play(Transform(rects, new_rects))
+```
+
+### The "Nudge" Visual
+
+Instead of "infinitesimal," show a tiny but visible dx and the resulting df:
+
+```python
+# Tangent line approach
+x = 2
+dx = 0.5
+# Show the input nudge (horizontal bar)
+dx_line = Line(axes.c2p(x, 0), axes.c2p(x + dx, 0), color=GREEN)
+dx_label = Tex("dx", color=GREEN).next_to(dx_line, DOWN)
+# Show the output nudge (vertical bar)
+df_line = Line(axes.c2p(x + dx, f(x)), axes.c2p(x + dx, f(x + dx)), color=YELLOW)
+df_label = Tex("df", color=YELLOW).next_to(df_line, RIGHT)
+```
+
+### The Car on a Road
+
+From EoC Chapter 2, a recurring metaphor: position s(t) on top, velocity v(t) = ds/dt below.
+
+```python
+# Car mobject (from _2017/eoc/chapter2.py)
+class Car(SVGMobject):
+    # Car SVG with configurable color
+class MoveCar(Animation):
+    # Animates car along a road
+```
+
+---
+
+## Chapter Planning by Topic
+
+### Area of a Circle (EoC Ch 1)
+
+**The most important scene in all of EoC**: Concentric rings unfurled into thin rectangles, forming a triangle whose area is pi*r^2.
+
+**Key scenes:**
+1. Circle with concentric rings (colors: BLUE inner to GREEN outer)
+2. "Unroll" a single ring into a thin rectangle (length = 2*pi*r, height = dr)
+3. Stack all rectangles: they form a triangle
+4. Triangle base = 2*pi*R, height = R, area = pi*R^2
+5. "This IS integration, even before we call it that"
+
+**From `CircleScene` in `_2017/eoc/chapter1.py`:**
+```python
+CONFIG = {
+    "radius": 1.5,
+    "fill_color": BLUE_E,
+    "radial_line_color": MAROON_B,
+    "outer_ring_color": GREEN_E,
+    "ring_colors": [BLUE, GREEN],
+    "dR": 0.1,
+    "dR_color": YELLOW,
+}
+```
+
+### Derivatives (EoC Ch 2-3)
+
+**Geometric approach to derivative rules:**
+
+**Power rule via areas:**
+1. x^2: draw a square with side x, grow by dx, new area = 2x*dx + dx^2
+2. x^3: draw a cube with side x, grow by dx, new volume = 3x^2*dx + ...
+3. Pattern: d/dx(x^n) = n*x^(n-1)
+
+**Chain rule via nested boxes (EoC Ch 4):**
+1. Inner function g(x): one box
+2. Outer function f(g(x)): box around the box
+3. Change in x -> change in g -> change in f
+4. df/dx = df/dg * dg/dx (chain of nudges)
+
+**Product rule via rectangle (EoC Ch 4):**
+1. Rectangle with sides f(x) and g(x)
+2. Area = f*g
+3. Grow x by dx: two new strips + tiny corner
+4. d(fg)/dx = f'g + fg' (the two strips)
+
+### Integration and FTC (EoC Ch 8-9)
+
+**Key visual: accumulation function**
+1. Graph of f(x) on top
+2. Below: shaded area from 0 to x, updating as x moves
+3. The area IS the antiderivative
+4. Fundamental theorem: the rate of area growth equals the function height
+
+**The slider technique:**
+```python
+x_tracker = ValueTracker(0)
+area = always_redraw(lambda: axes.get_area(
+    graph, x_range=[0, x_tracker.get_value()], color=BLUE, opacity=0.5
+))
+self.play(x_tracker.animate.set_value(4), run_time=5)
+```
+
+### Taylor Series (EoC Ch 11)
+
+**Progressive approximation:**
+1. Show the function
+2. Match value at point: constant term
+3. Match slope: linear term
+4. Match curvature: quadratic term
+5. Keep going: each term captures more
+6. The polynomial "hugs" the function more and more closely
+
+---
+
+## Geometric vs Algebraic Approach
+
+The defining choice of 3b1b calculus: ALWAYS lead with geometry.
+
+### Geometric First
+
+| Concept | Geometric Approach | Algebraic (secondary) |
+|---------|-------------------|----------------------|
+| Derivative | Slope of tangent line, rate of area growth | lim (f(x+h)-f(x))/h |
+| Integral | Area under curve, accumulated quantity | Sum of f(x_i)*dx |
+| Chain rule | Nested nudges through compositions | d/dx f(g(x)) = f'(g(x))g'(x) |
+| Product rule | Two strips of a growing rectangle | d/dx (fg) = f'g + fg' |
+| FTC | Area growth rate = function height | d/dx integral_0^x f(t)dt = f(x) |
+
+### When to Use Algebra
+
+Algebra comes AFTER geometric intuition, for:
+1. Confirming the geometric result
+2. Computing specific values
+3. Showing the formula is general
+4. Connecting to standard notation
+
+---
+
+## Color Conventions for Calculus
+
+| Element | Color | Purpose |
+|---------|-------|---------|
+| Input x / independent variable | BLUE | Consistent with function input |
+| Output f(x) | GREEN or YELLOW | Function value |
+| Nudge dx | GREEN | Small change in input |
+| Resulting change df | YELLOW | Small change in output |
+| Area under curve | BLUE with opacity 0.5 | Integral visualization |
+| Riemann rectangles | BLUE-GREEN gradient | Progressive refinement |
+| Tangent line | YELLOW | Derivative visualization |
+| Error/remainder | RED | Taylor series error term |
+
+---
+
+## Alternative Calculus Approach (`_2018/alt_calc.py`)
+
+Grant explored an alternative presentation focusing on:
+- Functions as transformations of the number line
+- Derivative as local scaling factor
+- Integration as inverse of this scaling
+
+This provides a second perspective for videos that need to show calculus from an unusual angle.
+
+---
+
+## Common Pitfalls in Calculus Videos
+
+1. **Starting with limits**: Limits are the FOUNDATION of rigor but the ENEMY of intuition. Build intuition first (EoC delays limits to chapter 7).
+2. **Algebraic derivation without geometric meaning**: Every formula should have a picture.
+3. **Static graphs**: The derivative is about CHANGE. Animate the point moving along the curve, the tangent line rotating, the area growing.
+4. **"And then you just apply the formula"**: Show WHY the formula works, not just how to use it.
+5. **Epsilon-delta too early**: Save formal rigor for viewers who already have intuition.