Communitygithub.com

MSP — Estilo y Protocolo Manim

Guía a un agente de IA para planificar, construir o editar animaciones Manim de calidad profesional, siguiendo un protocolo estricto de estilo, transformación y organización del proyecto.

¿Qué es MSP — Estilo y Protocolo Manim?

Este skill define un protocolo completo y riguroso para que sistemas de IA generen animaciones Manim de calidad profesional (estilo estudio de producción) usando Manim Community Edition (ManimCE) v0.18 o superior. Está diseñado para agentes como Claude Code, Cursor o Codex que necesitan producir scripts de animación limpios, organizados y visualmente fluidos. El skill cubre desde la estructura del proyecto (con temas, helpers y escenas separadas), normas de diseño visual (paleta de colores, tipografía, layout), protocolos de transformación y morphing (como TransformMatchingTex, ReplacementTransform, animate), hasta reglas de temporización, cámara 2D/3D, énfasis y exportación. Su objetivo principal es evitar que la IA genere código amateur, aplicando por defecto las mejores prácticas: colores semánticos, animaciones fluidas con transformaciones en lugar de cortes abruptos, organización modular del código, y uso consistente de constantes. Es especialmente útil para proyectos educativos, videos explicativos de matemáticas/ciencias, o cualquier demostración animada que requiera un alto estándar visual y mantenibilidad.

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

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

¿Qué hace MSP — Estilo y Protocolo Manim?

Especificación de habilidad de grado profesional para animaciones Manim generadas por IA

Versión: 1.0
Objetivo: Manim Community Edition (ManimCE) ≥ v0.18
Propósito: Permitir que cualquier sistema de IA genere animaciones Manim limpias, organizadas, con morphing suave y calidad de estudio/producción por defecto, no como excepción.

0. DIRECTIVA PRINCIPAL

Cada escena que escribas debe parecer de un estudio de animación profesional, no de un script de estudiante. Si una elección es ambigua, elige la opción más suave, limpia e intencionada — nunca el valor predeterminado más perezoso.

Antes de escribir cualquier código, repasa mentalmente esta lista:

  1. ¿Cuál es la única idea que comunica esta escena?
  2. ¿Cuál es la jerarquía visual (¿qué debe ver el ojo primero, segundo, tercero)?
  3. ¿Qué paleta de colores y fuente estoy usando, y es consistente en todo el proyecto?
  4. ¿Cómo entrará, se transformará y saldrá cada objeto? — nada debe simplemente "aparecer" o "desaparecer" sin un verbo de animación.
  5. ¿Cuál es el ritmo (presupuesto de tiempo de ejecución total) para la escena?

1. ENTORNO Y BLOQUEO DE VERSIÓN

Siempre usa por defecto Manim Community Edition, no ManimGL, a menos que el usuario solicite explícitamente ManimGL al estilo 3b1b.

from manim import *
  • CLI binario: manim (no manimgl)
  • Verbo de creación: Create() (no ShowCreation())
  • Renderizado matemático: MathTex(r"...") (no Tex(R"..."))

Nunca mezcles APIs. Si un fragmento usa self.camera.frame sin MovingCameraScene/ThreeDScene, márcalo — eso es sintaxis de ManimGL filtrándose.


2. ESTRUCTURA DE ARCHIVOS DEL PROYECTO

Para cualquier cosa más allá de una escena trivial única, impón esta estructura — nunca vuelques todo en un solo archivo monolítico:

project/
├── manim.cfg              # configuración de renderizado bloqueada (ver §9)
├── theme.py               # colores, fuentes, constantes (fuente única de verdad)
├── helpers.py             # constructores de mobjects reutilizables / funciones de diseño
├── scenes/
│   ├── 01_intro.py
│   ├── 02_derivation.py
│   └── 03_outro.py
└── assets/                # svgs, imágenes, audio

Ejemplo de theme.py (CREA UNO SIEMPRE para proyectos de múltiples escenas):

from manim import *

# ---- PALETA ----
BG_COLOR      = "#0E0E12"
PRIMARY       = "#58C4DD"   # azul predeterminado de manim, o color de marca
SECONDARY     = "#FFD166"
ACCENT        = "#EF476F"
TEXT_MAIN     = "#F5F5F5"
TEXT_MUTED    = "#8A8A8F"
SUCCESS       = "#06D6A0"

