@prismer/runtime 2.2.55 → 2.2.64

package/built-in-skills/prismer-manim-video/references/paper-explainer.md

@@ -0,0 +1,255 @@
+# Paper Explainer Workflow
+
+How to turn a research paper into an animated explainer video.
+
+## Why animate a paper?
+
+A research paper is optimized for precision and completeness. A video is optimized for understanding and retention. The translation is NOT "read the paper aloud with pictures" — it's "extract the core insight and make it feel obvious through visual storytelling."
+
+The paper has one job: prove the claim is true. The video has a different job: make the viewer understand WHY the claim is true, and WHY it matters.
+
+## Who is watching?
+
+Before anything, decide the audience:
+
+| Audience | Prerequisites | Pacing | Depth |
+|----------|--------------|--------|-------|
+| General public | None | Slow, many analogies | Intuition only, skip proofs |
+| Undergrad students | Basic math/CS | Medium, some formalism | Key equations, skip derivations |
+| Grad students / researchers | Domain knowledge | Faster, more notation | Full equations, sketch proofs |
+
+This determines everything: vocabulary, pacing, which sections to animate, how much math to show.
+
+## The 5-minute template
+
+Most paper explainers fit this structure (scale times proportionally for longer videos):
+
+| Section | Duration | Purpose |
+|---------|----------|---------|
+| **Hook** | 0:00-0:30 | Surprising result or provocative question |
+| **Problem** | 0:30-1:30 | What was broken/missing before this paper |
+| **Key insight** | 1:30-3:00 | The core idea, explained visually |
+| **How it works** | 3:00-4:00 | Method/algorithm, simplified |
+| **Evidence** | 4:00-4:30 | Key result that proves it works |
+| **Implications** | 4:30-5:00 | Why it matters, what it enables |
+
+### What to skip
+
+- Related work survey → one sentence: "Previous approaches did X, which had problem Y"
+- Implementation details → skip unless they're the contribution
+- Ablation studies → show one chart at most
+- Proofs → show the key step, not the full proof
+- Hyperparameter tuning → skip entirely
+
+### What to expand
+
+- The core insight → this gets the most screen time
+- Geometric/visual intuition → if the paper has math, show what it MEANS
+- Before/after comparison → the most compelling evidence
+
+## Pre-code workflow
+
+### Gate 1: Narration script
+
+Write the full narration before any code. Every sentence maps to a visual beat. If you can't write the narration, you don't understand the paper well enough to animate it.
+
+```markdown
+## Hook (30s)
+"What if I told you that a model with 7 billion parameters can outperform
+one with 70 billion — if you train it on the right data?"
+
+## Problem (60s)
+"The standard approach is to scale up. More parameters, more compute.
+[VISUAL: bar chart showing model sizes growing exponentially]
+But Chinchilla showed us that most models are undertrained..."
+```
+
+### Gate 2: Scene list
+
+After the narration, break it into scenes. Each scene is one Manim class.
+
+```markdown
+Scene 1: Hook — surprising stat with animated counter
+Scene 2: Problem — model size bar chart growing
+Scene 3: Key insight — training data vs parameters, animated 2D plot
+Scene 4: Method — pipeline diagram building left to right
+Scene 5: Results — before/after comparison with animated bars
+Scene 6: Closing — implications text
+```
+
+### Gate 3: Style constants
+
+Before coding scenes, define the visual language:
+
+```python
+# style.py — import in every scene file
+BG = "#0D1117"
+PRIMARY = "#58C4DD"
+SECONDARY = "#83C167"
+ACCENT = "#FFFF00"
+HIGHLIGHT = "#FF6B6B"
+MONO = "Menlo"
+
+# Color meanings for THIS paper
+MODEL_COLOR = PRIMARY      # "the model"
+DATA_COLOR = SECONDARY     # "training data"
+BASELINE_COLOR = HIGHLIGHT # "previous approach"
+RESULT_COLOR = ACCENT      # "our result"
+```
+
+## First-principles equation explanation
+
+When the paper has a key equation, don't just show it — build it from intuition:
+
+### The "what would you do?" pattern
+
+1. Pose the problem in plain language
+2. Ask what the simplest solution would be
+3. Show why it doesn't work (animate the failure)
+4. Introduce the paper's solution as the fix
+5. THEN show the equation — it now feels earned
+
+```python
+# Scene: Why we need attention (for a Transformer paper)
+# Step 1: "How do we let each word look at every other word?"
+# Step 2: Show naive approach (fully connected = O(n²) everything)
+# Step 3: Show it breaks (information overload, no selectivity)
+# Step 4: "What if each word could CHOOSE which words to attend to?"
+# Step 5: Show attention equation — Q, K, V now mean something
+```
+
+### Equation reveal strategy
+
+```python
+# Show equation dimmed first (full destination)
+eq = MathTex(r"Attention(Q,K,V) = softmax\left(\frac{QK^T}{\sqrt{d_k}}\right)V")
+eq.set_opacity(0.15)
+self.play(FadeIn(eq))
+
+# Highlight Q, K, V one at a time with color + label
+for part, color, label_text in [
+    (r"Q", PRIMARY, "Query: what am I looking for?"),
+    (r"K", SECONDARY, "Key: what do I contain?"),
+    (r"V", ACCENT, "Value: what do I output?"),
+]:
+    eq.set_color_by_tex(part, color)
+    label = Text(label_text, font_size=18, color=color, font=MONO)
+    # position label, animate it, wait, then dim it
+```
+
+## Building architecture diagrams
+
+### The progressive build pattern
+
+Don't show the full architecture at once. Build it:
+
+1. First component appears alone → explain
+2. Arrow grows → "this feeds into..."
+3. Second component appears → explain
+4. Repeat until complete
+
+```python
+# Component factory
+def make_box(label, color, width=2.0, height=0.8):
+    box = RoundedRectangle(corner_radius=0.1, width=width, height=height,
+                           color=color, fill_opacity=0.1, stroke_width=1.5)
+    text = Text(label, font_size=18, font=MONO, color=color).move_to(box)
+    return Group(box, text)
+
+encoder = make_box("Encoder", PRIMARY)
+decoder = make_box("Decoder", SECONDARY).next_to(encoder, RIGHT, buff=1.5)
+arrow = Arrow(encoder.get_right(), decoder.get_left(), color=DIM, stroke_width=1.5)
+
+self.play(FadeIn(encoder))
+self.wait(1)  # explain encoder
+self.play(GrowArrow(arrow))
+self.play(FadeIn(decoder))
+self.wait(1)  # explain decoder
+```
+
+### Data flow animation
+
+After building the diagram, show data moving through it:
+
+```python
+# Dot traveling along the pipeline
+data_dot = Dot(color=ACCENT, radius=0.1).move_to(encoder)
+self.play(FadeIn(data_dot))
+self.play(MoveAlongPath(data_dot, arrow), run_time=1)
+self.play(data_dot.animate.move_to(decoder), run_time=0.5)
+self.play(Flash(data_dot.get_center(), color=ACCENT), run_time=0.3)
+```
+
+## Animating results
+
+### Bar chart comparison (most common)
+
+```python
+# Before/after bars
+before_data = [45, 52, 38, 61]
+after_data = [78, 85, 72, 91]
+labels = ["Task A", "Task B", "Task C", "Task D"]
+
+before_chart = BarChart(before_data, bar_names=labels,
+    y_range=[0, 100, 20], bar_colors=[HIGHLIGHT]*4).scale(0.6).shift(LEFT*3)
+after_chart = BarChart(after_data, bar_names=labels,
+    y_range=[0, 100, 20], bar_colors=[SECONDARY]*4).scale(0.6).shift(RIGHT*3)
+
+before_label = Text("Baseline", font_size=20, color=HIGHLIGHT, font=MONO)
+after_label = Text("Ours", font_size=20, color=SECONDARY, font=MONO)
+
+# Reveal baseline first, then ours (dramatic comparison)
+self.play(Create(before_chart), FadeIn(before_label))
+self.wait(1.5)
+self.play(Create(after_chart), FadeIn(after_label))
+self.wait(0.5)
+
+# Highlight the improvement
+improvement = Text("+32.5 points (mean 49 to 81.5)", font_size=24, color=ACCENT, font=MONO)
+self.play(FadeIn(improvement))
+```
+
+### Training curve (for ML papers)
+
+```python
+tracker = ValueTracker(0)
+curve = always_redraw(lambda: axes.plot(
+    lambda x: 1 - 0.8 * np.exp(-x / 3),
+    x_range=[0, tracker.get_value()], color=PRIMARY
+))
+epoch_label = always_redraw(lambda: Text(
+    f"Epoch {int(tracker.get_value())}", font_size=18, font=MONO
+).to_corner(UR))
+
+self.add(curve, epoch_label)
+self.play(tracker.animate.set_value(10), run_time=5, rate_func=linear)
+```
+
+## Domain-specific patterns
+
+### ML papers
+- Show data flow through the model (animated pipeline)
+- Training curves with `ValueTracker`
+- Attention heatmaps as colored grids
+- Embedding space as 2D scatter (PCA/t-SNE visualization)
+- Loss landscape as 3D surface with gradient descent dot
+
+### Physics/math papers
+- Use `LinearTransformationScene` for linear algebra
+- Vector fields with `ArrowVectorField` / `StreamLines`
+- Phase spaces with `NumberPlane` + trajectories
+- Wave equations with time-parameterized plots
+
+### Systems/architecture papers
+- Pipeline diagrams built progressively
+- `ShowPassingFlash` for data flow along arrows
+- `ZoomedScene` for zooming into components
+- Before/after latency/throughput comparisons
+
+## Common mistakes
+
+1. **Trying to cover the whole paper.** A 5-minute video can explain ONE core insight well. Covering everything means explaining nothing.
+2. **Reading the abstract as narration.** Academic writing is designed for readers, not listeners. Rewrite in conversational language.
+3. **Showing notation without meaning.** Never show a symbol without first showing what it represents visually.
+4. **Skipping the motivation.** Jumping straight to "here's our method" without showing why the problem matters. The Problem section is what makes the viewer care.
+5. **Identical pacing throughout.** The hook and key insight need the most visual energy. The method section can be faster. Evidence should land with impact (pause after showing the big number).

