Que fait MSP — Manim Style & Protocol ?
Une spécification de compétence de qualité production pour les animations Manim générées par IA
Version: 1.0
Cible: Manim Community Edition (ManimCE) ≥ v0.18
Objectif: Permettre à tout système d'IA de générer par défaut des animations Manim propres, organisées, à morphing fluide et de qualité studio/production — et non comme une exception.
0. DIRECTIVE PRINCIPALE
Chaque scène que vous écrivez doit donner l'impression de provenir d'un studio d'animation professionnel, et non d'un script d'étudiant. Si un choix est ambigu, optez pour l'option la plus fluide, plus propre et plus intentionnelle — jamais le défaut le plus paresseux.
Avant d'écrire du code, parcourez silencieusement cette liste de contrôle :
- Quelle est l'unique idée que cette scène communique ?
- Quelle est la hiérarchie visuelle (que doit voir l'œil en premier, deuxième, troisième) ?
- Quelle palette de couleurs et quelle police est-ce que j'utilise, et est-ce cohérent à l'échelle du projet ?
- Comment chaque objet va-t-il entrer, se transformer et sortir — rien ne doit simplement « apparaître » ou « disparaître » sans un verbe d'animation.
- Quel est le rythme (budget total de run_time) pour la scène ?
1. ENVIRONNEMENT & VERROUILLAGE DE VERSION
Utilisez toujours par défaut Manim Community Edition, pas ManimGL, sauf si l'utilisateur demande explicitement le style 3b1b de ManimGL.
from manim import *
- Binaire CLI :
manim(pasmanimgl) - Verbe de création :
Create()(pasShowCreation()) - Rendu mathématique :
MathTex(r"...")(pasTex(R"..."))
Ne mélangez jamais les API. Si un extrait utilise self.camera.frame sans MovingCameraScene/ThreeDScene, signalez-le — c'est une syntaxe ManimGL qui s'infiltre.
2. STRUCTURE DE FICHIERS DU PROJET
Pour tout ce qui dépasse une scène triviale unique, imposez cette structure — ne mettez jamais tout dans un seul fichier monolithique :
projet/
├── manim.cfg # configuration de rendu verrouillée (voir §9)
├── theme.py # couleurs, polices, constantes (source unique de vérité)
├── helpers.py # constructeurs de mobjects / fonctions de disposition réutilisables
├── scenes/
│ ├── 01_intro.py
│ ├── 02_derivation.py
│ └── 03_outro.py
└── assets/ # svgs, images, audio
Exemple de theme.py (CRÉEZ-EN TOUJOURS UN pour les projets multi-scènes) :
from manim import *
# ---- PALETTE ----
BG_COLOR = "#0E0E12"
PRIMARY = "#58C4DD" # bleu par défaut de manim, ou couleur de marque
SECONDARY = "#FFD166"
ACCENT = "#EF476F"
TEXT_MAIN = "#F5F5F5"
TEXT_MUTED = "#8A8A8F"
SUCCESS = "#06D6A0"
# ---- TYPOGRAPHIE ----
FONT_MAIN = "Helvetica" # ou spécifique au projet
FONT_MONO = "JetBrains Mono"
# ---- CONSTANTES DE TEMPORISATION ----
T_FAST = 0.5
T_NORMAL = 1.0
T_SLOW = 1.8
LAG = 0.08 # lag_ratio par défaut pour les révélations groupées
config.background_color = BG_COLOR
Chaque fichier de scène importe theme.py. Ne codez jamais en dur les couleurs hexadécimales ou les nombres magiques run_time en ligne une fois qu'un fichier de thème existe — c'est le marqueur n°1 d'une sortie non professionnelle et incohérente.
3. NORMES DE CONCEPTION VISUELLE
3.1 Règles de couleur
- Maximum 4 à 5 couleurs par projet (1 fond, 1 à 2 primaires, 1 à 2 accents). Plus donne une impression de bruit/amateur.
- Utilisez la couleur sémantiquement : même couleur = même signification dans toute la vidéo (par exemple, toujours bleu pour « donné », toujours rouge pour « inconnu »).
- Le fond ne doit presque jamais être du noir pur (
#000000) ou du blanc pur — utilisez un noir doux proche (#0E0E12) ou un blanc cassé doux pour réduire la fatigue oculaire et donner un aspect « studio ».
3.2 Règles typographiques
Text()pour les étiquettes d'interface, les titres, les légendes — rapide, sans dépendance LaTeX.MathTex()pour toutes les notations mathématiques — ne simulez jamais les maths avecText().Tex()uniquement pour les blocs LaTeX mixtes prose + mathématiques.- Définissez un
font=global via les constantes de thème ; ne laissez jamais le choix de la police varier d'une scène à l'autre. - Convention de titre :
.to_edge(UP), poids gras, taille de police cohérente (par exemple, 40pt) dans chaque scène.
3.3 Règles de disposition
- Respectez la règle des tiers — évitez de centrer par défaut ; utilisez
.to_edge(),.shift(),.next_to()délibérément. - Maintenez des marges cohérentes (valeurs de buff) — définissez une constante
MARGIN = 0.75et réutilisez-la dans chaque appel.to_edge(..., buff=MARGIN). - Regroupez les objets connexes dans un seul
VGroupet positionnez/animez le groupe, pas des mobjects individuels lâches — cela garantit que l'alignement reste correct après toute transformation ultérieure. - Appelez toujours
.arrange()ou.arrange_in_grid()sur les groupes au lieu de calculer manuellement les coordonnées — les coordonnées manuelles sont fragiles et la source n°1 de dispositions cassées sous les modifications ultérieures.
4. LE PROTOCOLE DE MORPHING & DE TRANSFORMATION
C'est le cœur de l'animation « fluide et morphing » — le look signature des vidéos explicatives haut de gamme.
4.1 Règle : Ne jamais couper, toujours transformer
Si un objet devient conceptuellement un autre objet (équation réarrangée, forme devient une autre forme, étiquette mise à jour), ne jamais FadeOut + FadeIn en tant que mobjects distincts non liés — cela se lit comme un jump cut. Utilisez toujours une famille de transformations :
| Situation | Outil correct |
|---|---|
| L'équation se réarrange, les termes persistent | TransformMatchingTex(ancien, nouveau) |
| La forme se transforme en une forme différente | Transform(ancien, nouveau) ou ReplacementTransform(ancien, nouveau) |
| Le groupe de mobjects se restructure (par exemple, liste à puces → diagramme) | TransformMatchingShapes(ancien_groupe, nouveau_groupe) |
| Un objet remplace explicitement un autre dans le graphe de la scène | ReplacementTransform (échange l'ancien contre le nouveau dans self.mobjects) |
| Fondu tout en suggérant une continuité (par exemple, fantôme/superposition) | FadeTransform(ancien, nouveau) |
Détail du protocole pour TransformMatchingTex : construisez toujours les deux mobjects MathTex avec un regroupement de sous-chaînes cohérent (les mêmes fragments LaTeX en tant que groupes {} séparés) afin que Manim puisse faire correspondre les symboles identiques — c'est ce qui fait que les termes « glissent » visuellement vers leur nouvelle position au lieu d'un fondu enchaîné.
eq1 = MathTex("a", "+", "b", "=", "c")
eq2 = MathTex("c", "=", "a", "+", "b")
self.play(TransformMatchingTex(eq1, eq2), run_time=1.2)
4.2 Règle : Utilisez .animate pour les morphing de propriétés simples
Pour les changements de propriétés continus uniques (position, échelle, couleur, rotation) sur un mobject, préférez la syntaxe .animate — elle est plus propre et Manim interpole la transformation nette automatiquement :
self.play(square.animate.shift(RIGHT * 2).scale(1.5).set_color(ACCENT), run_time=1.0)
Mise en garde (critique, évitez les bugs d'hallucination de l'IA) : les appels .animate enchaînés interpolent l'état net final, et non chaque étape intermédiaire de manière séquentielle. N'enchaînez jamais les appels .animate qui dépendent d'un résultat intermédiaire (par exemple, .animate.move_to(X).rotate(angle_depending_on_position)) — séparez-les en appels self.play() distincts.
4.3 Règle : Utilisez les Updaters pour le mouvement continu/dépendant
Chaque fois que l'état d'un objet doit suivre en continu un autre objet (une étiquette suivant un point, un affichage de valeur suivant un ValueTracker), utilisez add_updater, ne re-jouez jamais manuellement chaque image :
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)
Supprimez toujours l'updater (remove_updater) (ou utilisez always_redraw pour une logique de recalcul à partir de zéro plus propre) une fois la phase de dépendance d'un objet terminée, pour éviter les bugs d'updaters obsolètes plus tard dans les longues scènes.
5. PROTOCOLE DE TEMPORISATION, DE RYTHME & D'ACCÉLÉRATION
5.1 Politique de fonction de taux par défaut
- Par défaut (ne pas remplacer) :
smooth— courbe en S ease-in/ease-out. À utiliser pour 90 % des animations — révélations d'équations, création de formes, mouvements standard. linear: obligatoire pour tout ce qui représente un mouvement physique littéral à taux constant — points en orbite, vecteurs à vitesse uniforme, aiguilles d'horloge en rotation, barres de progression liées au temps réel écoulé.rush_into/rush_from: à utiliser pour les entrées/sorties d'accentuation où quelque chose doit sembler se mettre en place ou s'élancer.there_and_back/there_and_back_with_pause: à utiliser pour les impulsions d'attention de typeIndicate, jamais pour les changements d'état permanents.ease_out_bounce/ease_out_elastic: réservez pour un contenu ludique et informel uniquement — jamais dans une dérivation mathématique/scientifique formelle, où cela semble non professionnel.
5.2 Règles de budget de temporisation
- Gardez le
run_timeindividuel entre 0,4 s et 3 s. En dessous de 0,4 s, c'est saccadé ; au-dessus de 3 s (sans raison narrative), ça traîne. - Entrées de titres/en-têtes de section :
0,8–1,2 s. - Transformations d'équations/diagrammes :
1,0–1,5 s. - Impulsions d'accentuation (
Indicate,Flash,Circumscribe) :0,5–0,8 s. - Mouvements de caméra (
move_camera,self.camera.frame.animate) :1,5–3 s— les mouvements de caméra plus rapides donnent la nausée. - Insérez des respirations
self.wait(0,3–1,0)délibérées après chaque révélation majeure — n'enchaînez jamais les appelsself.play()dos à dos sans pause ; cela submerge le spectateur.
5.3 Protocole de composition
- Événements simultanés mais indépendants → un seul appel
self.play(AnimA, AnimB, ...). - Simultané avec départ décalé (par exemple, 6 points de puce apparaissant en séquence mais se chevauchant) →
LaggedStart(*anims, lag_ratio=0,15). - Événements strictement séquentiels et dépendants →
Succession(*anims)ou appelsself.play()séparés. - Révélations de listes/grilles (puces, grilles de formes) → toujours
LaggedStartMap(FadeIn, group, lag_ratio=0,08, shift=UP*0.3)au lieu d'un seulFadeIn(group)simultané — le décalage est ce qui rend les entrées de groupe organiques plutôt que robotiques.
6. PROTOCOLE D'ORGANISATION DES SCÈNES & DU CODE
6.1 Forme de la méthode construct
Décomposez toujours construct() en phases nommées clairement délimitées via des commentaires ou des méthodes d'aide — jamais un bloc ininterrompu de 100 lignes :
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("Dérivation de la formule quadratique", font=FONT_MAIN).to_edge(UP)
self.play(Write(self.title), run_time=T_NORMAL)
self.wait(T_FAST)
def show_initial_equation(self):
...
Pour les longues vidéos, divisez en plusieurs classes de scène (une par section logique) plutôt qu'un seul construct() géant — cela permet un rendu ciblé via -n et une itération parallèle.
6.2 Protocole de construction des mobjects
- Construisez des visuels personnalisés complexes (diagrammes, graphiques, icônes) en tant que fonctions autonomes dans
helpers.pyretournant unVGroup, et non en ligne dansconstruct():
# 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)
- Nommez toujours les mobjects de manière significative (
title,eq_initial,graph_group) — ne laissez jamais de littéraux anonymes non référencés que vous devrez modifier ou transformer plus tard. - Utilisez
z_indexexplicitement pour toute scène avec des couches qui se chevauchent (ne vous fiez pas uniquement à l'ordre d'ajout une fois qu'il y a plus de 2 couches).
6.3 Règles de style / linting
- snake_case pour les variables/méthodes, PascalCase pour les sous-classes de Scene.
- Une ligne vide entre les « temps forts » d'animation dans le code pour la lisibilité — la structure du code doit refléter visuellement le rythme de la vidéo.
- Pas de nombres magiques nus pour la couleur/position/timing — référencez toujours les constantes de
theme.py. - Type-hint pour les fonctions d'aide (
def make_axes() -> Axes:) pour la maintenabilité sur les grands projets.
7. PROTOCOLE DE COMPOSITION & DE CAMÉRA (2D & 3D)
2D
- Utilisez
MovingCameraScenelorsque la vidéo doit panoramiquer/zoomer en 2D (par exemple, se concentrer sur une sous-région d'un diagramme) — animez viaself.camera.frame.animate.move_to(...).set(width=...), toujours avec unrun_timeexplicite.
3D
- Sous-classez
ThreeDScene. - Définissez l'orientation initiale avec
self.set_camera_orientation(phi=70*DEGREES, theta=-45*DEGREES, zoom=1)dans une étape de configuration dédiée — ne laissez jamais l'orientation par défaut sauf si c'est intentionnel. - Pour tout repositionnement de caméra que le spectateur doit percevoir comme un mouvement, utilisez
self.move_camera(phi=..., theta=..., run_time=2.5)— ne faites jamais de jump cut viaset_camera_orientationau milieu d'une scène. - Utilisez
self.begin_ambient_camera_rotation(rate=0.15)pour une rotation lente au repos sous narration ; associez toujours àself.stop_ambient_camera_rotation()avant toutmove_cameradélibéré ultérieur. - HUD/étiquettes/titres qui doivent rester lisibles quel que soit l'angle de la caméra →
self.add_fixed_in_frame_mobjects(label). - Étiquettes qui doivent suivre des objets 3D mais rester lisibles →
self.add_fixed_orientation_mobjects(label). - Gardez les tuples de
résolutionde surface 3D bas (par exemple,(24,24)) pendant l'itération ; augmentez uniquement pour le rendu de production final — c'est purement une règle de performance/flux de travail, pas visuelle.
8. PROTOCOLE D'ACCENTUATION & D'ATTENTION
Ne laissez jamais un résultat clé visuellement identique au contenu de support. Après avoir révélé le « payoff » d'une scène (équation finale, idée clé, résultat), appliquez exactement une technique d'accentuation — n'en empilez pas plus d'une ou cela semble frénétique :
Circumscribe(mobject, color=ACCENT, run_time=1.2)— dessine une forme autour de lui.Indicate(mobject, scale_factor=1.15)— brève impulsion d'échelle + flash de couleur.Flash(point, color=ACCENT)— rafale radiale, bien pour un point/intersection spécifique.mobject.animate.set_color(ACCENT)combiné à une légère échelle — pour un recoloriage permanent signalant "c'est la réponse."
9. PROTOCOLE DE RENDU & D'EXPORTATION
9.1 Fichier de configuration verrouillé (validez-le — ne vous fiez jamais aux indicateurs ad hoc pour la livraison finale)
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 Étapes du flux de travail (suivez toujours cet ordre, ne rendez jamais la qualité finale en premier)
- Passe de brouillon :
manim -pql scenes/02_derivation.py DerivationScene— itération rapide, vérifiez la logique/le timing. - Passe de vérification ponctuelle :
manim -pqh -s scenes/02_derivation.py DerivationScene— vérification haute qualité d'une seule image de la composition/couleur. - Passe de rendu final :
manim -pqh scenes/02_derivation.py DerivationScene— rendu complet haute qualité.
9.3 Rendu en mode transparent (écran vert / alpha)
Pour tout contenu qui sera superposé à un autre métrage ou arrière-plan, utilisez un fond transparent :
config.frame_rate = 60
config.pixel_height = 1080
config.pixel_width = 1920
config.background_color = "#00000000" # Chaîne hexadécimale 8 caractères avec transparence
Ensuite, rendez avec le drapeau --write_all pour écrire chaque image animée sous forme de séquence PNG avec canal alpha :
manim scenes/02_derivation.py DerivationScene -pqh --write_all
Combinez ensuite les images via le pipeline vidéo de votre choix (FFmpeg, AE, etc.).
10. PROTOCOLE DE RÉFÉRENCE DE LA DOCUMENTATION & DES FONCTIONS
Pour toute fonction d'API Manim dont vous n'êtes pas sûr à 100 % de la signature, de l'ordre des paramètres ou de la version dans laquelle elle a été introduite/supprimée :
- Ne l'inventez pas. Ne remplacez pas un paramètre booléen
fill_colormanquant parcoloret n'assumez pas que l'API a une fonctionnalité qu'elle n'a pas. - Consultez la documentation officielle via l'exploration de code (pas une estimation nuancée) :
https://docs.manim.community/en/stable/reference/<ClasseMobject>.html. - Les API héritées/manimGL courantes à éviter :
ShowCreation,FadeInFromDown,get_center,get_top,set_color_by_gradient(utilisezset_color_by_gradientde ManimCE),add_foreground_mobject. Utilisez toujours les alternatives modernes de ManimCE.
11. RÈGLES ANTI-BOUCLES INFINIES & DE SÉCURITÉ
- Fixez toujours un
run_timeexplicite pour chaqueself.play()— les valeurs par défaut non définies peuvent être extrêmement lentes ou boucler indéfiniment dans des cas extrêmes. - Ne créez jamais d'updaters qui se modifient eux-mêmes récursivement. Exemple de bug :
# MAUVAIS — modifie la position en fonction du temps, puis appelle play, ce qui ajoute +t, boucle infinie
self.time = 0
def bad_updater(mob):
self.time += self.dt
mob.move_to(RIGHT * np.sin(self.time))
self.play(mob.animate.shift(UP)) # BOUCLE ! Ne faites jamais play dans un updater
- Les transformations (Transform, ReplacementTransform) doivent avoir des diplômes (degrees de soi ou de la scène) compatibles ; si les mobjects source et cible ont des structures de sous-mobjects radicalement différentes, utilisez
TransformMatchingShapesqui fonctionne par correspondance de courbes. - Si une animation nécessite plus de 3 transformations simultanées, refactorez en une seule animation de groupe avec un seul appel
self.play()— 5self.play()simultanés séparent conceptuellement les événements que l'œil perçoit comme un seul mouvement, ce qui entraîne une désynchronisation visuelle.
12. PROTOCOLE AUDIO (OPTIONNEL MAIS RECOMMANDÉ)
Si un fichier audio de narration ou de fond est fourni, l'animation doit être une interprétation visuelle directe du rythme et des points d'emphase de la piste audio :
- Analysez les indices temporels de l'audio (soit depuis un fichier
.srt, soit depuis des repères temporels explicites fournis) — alignez chaque révélation majeure sur un mot/syllabe accentué. - Concaténez les scènes + audio dans le montage final en utilisant un outil externe (FFmpeg, DaVinci Resolve, AE) — ne cherchez pas à rendre l'audio exactement dans Manim ; Manim n'est pas un outil de montage non linéaire.
- Si aucun audio n'est fourni, supposez un rythme de narration lent et délibéré (~150 mots/min) et espacez les animations en conséquence — plus de
self.wait()que pour une vidéo muette.
13. PROTOCOLE DE REVUE & D'AUTO-VÉRIFICATION
Avant de finaliser un rendu, parcourez cette liste de contrôle de manière algorithmique — ne la sautez jamais, même pour un « petit » changement :
- Tous les run_time sont-ils dans la plage acceptée (0,4–3 s) ?
- Les entrées et sorties ont-elles des verbes d'animation ? (Pas d'apparitions/disparitions soudaines)
- Les transformations sont-elles de la bonne famille ? (Transform vs. TransformMatchingTex vs. FadeTransform)
- Les couleurs sont-elles référencées depuis theme.py et non codées en dur ?
- Tous les appels
self.play()ont-ils un run_time ou lag_ratio explicite ? - La composition suit-elle la règle des tiers ou une disposition intentionnelle ? (Pas de centrage par défaut qui a une belle apparence ?)
- Les appels simultanés
self.play()sont-ils logiquement regroupés (même « temps » dans l'esprit du spectateur) ? - Y a-t-il une
wait()après les révélations majeures ? - La scène importe-t-elle theme.py et utilise-t-elle ses constantes ?
- Les mobjects ont-ils des noms significatifs ? (Pas de
v1,v2,temp) - La fonction rate_func est-elle correcte pour le mouvement ? (
linearpour le mouvement à taux constant,smoothpour tout le reste) - Le code évite-t-il d'utiliser des API Markdown ? (Aucune répétition de balises markdown dans les chaînes de code Python — codez les animations Manim en Python pur, pas de balisage markdown dans les appels de fonction).
14. EXEMPLE DE SCÈNE COMPLÈTE (RÉFÉRENCE DE FONCTIONNEMENT)
# scenes/example.py
from theme import *
class ExampleScene(Scene):
def construct(self):
# 1. Titre
title = Text("Loi de Gauss", font=FONT_MAIN).to_edge(UP)
self.play(Write(title), run_time=T_NORMAL)
self.wait(T_FAST)
# 2. Équation initiale
eq = MathTex(r"\oint \mathbf{E} \cdot d\mathbf{A} = \frac{Q_{\text{enc}}}{\epsilon_0}")
self.play(Write(eq), run_time=T_NORMAL)
self.wait(T_FAST)
# 3. Transformer pour développer
eq2 = MathTex(r"\oint \mathbf{E} \cdot d\mathbf{A}", "=", r"\frac{Q_{\text{enc}}}{\epsilon_0}")
self.play(TransformMatchingTex(eq, eq2), run_time=T_SLOW)
self.wait(T_NORMAL)
# 4. Mettre en évidence des parties
box = SurroundingRectangle(eq2[2], color=ACCENT, buff=0.1)
self.play(Create(box), run_time=T_FAST)
self.wait()
Fin de MSP — Manim Style & Protocol v1.0