Communitygithub.com

MSP — Manim-Stil & -Protokoll

Zeigt einem KI-Agenten, wie er „MSP — Manim-Stil & -Protokoll“ plant, erstellt oder zuschneidet, sodass das konkrete Ergebnis ein brauchbarer Code oder ein Skript ist. Der Ablauf folgt einer produktionsreifen Spezifikation für KI-generierte Manim-Animationen, 0. PRIME DIRECTIVE, 1. UMGEBUNG & VERSIONSLOCK. Verwende dies, wenn eine neue Aufgabe dieses Handwerk erfordert.

Was ist MSP — Manim-Stil & -Protokoll?

Diese Fähigkeit (Skill) befähigt einen KI-Agenten, professionelle, qualitativ hochwertige Manim-Animationen zu generieren, die wie aus einem professionellen Animationsstudio wirken. Sie definiert ein umfassendes Protokoll für die Erstellung von ManimCE-Animationen, das alles von der Projektstruktur und visuellen Designstandards bis hin zu Transformations-, Timing- und Kameraprotokollen abdeckt. Der Skill stellt sicher, dass Animationen sauber, organisiert und mit fließenden Übergängen sind, anstatt aus einfachen Ein- und Ausblendungen zu bestehen. Er ist für Manim Community Edition (ManimCE) ab Version 0.18 optimiert und enthält eine PRIME DIRECTIVE, die besagt, dass jede Szene wie aus einem professionellen Studio aussehen muss. Der Skill fördert die Verwendung von Projektdateien, einer zentralen `theme.py` für konsistente Farben und Schriftarten, und eines strukturierten Ansatzes für Animationen, Timing und Kameraführung, um konsistente und professionelle Ergebnisse zu erzielen.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Frqme21/MSP-Manim-Style-protocol/tree/HEAD/v1

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Was macht MSP — Manim-Stil & -Protokoll?

Eine produktionsreife Skillspezifikation für KI-generierte Manim-Animationen

Version: 1.0
Ziel: Manim Community Edition (ManimCE) ≥ v0.18
Zweck: Jedes KI-System in die Lage versetzen, standardmäßig saubere, organisierte, fließend übergehende,
         Studio-/Produktionsqualität-Manim-Animationen zu generieren – nicht als Ausnahme.

0. PRIME DIRECTIVE

Jede Szene, die du schreibst, muss aussehen, als käme sie von einem professionellen Animationsstudio, nicht von einem Studentenskript. Wenn eine Wahl mehrdeutig ist, wähle die Option, die flüssiger, sauberer und zielgerichteter ist – niemals die faulste Standardeinstellung.

Bevor du Code schreibst, gehe still diese Checkliste durch:

  1. Was ist die eine Idee, die diese Szene vermittelt?
  2. Was ist die visuelle Hierarchie (was soll das Auge zuerst, zweitens, drittens sehen)?
  3. Welche Farbpalette und welche Schriftart verwende ich, und ist sie projektweit einheitlich?
  4. Wie wird jedes Objekt eintreten, transformieren und austreten – nichts sollte einfach so „erscheinen“ oder „verschwinden“ ohne ein Animationsverb.
  5. Was ist das Tempo (Gesamtlaufzeitbudget) für die Szene?

1. UMGEBUNG & VERSIONSLOCK

Standardmäßig immer Manim Community Edition verwenden, nicht ManimGL, es sei denn, der Benutzer fordert explizit den 3b1b-ManimGL-Stil an.

from manim import *
  • CLI-Binär: manim (nicht manimgl)
  • Erstellungsverb: Create() (nicht ShowCreation())
  • Mathe-Rendering: MathTex(r"...") (nicht Tex(R"..."))

NIEMALS APIs mischen. Wenn ein Code-Snippet self.camera.frame ohne MovingCameraScene/ThreeDScene verwendet, markiere es – das ist ManimGL-Syntax, die hereinsickert.


2. PROJEKT DATEISTRUKTUR

Für alles, was über eine einzige triviale Szene hinausgeht, erzwinge diese Struktur – werfe niemals alles in eine einzige monolithische Datei:

projekt/
├── manim.cfg              # festgelegte Rendering-Konfiguration (siehe §9)
├── theme.py               # Farben, Schriftarten, Konstanten (einzige Quelle der Wahrheit)
├── helpers.py             # wiederverwendbare Mobject-Builder / Layout-Funktionen
├── scenes/
│   ├── 01_intro.py
│   ├── 02_derivation.py
│   └── 03_outro.py
└── assets/                # SVGs, Bilder, Audio

theme.py Beispiel (IMMER eines für Projekte mit mehreren Szenen erstellen):

from manim import *

# ---- PALETTE ----
BG_COLOR      = "#0E0E12"
PRIMARY       = "#58C4DD"   # Standard-Manim-Blau oder Markenfarbe
SECONDARY     = "#FFD166"
ACCENT        = "#EF476F"
TEXT_MAIN     = "#F5F5F5"
TEXT_MUTED    = "#8A8A8F"
SUCCESS       = "#06D6A0"

# ---- TYPOGRAPHIE ----
FONT_MAIN = "Helvetica"      # oder projektspezifisch
FONT_MONO = "JetBrains Mono"

# ---- ZEITKONSTANTEN ----
T_FAST   = 0.5
T_NORMAL = 1.0
T_SLOW   = 1.8
LAG      = 0.08   # Standard-Lag-Ratio für gruppierte Enthüllungen

config.background_color = BG_COLOR

Jede Szenendatei importiert aus theme.py. NIEMALS Hex-Farben oder magische run_time-Werte inline hartcodieren, sobald eine Theme-Datei existiert – das ist das #1-Merkmal von unprofessioneller, inkonsistenter Ausgabe.


3. VISUELLE DESIGNSTANDARDS

