Communitygithub.com

MSP — Manim Style & Protocol

Mostra a um agente como planejar, construir ou editar animações Manim para que a saída concreta seja um roteiro utilizável ou um script. O procedimento percorre uma Especificação de Habilidade de Nível de Produção para Animações Manim Geradas por IA, 0. DIRETIVA PRINCIPAL, 1. AMBIENTE & VERSÃO. Use quando uma nova tarefa exigir essa habilidade.

O que é MSP — Manim Style & Protocol?

Esta habilidade fornece um protocolo abrangente e de nível profissional para que sistemas de IA (como Claude Code, Cursor ou Codex) gerem animações Manim suaves, limpas e organizadas, utilizando a Manim Community Edition (ManimCE) ≥ v0.18. Ela estabelece regras rigorosas para design visual, morfismo de transformação, temporização, composição e estrutura de projeto, garantindo que o resultado pareça de um estúdio profissional e não de um script de estudante. A especificação cobre desde o ambiente e dependências, passando por paletas de cores consistentes e tipografia, até protocolos detalhados para transformações (como `TransformMatchingTex` e `Transform`), preferências de animação (`.animate` e `updaters`), e manipulação da câmera em 2D e 3D. Ao seguir esta diretriz, o agente evita os erros comuns de iniciantes, como animações abruptas, temporização inconsistente, mistura de APIs e layout não profissional, resultando em animações de alta qualidade e com um ritmo profissional.

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

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

O que MSP — Manim Style & Protocol faz?

Uma Especificação de Habilidade de Nível de Produção para Animações Manim Geradas por IA

Versão: 1.0
Alvo: Manim Community Edition (ManimCE) ≥ v0.18
Propósito: Permitir que qualquer sistema de IA gere animações Manim limpas, organizadas, com morfismo suave e qualidade de estúdio/produção por padrão — não como exceção.

0. DIRETIVA PRINCIPAL

Cada cena que você escrever deve parecer que veio de um estúdio de animação profissional, não de um script de estudante. Se uma escolha for ambígua, escolha a opção que é mais suave, mais limpa e mais intencional — nunca a opção padrão mais preguiçosa.

Antes de escrever qualquer código, percorra silenciosamente esta lista de verificação:

  1. Qual é a única ideia que esta cena comunica?
  2. Qual é a hierarquia visual (o que o olho deve ver primeiro, segundo, terceiro)?
  3. Qual paleta de cores e fonte estou usando, e ela é consistente em todo o projeto?
  4. Como cada objeto vai entrar, se transformar e sair — nada deve simplesmente "aparecer" ou "desaparecer" sem um verbo de animação.
  5. Qual é o ritmo (orçamento total de run_time) para a cena?

1. AMBIENTE & VERSÃO

Sempre use como padrão a Manim Community Edition, não a ManimGL, a menos que o usuário solicite explicitamente a ManimGL estilo 3b1b.

from manim import *
  • Binário CLI: manim (não manimgl)
  • Verbo de criação: Create() (não ShowCreation())
  • Renderização matemática: MathTex(r"...") (não Tex(R"..."))

Nunca misture APIs. Se um trecho usar self.camera.frame sem MovingCameraScene/ThreeDScene, sinalize-o — isso é sintaxe ManimGL vazando.


2. ESTRUTURA DE ARQUIVOS DO PROJETO

Para qualquer coisa além de uma única cena trivial, imponha esta estrutura — nunca despeje tudo em um único arquivo monolítico:

projeto/
├── manim.cfg              # configuração de renderização fixa (veja §9)
├── tema.py                # cores, fontes, constantes (fonte única da verdade)
├── helpers.py             # construtores de mobjects reutilizáveis / funções de layout
├── cenas/
│   ├── 01_intro.py
│   ├── 02_derivacao.py
│   └── 03_outro.py
└── assets/                # svgs, imagens, áudio

Exemplo de tema.py (SEMPRE crie um para projetos com várias cenas):

from manim import *

# ---- PALETA ----
COR_FUNDO      = "#0E0E12"
PRIMARIA       = "#58C4DD"   # azul padrão do manim, ou cor da marca
SECUNDARIA     = "#FFD166"
DESTAQUE       = "#EF476F"
TEXTO_PRINCIPAL = "#F5F5F5"
TEXTO_SUAVE    = "#8A8A8F"
SUCESSO        = "#06D6A0"

# ---- TIPOGRAFIA ----
FONTE_PRINCIPAL = "Helvetica"      # ou específica do projeto
FONTE_MONO = "JetBrains Mono"