package/built-in-skills/prismer-manim-video/references/production-quality.md

@@ -0,0 +1,190 @@
+# Production Quality Checklist
+
+Standards and checks for ensuring animation output is publication-ready.
+
+## Pre-Code Checklist
+
+Before writing any Manim code:
+
+- [ ] Narration script written with visual beats marked
+- [ ] Scene list with purpose, duration, and layout for each
+- [ ] Color palette defined with meaning assignments (`PRIMARY` = main concept, etc.)
+- [ ] `MONO = "Menlo"` set as the font constant
+- [ ] Target resolution and aspect ratio decided
+
+## Text Quality
+
+### Overlap prevention
+
+```python
+# RULE: buff >= 0.5 for edge text
+label.to_edge(DOWN, buff=0.5)     # GOOD
+label.to_edge(DOWN, buff=0.3)     # BAD — may clip
+
+# RULE: FadeOut previous before adding new at same position
+self.play(ReplacementTransform(note1, note2))  # GOOD
+self.play(Write(note2))                          # BAD — overlaps note1
+
+# RULE: Reduce font size for dense scenes
+# When > 4 text elements visible, use font_size=20 not 28
+```
+
+### Width enforcement
+
+Long text strings overflow the frame:
+
+```python
+# RULE: Set max width for any text that might be long
+text = Text("This is a potentially long description", font_size=22, font=MONO)
+if text.width > config.frame_width - 1.0:
+    text.set_width(config.frame_width - 1.0)
+```
+
+### Font consistency
+
+```python
+# RULE: Define MONO once, use everywhere
+MONO = "Menlo"
+
+# WRONG: mixing fonts
+Text("Title", font="Helvetica")
+Text("Label", font="Arial")
+Text("Code", font="Courier")
+
+# RIGHT: one font
+Text("Title", font=MONO, weight=BOLD, font_size=48)
+Text("Label", font=MONO, font_size=20)
+Text("Code", font=MONO, font_size=18)
+```
+
+## Spatial Layout
+
+### The coordinate budget
+
+The visible frame is approximately 14.2 wide × 8.0 tall (default 16:9). With mandatory margins:
+
+```
+Usable area: x ∈ [-6.5, 6.5], y ∈ [-3.5, 3.5]
+Top title zone: y ∈ [2.5, 3.5]
+Bottom note zone: y ∈ [-3.5, -2.5]
+Main content: y ∈ [-2.5, 2.5], x ∈ [-6.0, 6.0]
+```
+
+### Fill the frame
+
+Empty scenes look unfinished. If the main content is small, add context:
+- A dimmed grid/axes behind the content
+- A title/subtitle at the top
+- A source citation at the bottom
+- Decorative geometry at low opacity
+
+### Maximum simultaneous elements
+
+**Hard limit: 6 actively visible elements.** Beyond that, the viewer can't track everything. If you need more:
+- Dim old elements to opacity 0.3
+- Remove elements that have served their purpose
+- Split into two scenes
+
+## Animation Quality
+
+### Variety audit
+
+Check that no two consecutive scenes use the exact same:
+- Animation type (if Scene 3 uses Write for everything, Scene 4 should use FadeIn or Create)
+- Color emphasis (rotate through palette colors)
+- Layout (center, left-right, grid — alternate)
+- Pacing (if Scene 2 was slow and deliberate, Scene 3 can be faster)
+
+### Tempo curve
+
+A good video follows a tempo curve:
+
+```
+Slow ──→ Medium ──→ FAST (climax) ──→ Slow (conclusion)
+
+Scene 1: Slow (introduction, setup)
+Scene 2: Medium (building understanding)
+Scene 3: Medium-Fast (core content, lots of animation)
+Scene 4: FAST (montage of applications/results)
+Scene 5: Slow (conclusion, key takeaway)
+```
+
+### Transition quality
+
+Between scenes:
+- **Clean exit**: `self.play(FadeOut(Group(*self.mobjects)), run_time=0.5)`
+- **Brief pause**: `self.wait(0.3)` after fadeout, before next scene's first animation
+- **Never hard-cut**: always animate the transition
+
+## Color Quality
+
+### Dimming on dark backgrounds
+
+Colors that look vibrant on white look muddy on dark backgrounds (#0D1117, #1C1C1C). Test your palette:
+
+```python
+# Colors that work well on dark backgrounds:
+# Bright and saturated: #58C4DD, #83C167, #FFFF00, #FF6B6B
+# Colors that DON'T work: #666666 (invisible), #2244AA (too dark)
+
+# RULE: Structural elements (axes, grids) at opacity 0.15
+# Context elements at 0.3-0.4
+# Primary elements at 1.0
+```
+
+### Color meaning consistency
+
+Once a color is assigned a meaning, it keeps that meaning for the entire video:
+
+```python
+# If PRIMARY (#58C4DD) means "the model" in Scene 1,
+# it means "the model" in every scene.
+# Never reuse PRIMARY for a different concept later.
+```
+
+## Data Visualization Quality
+
+### Minimum requirements for charts
+
+- Axis labels on every axis
+- Y-axis range starts at 0 (or has a clear break indicator)
+- Bar/line colors match the legend
+- Numbers on notable data points (at least the maximum and the comparison point)
+
+### Animated counters
+
+When showing a number changing:
+```python
+# GOOD: DecimalNumber with smooth animation
+counter = DecimalNumber(0, font_size=48, num_decimal_places=0, font="Menlo")
+self.play(counter.animate.set_value(1000), run_time=3, rate_func=rush_from)
+
+# BAD: Text that jumps between values
+```
+
+## Pre-Render Checklist
+
+Before running `manim -qh`:
+
+- [ ] All scenes render without errors at `-ql`
+- [ ] Preview stills at `-qm` for text-heavy scenes (check kerning)
+- [ ] Background color set in every scene (`self.camera.background_color = BG`)
+- [ ] `add_subcaption()` or `subcaption=` on every significant animation
+- [ ] No text smaller than font_size=18
+- [ ] No text using proportional fonts (use monospace)
+- [ ] buff >= 0.5 on all `.to_edge()` calls
+- [ ] Clean exit (FadeOut all) at end of every scene
+- [ ] `self.wait()` after every reveal
+- [ ] Color constants used (no hardcoded hex strings in scene code)
+- [ ] All scenes use the same quality flag (don't mix `-ql` and `-qh`)
+
+## Post-Render Checklist
+
+After stitching the final video:
+
+- [ ] Watch the complete video at 1x speed — does it feel rushed anywhere?
+- [ ] Is there a moment where two things animate simultaneously and it's confusing?
+- [ ] Does every text label have enough time to be read?
+- [ ] Are transitions between scenes smooth (no black frames, no jarring cuts)?
+- [ ] Is the audio in sync with the visuals (if using voiceover)?
+- [ ] Is the Gibbs-like "first impression" good? The first 5 seconds determine if someone keeps watching

package/built-in-skills/prismer-manim-video/references/rendering.md

@@ -0,0 +1,187 @@
+# Rendering Reference
+
+## Prerequisites
+
+```bash
+manim --version       # Manim CE
+pdflatex --version    # LaTeX
+ffmpeg -version       # ffmpeg
+```
+
+## CLI Reference
+
+```bash
+manim -ql script.py Scene1 Scene2    # draft (480p 15fps)
+manim -qm script.py Scene1           # medium (720p 30fps)
+manim -qh script.py Scene1           # production (1080p 60fps)
+manim -ql --format=png -s script.py Scene1  # preview still (last frame)
+manim -ql --format=gif script.py Scene1     # GIF output
+```
+
+## Quality Presets
+
+| Flag | Resolution | FPS | Use case |
+|------|-----------|-----|----------|
+| `-ql` | 854x480 | 15 | Draft iteration (layout, timing) |
+| `-qm` | 1280x720 | 30 | Preview (use for text-heavy scenes) |
+| `-qh` | 1920x1080 | 60 | Production |
+
+**Text rendering quality:** `-ql` (480p15) produces noticeably poor text kerning and readability. For scenes with significant text, preview stills at `-qm` to catch issues invisible at 480p. Use `-ql` only for testing layout and animation timing.
+
+## Output Structure
+
+```
+media/videos/script/480p15/Scene1_Intro.mp4
+media/images/script/Scene1_Intro.png  (from -s flag)
+```
+
+## Stitching with ffmpeg
+
+```bash
+cat > concat.txt << 'EOF'
+file 'media/videos/script/480p15/Scene1_Intro.mp4'
+file 'media/videos/script/480p15/Scene2_Core.mp4'
+EOF
+ffmpeg -y -f concat -safe 0 -i concat.txt -c copy final.mp4
+```
+
+## Add Voiceover
+
+```bash
+# Mux narration
+ffmpeg -y -i final.mp4 -i narration.mp3 -c:v copy -c:a aac -b:a 192k -shortest final_narrated.mp4
+
+# Concat per-scene audio first
+cat > audio_concat.txt << 'EOF'
+file 'audio/scene1.mp3'
+file 'audio/scene2.mp3'
+EOF
+ffmpeg -y -f concat -safe 0 -i audio_concat.txt -c copy full_narration.mp3
+```
+
+## Add Background Music
+
+```bash
+ffmpeg -y -i final.mp4 -i music.mp3 \
+  -filter_complex "[1:a]volume=0.15[bg]" \
+  -map 0:v:0 -map '[bg]' -c:v copy -c:a aac -shortest final_with_music.mp4
+```
+
+## GIF Export
+
+The command above adds music to a silent render. For an already narrated input, first verify its audio stream with ffprobe, then mix `[0:a][bg]amix=inputs=2:duration=first[mix]` and map `[mix]`. Do not reference a nonexistent input audio stream.
+
+```bash
+ffmpeg -y -i scene.mp4 \
+  -vf "fps=15,scale=640:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" \
+  output.gif
+```
+
+## Aspect Ratios
+
+```bash
+manim -ql --resolution 1080,1920 script.py Scene  # 9:16 vertical
+manim -ql --resolution 1080,1080 script.py Scene  # 1:1 square
+```
+
+## Render Workflow
+
+1. Draft render all scenes at `-ql`
+2. Preview stills at key moments (`-s`)
+3. Fix and re-render only broken scenes
+4. Stitch with ffmpeg
+5. Review stitched output
+6. Production render at `-qh`
+7. Re-stitch + add audio
+
+## manim.cfg — Project Configuration
+
+Create `manim.cfg` in the project directory for per-project defaults:
+
+```ini
+[CLI]
+quality = low_quality
+preview = True
+media_dir = ./media
+
+[renderer]
+background_color = #0D1117
+
+[tex]
+tex_template_file = custom_template.tex
+```
+
+This eliminates repetitive CLI flags and `self.camera.background_color` in every scene.
+
+## Sections — Chapter Markers
+
+Mark sections within a scene for organized output:
+
+```python
+class LongVideo(Scene):
+    def construct(self):
+        self.next_section("Introduction")
+        # ... intro content ...
+
+        self.next_section("Main Concept")
+        # ... main content ...
+
+        self.next_section("Conclusion")
+        # ... closing ...
+```
+
+Render individual sections: `manim --save_sections script.py LongVideo`
+This outputs separate video files per section — useful for long videos where you want to re-render only one part.
+
+## manim-voiceover Plugin (Recommended for Narrated Videos)
+
+The official `manim-voiceover` plugin integrates TTS directly into scene code, auto-syncing animation duration to voiceover length. This is significantly cleaner than the manual ffmpeg muxing approach above.
+
+### Installation
+
+```bash
+pip install "manim-voiceover[elevenlabs]"
+# Or for free/local TTS:
+pip install "manim-voiceover[gtts]"    # Google TTS (free, lower quality)
+pip install "manim-voiceover[azure]"   # Azure Cognitive Services
+```
+
+### Usage
+
+```python
+from manim import *
+from manim_voiceover import VoiceoverScene
+from manim_voiceover.services.elevenlabs import ElevenLabsService
+
+class NarratedScene(VoiceoverScene):
+    def construct(self):
+        self.set_speech_service(ElevenLabsService(
+            voice_name="Alice",
+            model_id="eleven_multilingual_v2"
+        ))
+
+        # Voiceover auto-controls scene duration
+        with self.voiceover(text="Here is a circle being drawn.") as tracker:
+            self.play(Create(Circle()), run_time=tracker.duration)
+
+        with self.voiceover(text="Now let's transform it into a square.") as tracker:
+            self.play(Transform(Circle(), Square()), run_time=tracker.duration)
+```
+
+### Key Features
+
+- `tracker.duration` — total voiceover duration in seconds
+- `tracker.time_until_bookmark("mark1")` — sync specific animations to specific words
+- Auto-generates subtitle `.srt` files
+- Caches audio locally — re-renders don't re-generate TTS
+- Works with: ElevenLabs, Azure, Google TTS, pyttsx3 (offline), and custom services
+
+### Bookmarks for Precise Sync
+
+```python
+with self.voiceover(text='This is a <bookmark mark="circle"/>circle.') as tracker:
+    self.wait_until_bookmark("circle")
+    self.play(Create(Circle()), run_time=tracker.time_until_bookmark("circle", limit=1))
+```
+
+This is the recommended approach for any video with narration. The manual ffmpeg muxing workflow above is still useful for adding background music or post-production audio mixing.