3.1 Farbregeln

  • Maximal 4–5 Farben pro Projekt (1 Hintergrund, 1–2 Primärfarben, 1–2 Akzentfarben). Mehr wirkt laut/unprofessionell.
  • Farben semantisch verwenden: dieselbe Farbe = dieselbe Bedeutung im gesamten Video (z. B. immer Blau für „gegeben“, immer Rot für „unbekannt“).
  • Der Hintergrund sollte fast nie reines Schwarz (#000000) oder reines Weiß sein – verwende ein weiches Beinahe-Schwarz (#0E0E12) oder ein weiches Off-White für reduzierte Augenbelastung und ein „Studio“-Gefühl.

3.2 Typographieregeln

  • Text() für UI-Beschriftungen, Titel, Untertitel – schnell, keine LaTeX-Abhängigkeit.
  • MathTex() für alle mathematischen Notationen – niemals Mathematik mit Text() vortäuschen.
  • Tex() nur für gemischte Prosa+Mathematik-LaTeX-Blöcke.
  • Eine font= global über Theme-Konstanten setzen; die Schriftart niemals von Szene zu Szene variieren lassen.
  • Titelkonvention: .to_edge(UP), fett, einheitliche Schriftgröße (z. B. 40pt) in jeder Szene.

3.3 Layoutregeln

  • Die Drittelregel beachten – vermeide, standardmäßig alles mittig zentrieren; verwende bewusst .to_edge(), .shift(), .next_to().
  • Einheitliche Ränder (Buff-Werte) einhalten – definiere eine Konstante MARGIN = 0.75 und verwende sie in jedem .to_edge(..., buff=MARGIN)-Aufruf wieder.
  • Zusammengehörige Objekte in einer einzigen VGroup gruppieren und die Gruppe positionieren/animieren, nicht lose einzelne Mobjects – das stellt sicher, dass die Ausrichtung bei späteren Transformationen korrekt bleibt.
  • Immer .arrange() oder .arrange_in_grid() auf Gruppen anwenden, anstatt Koordinaten manuell zu berechnen – manuelle Koordinatenberechnung ist fehleranfällig und die #1-Quelle für kaputte Layouts bei späteren Bearbeitungen.

4. DAS MORPHING- & TRANSFORMPROTOKOLL

Dies ist das Herzstück der „fließenden, übergehenden“ Animation – der unverwechselbare Look hochwertiger Erklärvideos.

4.1 Regel: Niemals Schneiden, Immer Transformieren

Wenn ein Objekt konzeptionell zu einem anderen Objekt wird (Gleichung wird umgestellt, Form wird zu einer anderen Form, Beschriftung wird aktualisiert), niemals FadeOut + FadeIn als separate, nicht zusammenhängende Mobjects verwenden – das wirkt wie ein Jump Cut. Verwende immer eine Transformationsfamilie:

SituationRichtiges Werkzeug
Gleichung wird umgestellt, Terme bleiben erhaltenTransformMatchingTex(old, new)
Form verwandelt sich in eine andere FormTransform(old, new) oder ReplacementTransform(old, new)
Gruppe von Mobjects wird umstrukturiert (z. B. Aufzählungsliste → Diagramm)TransformMatchingShapes(old_group, new_group)
Ein Objekt ersetzt explizit ein anderes im SzenengraphenReplacementTransform (tauscht alt gegen neu in self.mobjects)
Ausblenden bei gleichzeitiger Wahrung der Kontinuität (z. B. Geist/Überlagerung)FadeTransform(old, new)

Protokolldetail für TransformMatchingTex: Beide MathTex-Mobjects immer mit konsistenter Untergruppierung von Zeichenfolgen erstellen (dieselben LaTeX-Fragmente als separate {}-Gruppen), damit Manim identische Symbole abgleichen kann – das ist es, was Terme optisch an ihre neue Position „gleiten“ lässt, anstatt überzublenden.

eq1 = MathTex("a", "+", "b", "=", "c")
eq2 = MathTex("c", "=", "a", "+", "b")
self.play(TransformMatchingTex(eq1, eq2), run_time=1.2)

4.2 Regel: Verwende .animate für Einfache Eigenschaftsmorphs

Für einzelne kontinuierliche Eigenschaftsänderungen (Position, Skalierung, Farbe, Rotation) an einem Mobject bevorzuge die .animate-Syntax – sie ist sauberer und Manim interpoliert die Netto-Transformation automatisch:

self.play(square.animate.shift(RIGHT * 2).scale(1.5).set_color(ACCENT), run_time=1.0)

Einschränkung (kritisch, vermeide KI-Halluzinationsfehler): Verkettete .animate-Aufrufe interpolieren den endgültigen Nettozustand, nicht jeden Zwischenschritt nacheinander. Verkette niemals .animate-Aufrufe, die von einem Zwischenergebnis abhängen (z. B. .animate.move_to(X).rotate(winkel_abhängig_von_position)) – stattdessen in separate self.play()-Aufrufe aufteilen.

4.3 Regel: Verwende Updater für Kontinuierliche/Abhängige Bewegung

Wann immer der Zustand eines Objekts kontinuierlich einem anderen Objekt folgen muss (eine Beschriftung, die einem Punkt folgt, eine Wertanzeige, die einem ValueTracker folgt), verwende add_updater, niemals manuell play pro Frame erneut:

tracker = ValueTracker(0)
label = DecimalNumber(0).add_updater(lambda d: d.set_value(tracker.get_value()))
dot = Dot().add_updater(lambda m: m.move_to(axes.c2p(tracker.get_value(), f(tracker.get_value()))))
self.add(label, dot)
self.play(tracker.animate.set_value(5), run_time=3, rate_func=linear)

Immer remove_updater (oder always_redraw für sauberere Neuberechnungslogik von Grund auf) verwenden, sobald die Abhängigkeitsphase eines Objekts endet, um veraltete Updater-Fehler später in langen Szenen zu vermeiden.


5. ZEITSTEUERUNGS-, TEMPO- & EASING-PROTOKOLL

5.1 Standard-Rate-Function-Politik

  • Standard (nicht überschreiben): smooth – S-Kurven-Ease-In/Ease-Out. Verwende für 90 % der Animationen – Gleichungsenthüllungen, Formerstellung, Standardbewegungen.
  • linear: zwingend für alles, was buchstäbliche gleichmäßige physikalische Bewegung darstellt – umlaufende Punkte, gleichförmige Geschwindigkeitsvektoren, rotierende Uhrzeiger, Fortschrittsbalken, die an die reale verstrichene Zeit gebunden sind.
  • rush_into / rush_from: für betonte Ein-/Ausgänge verwenden, wenn etwas wie ein Einrasten oder Wegfliegen wirken soll.
  • there_and_back / there_and_back_with_pause: für Indicate-artige Aufmerksamkeitsimpulse verwenden, niemals für dauerhafte Zustandsänderungen.
  • ease_out_bounce / ease_out_elastic: nur für verspielte, informelle Inhalte reservieren; niemals in einer formellen Mathe-/Wissenschaftsherleitung, wo es unprofessionell wirkt.

5.2 Timing-Budget-Regeln

  • run_time einzelner Animationen zwischen 0,4 s und 3 s halten. Unter 0,4 s wirkt es ruckartig; über 3 s (ohne narrativen Grund) zieht es sich.
  • Ein-/Ausgänge von Titeln/Sektionsköpfen: 0,8–1,2 s.
  • Gleichungs-/Diagrammtransformationen: 1,0–1,5 s.
  • Betonungsimpulse (Indicate, Flash, Circumscribe): 0,5–0,8 s.
  • Kamerabewegungen (move_camera, self.camera.frame.animate): 1,5–3 s – schnellere Kamerabewegungen wirken unangenehm.
  • Nach jeder größeren Enthüllung bewusste self.wait(0,3–1,0)-Atempausen einfügen – niemals self.play()-Aufrufe ohne Pause hintereinander ketten; das überfordert den Betrachter.

5.3 Kompositionsprotokoll

  • Gleichzeitige, aber unabhängige Ereignisse → einzelner self.play(AnimA, AnimB, ...)-Aufruf.
  • Gleichzeitig mit gestaffeltem Start (z. B. 6 Aufzählungspunkte, die nacheinander, aber überlappend erscheinen) → LaggedStart(*anims, lag_ratio=0.15).
  • Streng sequentielle, abhängige Ereignisse → Succession(*anims) oder separate self.play()-Aufrufe.
  • List-/Grid-Enthüllungen (Aufzählungen, Formengitter) → immer LaggedStartMap(FadeIn, group, lag_ratio=0.08, shift=UP*0.3) anstelle eines einzelnen gleichzeitigen FadeIn(group) – Staffelung ist es, was Gruppeneingänge organisch statt roboterhaft wirken lässt.

6. SZENEN- & CODE-ORGANISATIONSPROTOKOLL

6.1 Methodenform von Konstrukt

construct() immer in klar abgegrenzte, benannte Phasen mittels Kommentaren oder Hilfsmethoden zerlegen – niemals einen einzigen 100-zeiligen Block ohne Unterbrechung:

class DerivationScene(Scene):
    def construct(self):
        self.setup_title()
        self.show_initial_equation()
        self.derive_steps()
        self.highlight_result()
        self.cleanup()

    def setup_title(self):
        self.title = Text("Herleitung der quadratischen Formel", font=FONT_MAIN).to_edge(UP)
        self.play(Write(self.title), run_time=T_NORMAL)
        self.wait(T_FAST)

    def show_initial_equation(self):
        ...

Für lange Videos in mehrere Szenenklassen aufteilen (eine pro logischem Abschnitt), anstatt eine einzige riesige construct()-Methode – ermöglicht gezieltes Neurendern mittels -n und parallele Iteration.

6.2 Mobject-Konstruktionsprotokoll

  • Komplexe benutzerdefinierte Grafiken (Diagramme, Graphen, Symbole) als eigenständige Funktionen in helpers.py erstellen, die ein VGroup zurückgeben, nicht inline in construct():
# helpers.py
def make_neuron(radius=0.3, color=PRIMARY) -> VGroup:
    circle = Circle(radius=radius, color=color, fill_opacity=0.8)
    label = Text("n", font_size=20).move_to(circle)
    return VGroup(circle, label)
  • Mobjects immer sinnvoll benennen (title, eq_initial, graph_group) – niemals unbenannte anonyme Literale hinterlassen, die später mutiert oder transformiert werden müssen.
  • z_index explizit für jede Szene mit überlappenden Ebenen verwenden (sich nicht allein auf die Hinzufügungsreihenfolge verlassen, sobald mehr als 2 Ebenen vorhanden sind).

6.3 Stil-/Linting-Regeln

  • snake_case für Variablen/Methoden, PascalCase für Scene-Unterklassen.
  • Eine Leerzeile zwischen Animations-„Schlägen“ im Code für Lesbarkeit – die Codestruktur sollte visuell das Tempo des Videos widerspiegeln.
  • Keine nackten magischen Zahlen für Farbe/Position/Timing – immer auf theme.py-Konstanten verweisen.
  • Helferfunktionen typisieren (def make_axes() -> Axes:) für Wartbarkeit bei größeren Projekten.

7. KOMPOSITIONS- & KAMERAPROTOKOLL (2D & 3D)

2D

  • MovingCameraScene immer dann verwenden, wenn das Video in 2D schwenken/zoomen muss (z. B. Fokussieren auf einen Unterbereich eines Diagramms) – animieren via self.camera.frame.animate.move_to(...).set(width=...), immer mit einer expliziten run_time.

3D

  • ThreeDScene unterklassifizieren.
  • Anfangsposition mit self.set_camera_orientation(phi=70*DEGREES, theta=-45*DEGREES, zoom=1) in einem dedizierten Setup-Schritt setzen – niemals die Standardposition belassen, es sei denn, es ist beabsichtigt.
  • Für jede Kameraneupositionierung, die der Betrachter als Bewegung wahrnehmen soll, self.move_camera(phi=..., theta=..., run_time=2.5) verwenden – niemals einen Jump-Cut mittels set_camera_orientation mitten in der Szene durchführen.
  • self.begin_ambient_camera_rotation(rate=0.15) für langsame Leerlaufdrehung unter Erzählung verwenden; immer mit self.stop_ambient_camera_rotation() paaren, bevor eine nachfolgende absichtliche move_camera erfolgt.
  • HUD/Beschriftungen/Titel, die unabhängig vom Kamerawinkel lesbar bleiben müssen → self.add_fixed_in_frame_mobjects(label).
  • Beschriftungen, die 3D-Objekten folgen, aber lesbar bleiben sollen → self.add_fixed_orientation_mobjects(label).
  • Auflösungs-Tupel von 3D-Oberflächen während der Iteration niedrig halten (z. B. (24,24)); nur für das endgültige Produktionsrendering erhöhen – dies ist eine reine Leistungs-/Workflow-Regel, keine visuelle.

8. BETONUNGS- & AUFMERKSAMKEITSPROTOKOLL

Lass ein wichtiges Ergebnis niemals visuell identisch mit unterstützendem Inhalt dasitzen. Wende nach der Enthüllung des „Höhepunkts“ einer Szene (endgültige Gleichung, Schlüsseleinblick, Ergebnis) genau eine Betonungstechnik an – nicht mehr als eine stapeln, sonst wirkt es hektisch:

  • Circumscribe(mobject, color=ACCENT, run_time=1.2) – zeichnet eine Form darum herum.
  • Indicate(mobject, scale_factor=1.15) – kurzer Puls-Skalierung + Farbblitz.
  • Flash(point, color=ACCENT) – radialer Ausbruch, gut für einen bestimmten Koordinaten-/Schnittpunkt.
  • mobject.animate.set_color(ACCENT) kombiniert mit einer leichten Skalierung – für dauerhafte Neufärbung, die signalisiert: „Das ist die Antwort.“

9. RENDER- & EXPORTPROTOKOLL

9.1 Festgelegte Konfigurationsdatei (diese committen – sich für die endgültige Auslieferung niemals auf Ad-hoc-Flags verlassen)

manim.cfg:

[CLI]
quality = production_quality
preview = False
background_color = "#0E0E12"
output_file = {scene_name}
frame_rate = 60
pixel_height = 1080
pixel_width = 1920

9.2 Workflow-Stufen (immer diese Reihenfolge einhalten, niemals zuerst in endgültiger Qualität rendern)

  1. Entwurfsdurchlauf: manim -pql scenes/02_derivation.py DerivationScene – schnelle Iteration, Logik/Timing prüfen.
  2. Stichprobendurchlauf: manim -pqh -s scenes/02_derivation.py DerivationScene – Einzelframe-Überprüfung in hoher Qualität von Komposition/Farbe.

…

[gekürzt für Übersetzung]

Verwandte Skills