# ---- TIPOGRAFÍA ----
FONT_MAIN = "Helvetica"      # o específica del proyecto
FONT_MONO = "JetBrains Mono"

# ---- CONSTANTES DE TEMPORIZACIÓN ----
T_FAST   = 0.5
T_NORMAL = 1.0
T_SLOW   = 1.8
LAG      = 0.08   # lag_ratio predeterminado para revelaciones en grupo

config.background_color = BG_COLOR

Cada archivo de escena importa de theme.py. Nunca codifiques colores hexadecimales ni números mágicos de run_time en línea una vez que exista un archivo de tema — este es el marcador #1 de resultados poco profesionales e inconsistentes.


3. ESTÁNDARES DE DISEÑO VISUAL

3.1 Reglas de color

  • Máximo 4–5 colores por proyecto (1 fondo, 1–2 primarios, 1–2 acento). Más se lee como ruidoso/amateur.
  • Usa el color de forma semántica: mismo color = mismo significado en todo el video (p. ej., siempre azul para "dado", siempre rojo para "desconocido").
  • El fondo casi nunca debe ser negro puro (#000000) o blanco puro — usa un casi negro suave (#0E0E12) o un casi blanco suave para reducir la fatiga visual y tener una sensación de "estudio".

3.2 Reglas tipográficas

  • Text() para etiquetas de UI, títulos, subtítulos — rápido, sin dependencia de LaTeX.
  • MathTex() para toda notación matemática — nunca finjas matemáticas con Text().
  • Tex() solo para bloques de LaTeX mixtos de prosa + matemáticas.
  • Establece una fuente globalmente mediante constantes de tema; nunca dejes que la elección de fuente varíe de escena a escena.
  • Convención de títulos: .to_edge(UP), peso negrita, tamaño de fuente consistente (p. ej., 40pt) en cada escena.

3.3 Reglas de diseño

  • Respeta la regla de los tercios — evita centrar todo por defecto; usa .to_edge(), .shift(), .next_to() deliberadamente.
  • Mantén márgenes consistentes (valores buff) — define una constante MARGIN = 0.75 y reutilízala en cada llamada .to_edge(..., buff=MARGIN).
  • Agrupa objetos relacionados en un solo VGroup y posiciona/anima el grupo, no mobjects sueltos individuales — esto garantiza que la alineación se mantenga correcta a través de cualquier transformación posterior.
  • Siempre llama a .arrange() o .arrange_in_grid() en grupos en lugar de calcular coordenadas manualmente — las coordenadas manuales son frágiles y son la fuente #1 de diseños rotos bajo ediciones posteriores.

4. EL PROTOCOLO DE MORPHING Y TRANSFORMACIÓN

Este es el corazón de la animación "suave y con morphing" — el aspecto característico de los videos explicativos de alta calidad.

4.1 Regla: Nunca cortes, siempre transforma

Si un objeto se convierte conceptualmente en otro objeto (una ecuación se reorganiza, una forma se convierte en otra forma, una etiqueta se actualiza), nunca uses FadeOut + FadeIn como mobjects separados no relacionados — esto se lee como un corte abrupto. Siempre usa una familia de transformación:

SituaciónHerramienta correcta
La ecuación se reorganiza, los términos persistenTransformMatchingTex(old, new)
La forma se transforma en una forma diferenteTransform(old, new) o ReplacementTransform(old, new)
Grupo de mobjects se reestructura (p. ej., lista de viñetas → diagrama)TransformMatchingShapes(old_group, new_group)
Un objeto reemplaza explícitamente a otro en el gráfico de la escenaReplacementTransform (intercambia old por new en self.mobjects)
Fundido mientras se implica continuidad (p. ej., fantasma/superposición)FadeTransform(old, new)

Detalle del protocolo para TransformMatchingTex: siempre construye ambos mobjects MathTex con agrupación de subcadenas consistente (mismos fragmentos de LaTeX como grupos {} separados) para que Manim pueda hacer coincidir símbolos idénticos — esto es lo que hace que los términos se "deslicen" visualmente a su nueva posición en lugar de hacer un fundido cruzado.

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

4.2 Regla: Usa .animate para transformaciones simples de propiedades

Para cambios continuos de una sola propiedad (posición, escala, color, rotación) en un mobject, prefiere la sintaxis .animate — es más limpia y Manim interpola automáticamente la transformación neta:

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

Advertencia (crítica, evita errores de alucinación de IA): las llamadas .animate encadenadas interpolan el estado neto final, no cada paso intermedio secuencialmente. Nunca encadenes llamadas .animate que dependan de un resultado intermedio (p. ej., .animate.move_to(X).rotate(angle_depending_on_position)) — divídelas en llamadas self.play() separadas en su lugar.

4.3 Regla: Usa actualizadores para movimiento continuo/dependiente

Siempre que el estado de un objeto deba rastrear continuamente a otro objeto (una etiqueta que sigue a un punto, una pantalla de valor que rastrea un ValueTracker), usa add_updater, nunca vuelvas a play manualmente cada fotograma:

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)