# ---- CONSTANTES DE TEMPO ----
T_RAPIDO   = 0.5
T_NORMAL = 1.0
T_LENTO   = 1.8
LAG      = 0.08   # lag_ratio padrão para revelações em grupo

config.background_color = COR_FUNDO

Cada arquivo de cena importa de tema.py. Nunca codifique cores hexadecimais ou números mágicos de run_time diretamente depois que um arquivo de tema existir — esta é a marca nº 1 de saída não profissional e inconsistente.


3. PADRÕES DE DESIGN VISUAL

3.1 Regras de Cor

  • Máximo de 4-5 cores por projeto (1 fundo, 1-2 primárias, 1-2 de destaque). Mais parece ruidoso/amador.
  • Use a cor semanticamente: mesma cor = mesmo significado em todo o vídeo (ex., sempre azul para "dado", sempre vermelho para "desconhecido").
  • O fundo quase nunca deve ser preto puro (#000000) ou branco puro — use um preto suave próximo (#0E0E12) ou um branco suave para reduzir o cansaço visual e dar uma sensação de "estúdio".

3.2 Regras de Tipografia

  • Use Text() para rótulos de UI, títulos, legendas — rápido, sem dependência de LaTeX.
  • Use MathTex() para toda notação matemática — nunca finja matemática com Text().
  • Use Tex() apenas para blocos LaTeX de prosa+matemática misturados.
  • Defina uma font= globalmente através das constantes do tema; nunca deixe a escolha da fonte variar de cena para cena.
  • Convenção de título: .to_edge(UP), peso negrito, tamanho de fonte consistente (ex., 40pt) em todas as cenas.

3.3 Regras de Layout

  • Respeite a regra dos terços — evite centralizar tudo por padrão; use .to_edge(), .shift(), .next_to() deliberadamente.
  • Mantenha margens consistentes (valores de buff) — defina uma constante MARGEM = 0.75 e reutilize-a em cada chamada .to_edge(..., buff=MARGEM).
  • Agrupe objetos relacionados em um único VGroup e posicione/anime o grupo, não mobjects individuais soltos — isso garante que o alinhamento permaneça correto através de qualquer transformação posterior.
  • Sempre chame .arrange() ou .arrange_in_grid() em grupos em vez de calcular coordenadas manualmente — coordenadas manuais são frágeis e a fonte nº 1 de layouts quebrados sob edições posteriores.

4. O PROTOCOLO DE MORFISMO & TRANSFORMAÇÃO

Este é o coração da animação "suave e com morfismo" — a aparência característica de vídeos explicativos de alta qualidade.

4.1 Regra: Nunca Corte, Sempre Transforme

Se um objeto conceitualmente se torna outro objeto (equação se reorganiza, forma se transforma em outra forma, rótulo é atualizado), nunca use FadeOut + FadeIn como mobjects separados e não relacionados — isso parece um corte brusco. Sempre use uma família de transformação:

SituaçãoFerramenta correta
Equação se reorganiza, termos persistemTransformMatchingTex(antigo, novo)
Forma se transforma em forma diferenteTransform(antigo, novo) ou ReplacementTransform(antigo, novo)
Grupo de mobjects se reestrutura (ex., lista de tópicos → diagrama)TransformMatchingShapes(grupo_antigo, grupo_novo)
Um objeto substitui explicitamente outro no grafo da cenaReplacementTransform (troca antigo por novo em self.mobjects)
Desvanecimento implicando continuidade (ex., fantasma/sobreposição)FadeTransform(antigo, novo)

Detalhe do protocolo para TransformMatchingTex: sempre construa ambos os mobjects MathTex com agrupamento de substrings consistente (os mesmos fragmentos LaTeX como grupos {} separados) para que o Manim possa combinar símbolos idênticos — isso é o que faz os termos "deslizarem" visualmente para sua nova posição em vez de fazer uma transição cruzada.

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

4.2 Regra: Use .animate para Morfismos de Propriedade Simples

Para mudanças contínuas de propriedade única (posição, escala, cor, rotação) em um mobject, prefira a sintaxe .animate — é mais limpa e o Manim interpola a transformação líquida automaticamente:

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

Ressalva (crítica, evite bugs de alucinação de IA): chamadas .animate encadeadas interpolam o estado líquido final, não cada etapa intermediária sequencialmente. Nunca encadeie chamadas .animate que dependem de um resultado intermediário (ex., .animate.move_to(X).rotate(angulo_dependendo_da_posição)) — divida em chamadas self.play() separadas.

4.3 Regra: Use Updaters para Movimento Contínuo/Dependente

Sempre que o estado de um objeto deve rastrear continuamente outro objeto (um rótulo seguindo um ponto, uma exibição de valor rastreando um ValueTracker), use add_updater, nunca reproduza manualmente cada quadro:

rastreador = ValueTracker(0)
rotulo = DecimalNumber(0).add_updater(lambda d: d.set_value(rastreador.get_value()))
ponto = Dot().add_updater(lambda m: m.move_to(eixos.c2p(rastreador.get_value(), f(rastreador.get_value()))))
self.add(rotulo, ponto)
self.play(rastreador.animate.set_value(5), run_time=3, rate_func=linear)

Sempre remove_updater (ou use always_redraw para lógica de recalcular do zero mais limpa) assim que a fase de dependência de um objeto terminar, para evitar bugs de updater obsoletos posteriores em cenas longas.


5. PROTOCOLO DE TEMPO, RITMO & EASING

5.1 Política de Função de Taxa Padrão

  • Padrão (não substitua): smooth — ease-in/ease-out em curva S. Use para 90% das animações — revelações de equações, criação de formas, movimentos padrão.
  • linear: obrigatório para qualquer coisa que descreva movimento físico literal de taxa constante — pontos orbitando, vetores de velocidade uniforme, ponteiros de relógio girando, barras de progresso vinculadas ao tempo real decorrido.
  • rush_into / rush_from: use para entradas/saídas de ênfase onde algo deve parecer que está se encaixando no lugar ou sendo lançado para longe.
  • there_and_back / there_and_back_with_pause: use para pulsos de atenção estilo Indicate, nunca para mudanças de estado permanentes.
  • ease_out_bounce / ease_out_elastic: reserve para conteúdo lúdico e informal apenas — nunca em uma derivação formal de matemática/ciência, onde parece pouco profissional.

5.2 Regras de Orçamento de Tempo

  • Mantenha run_time individual entre 0,4s e 3s. Abaixo de 0,4s parece chocante; acima de 3s (sem motivo narrativo) arrasta.
  • Entradas de títulos/cabeçalhos de seção: 0,8–1,2s.
  • Transformações de equações/diagramas: 1,0–1,5s.
  • Pulsos de ênfase (Indicate, Flash, Circumscribe): 0,5–0,8s.
  • Movimentos de câmera (move_camera, self.camera.frame.animate): 1,5–3s — movimentos de câmera mais rápidos que isso causam náuseas.
  • Insira pausas deliberadas self.wait(0,3–1,0) após cada grande revelação — nunca encadeie chamadas self.play() consecutivas sem pausa; isso sobrecarrega o espectador.

5.3 Protocolo de Composição

  • Eventos simultâneos mas independentes → chamada única self.play(AnimA, AnimB, ...).
  • Simultâneos com início escalonado (ex., 6 tópicos aparecendo em sequência mas se sobrepondo) → LaggedStart(*anims, lag_ratio=0.15).
  • Eventos estritamente sequenciais e dependentes → Succession(*anims) ou chamadas self.play() separadas.
  • Revelações de listas/grades (marcadores, grades de formas) → sempre LaggedStartMap(FadeIn, grupo, lag_ratio=0.08, shift=UP*0.3) em vez de um único FadeIn(grupo) simultâneo — o escalonamento é o que faz as entradas de grupo parecerem orgânicas em vez de robóticas.

6. PROTOCOLO DE ORGANIZAÇÃO DE CENA & CÓDIGO

6.1 Forma do Método construct

Sempre decomponha construct() em fases claramente delimitadas e nomeadas por meio de comentários ou métodos auxiliares — nunca um bloco ininterrupto de 100 linhas:

class CenaDerivacao(Cena):
    def construct(self):
        self.configurar_titulo()
        self.mostrar_equacao_inicial()
        self.derivar_passos()
        self.destacar_resultado()
        self.limpar()

    def configurar_titulo(self):
        self.titulo = Text("Derivando a Fórmula Quadrática", font=FONTE_PRINCIPAL).to_edge(UP)
        self.play(Write(self.titulo), run_time=T_NORMAL)
        self.wait(T_RAPIDO)

    def mostrar_equacao_inicial(self):
        ...

Para vídeos longos, divida em várias classes de cena (uma por seção lógica) em vez de um único construct() gigante — permite renderização direcionada via -n e iteração paralela.

6.2 Protocolo de Construção de Mobjects

  • Construa visuais personalizados complexos (diagramas, gráficos, ícones) como funções independentes em helpers.py retornando um VGroup, não inline em construct():
# helpers.py
def criar_neuronio(raio=0.3, cor=PRIMARIA) -> VGroup:
    circulo = Circle(radius=raio, color=cor, fill_opacity=0.8)
    rotulo = Text("n", font_size=20).move_to(circulo)
    return VGroup(circulo, rotulo)
  • Sempre nomeie mobjects de forma significativa (titulo, eq_inicial, grupo_grafico) — nunca deixe literais anônimos não referenciados que você precisará mutar ou transformar depois.
  • Use z_index explicitamente para qualquer cena com camadas sobrepostas (não confie apenas na ordem de adição assim que houver mais de 2 camadas).

6.3 Regras de Estilo / Linting

  • snake_case para variáveis/métodos, PascalCase para subclasses de Cena.
  • Uma linha em branco entre "batidas" de animação no código para legibilidade — a estrutura do código deve espelhar visualmente o ritmo do vídeo.
  • Sem números mágicos para cor/posição/tempo — sempre referencie as constantes de tema.py.
  • Dicas de tipo para funções auxiliares (def criar_eixos() -> Axes:) para capacidade de manutenção em projetos maiores.

7. PROTOCOLO DE COMPOSIÇÃO & CÂMERA (2D & 3D)

2D

  • Use MovingCameraScene sempre que o vídeo precisar panorâmica/zoom em 2D (ex., focando em uma sub-região de um diagrama) — anime via self.camera.frame.animate.move_to(...).set(width=...), sempre com um run_time explícito.

3D

  • Subclasse ThreeDScene.
  • Defina a orientação inicial com self.set_camera_orientation(phi=70*GRAUS, theta=-45*GRAUS, zoom=1) em uma etapa de configuração dedicada — nunca deixe a orientação padrão a menos que seja intencional.
  • Para qualquer reposicionamento de câmera que o espectador deve perceber como movimento, use self.move_camera(phi=..., theta=..., run_time=2.5) — nunca corte bruscamente via set_camera_orientation no meio da cena.
  • Use self.begin_ambient_camera_rotation(taxa=0.15) para rotação lenta e ambiente sob narração; sempre emparelhe com self.stop_ambient_camera_rotation() antes de qualquer move_camera deliberado subsequente.
  • HUD/rótulos/títulos que devem permanecer legíveis independentemente do ângulo da câmera → self.add_fixed_in_frame_mobjects(rotulo).
  • Rótulos que devem rastrear objetos 3D mas permanecer legíveis → self.add_fixed_orientation_mobjects(rotulo).
  • Mantenha as tuplas de resolução de superfície 3D baixas (ex., (24,24)) durante a iteração; aumente apenas para a renderização final de produção — esta é puramente uma regra de desempenho/fluxo de trabalho, não visual.

8. PROTOCOLO DE ÊNFASE & ATENÇÃO

Nunca deixe um resultado chave visualmente idêntico ao conteúdo de suporte. Depois de revelar a "recompensa" de uma cena (equação final, insight chave, resultado), aplique exatamente uma técnica de ênfase — não empilhe mais de uma ou parecerá frenético:

  • Circumscribe(mobjeto, cor=DESTAQUE, run_time=1.2) — desenha uma forma ao redor dele.
  • Indicate(mobjeto, fator_escala=1.15) — breve pulso de escala + flash de cor.
  • Flash(ponto, cor=DESTAQUE) — explosão radial, bom para um ponto/coordenada de interseção específica.
  • mobjeto.animate.set_color(DESTAQUE) combinado com uma ligeira escala — para recolorir permanentemente sinalizando "esta é a resposta."

9. PROTOCOLO DE RENDERIZAÇÃO & EXPORTAÇÃO

9.1 Arquivo de Configuração Fixo (confirme este — nunca confie em flags ad hoc para 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 Estágios do Fluxo de Trabalho (sempre siga esta ordem, nunca renderize a qualidade final primeiro)

  1. Passe de rascunho: manim -pql cenas/02_derivacao.py CenaDerivacao — iteração rápida, verifique lógica/tempo.
  2. Passe de verificação: manim -pqh -s cenas/02_derivacao.py CenaDerivacao — verificação de alta qualidade de quadro único da composição/cor.

Habilidades Relacionadas