Siempre llama a remove_updater (o usa always_redraw para una lógica de recálculo desde cero más limpia) una vez que termine la fase de dependencia de un objeto, para evitar errores de actualizadores obsoletos más adelante en escenas largas.


5. PROTOCOLO DE TEMPORIZACIÓN, RITMO Y SUAVIZACIÓN

5.1 Política de función de tasa predeterminada

  • Predeterminado (no anular): smooth — curva S de entrada/salida suave. Úsalo para el 90% de las animaciones — revelaciones de ecuaciones, creación de formas, movimientos estándar.
  • linear: obligatorio para cualquier cosa que represente movimiento físico literal a tasa constante — puntos en órbita, vectores de velocidad uniforme, manecillas de reloj girando, barras de progreso vinculadas al tiempo real transcurrido.
  • rush_into / rush_from: úsalo para entradas/salidas de énfasis donde algo debe sentirse como si se encajara en su lugar o se lanzara.
  • there_and_back / there_and_back_with_pause: úsalo para pulsos de atención al estilo Indicate, nunca para cambios de estado permanentes.
  • ease_out_bounce / ease_out_elastic: resérvalo para contenido lúdico e informal solamente — nunca en una derivación formal de matemáticas/ciencias, donde se ve poco profesional.

5.2 Reglas de presupuesto de temporización

  • Mantén el run_time individual entre 0,4 s y 3 s. Por debajo de 0,4 s se lee como brusco; por encima de 3 s (sin razón narrativa) se alarga.
  • Entradas de títulos/encabezados de sección: 0,8–1,2 s.
  • Transformaciones de ecuaciones/diagramas: 1,0–1,5 s.
  • Pulsos de énfasis (Indicate, Flash, Circumscribe): 0,5–0,8 s.
  • Movimientos de cámara (move_camera, self.camera.frame.animate): 1,5–3 s — los movimientos de cámara más rápidos que esto resultan nauseabundos.
  • Inserta pausas deliberadas self.wait(0,3–1,0) después de cada revelación importante — nunca encadenes llamadas self.play() una detrás de otra sin pausa; abruma al espectador.

5.3 Protocolo de composición

  • Eventos simultáneos pero independientes → una sola llamada self.play(AnimA, AnimB, ...).
  • Simultáneos con inicio escalonado (p. ej., 6 viñetas que aparecen en secuencia pero superpuestas) → LaggedStart(*anims, lag_ratio=0.15).
  • Eventos estrictamente secuenciales y dependientes → Succession(*anims) o llamadas self.play() separadas.
  • Revelaciones de listas/cuadrículas (viñetas, cuadrículas de formas) → siempre LaggedStartMap(FadeIn, group, lag_ratio=0.08, shift=UP*0.3) en lugar de un solo FadeIn(group) simultáneo — escalonar es lo que hace que las entradas de grupo se sientan orgánicas en lugar de robóticas.

6. PROTOCOLO DE ORGANIZACIÓN DE ESCENA Y CÓDIGO

6.1 Forma del método construct

Siempre descompón construct() en fases claramente delimitadas y con nombre mediante comentarios o métodos auxiliares — nunca un bloque ininterrumpido de 100 líneas:

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("Derivando la fórmula cuadrática", font=FONT_MAIN).to_edge(UP)
        self.play(Write(self.title), run_time=T_NORMAL)
        self.wait(T_FAST)

    def show_initial_equation(self):
        ...

Para videos largos, divide en múltiples clases de escena (una por sección lógica) en lugar de un construct() gigante — permite renderizado dirigido mediante -n e iteración paralela.

6.2 Protocolo de construcción de mobjects

  • Construye imágenes personalizadas complejas (diagramas, gráficos, iconos) como funciones independientes en helpers.py que devuelven un VGroup, no en línea en 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)
  • Siempre nombra los mobjects de manera significativa (title, eq_initial, graph_group) — nunca dejes literales anónimos sin referencia que necesites mutar o transformar más tarde.
  • Usa z_index explícitamente para cualquier escena con capas superpuestas (no confíes solo en el orden de agregado una vez que existan más de 2 capas).

6.3 Reglas de estilo / linting

  • snake_case para variables/métodos, PascalCase para subclases de Scene.
  • Una línea en blanco entre "golpes" de animación en el código para legibilidad — la estructura del código debe reflejar visualmente el ritmo del video.
  • Sin números mágicos desnudos para color/posición/temporización — siempre referencia las constantes de theme.py.
  • Escribe sugerencias de tipo para funciones auxiliares (def hacer_ejes() -> Axes:) para mantenibilidad en proyectos más grandes.

7. PROTOCOLO DE COMPOSICIÓN Y CÁMARA (2D Y 3D)

2D

  • Usa MovingCameraScene cada vez que el video necesite paneo/zoom en 2D (p. ej., enfocándose en una subregión de un diagrama) — anima mediante self.camera.frame.animate.move_to(...).set(width=...), siempre con un run_time explícito.

3D

  • Subclasea ThreeDScene.
  • Establece la orientación inicial con self.set_camera_orientation(phi=70*DEGREES, theta=-45*DEGREES, zoom=1) en un paso de configuración dedicado — nunca dejes la orientación predeterminada a menos que sea intencional.
  • Para cualquier reposicionamiento de cámara que el espectador deba percibir como movimiento, usa self.move_camera(phi=..., theta=..., run_time=2.5) — nunca hagas un corte abrupto mediante set_camera_orientation a mitad de la escena.
  • Usa self.begin_ambient_camera_rotation(rate=0.15) para rotación lenta e inactiva bajo narración; siempre combínalo con self.stop_ambient_camera_rotation() antes de cualquier move_camera deliberado posterior.
  • HUD/etiquetas/títulos que deben permanecer legibles independientemente del ángulo de la cámara → self.add_fixed_in_frame_mobjects(label).
  • Etiquetas que deben rastrear objetos 3D pero permanecer legibles → self.add_fixed_orientation_mobjects(label).
  • Mantén las tuplas de resolution de superficies 3D bajas (p. ej., (24,24)) durante la iteración; auméntalas solo para el renderizado de producción final — esto es puramente una regla de rendimiento/flujo de trabajo, no visual.

8. PROTOCOLO DE ÉNFASIS Y ATENCIÓN

Nunca dejes que un resultado clave se vea visualmente idéntico al contenido de apoyo. Después de revelar la "recompensa" de una escena (ecuación final, idea clave, resultado), aplica exactamente una técnica de énfasis — no apiles más de una o se lee como frenético:

  • Circumscribe(mobject, color=ACCENT, run_time=1.2) — dibuja una forma a su alrededor.
  • Indicate(mobject, scale_factor=1.15) — pulso breve de escala + destello de color.
  • Flash(point, color=ACCENT) — ráfaga radial, bueno para un punto/coordenada de intersección específico.
  • mobject.animate.set_color(ACCENT) combinado con una ligera escala — para recoloración permanente que señala "esta es la respuesta."

9. PROTOCOLO DE RENDERIZADO Y EXPORTACIÓN

9.1 Archivo de configuración bloqueado (compromételo — nunca confíes en banderas ad hoc para la entrega final)

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 Etapas del flujo de trabajo (sigue siempre este orden, nunca renderices calidad final primero)

  1. Pase de borrador: manim -pql scenes/02_derivation.py DerivationScene — iteración rápida, verifica lógica/temporización.
  2. Pase de verificación puntual: manim -pqh -s scenes/02_derivation.py DerivationScene — verificación de alta calidad de un solo fotograma de composición/color. ...

Skills relacionados