Rendu vidéo programmatique dans Blender avec Python (2026)

Apprendre Blender en tant qu’artiste 3D signifie généralement découvrir son écosystème d’add-ons. Des tâches qui prendraient des heures, comme le rig d’un personnage, peuvent être réduites à quelques secondes grâce à des add-ons comme Rigify. Il en va de même pour la plupart des workflows, et on finit souvent par se poser la même question récurrente : « Blender peut-il faire ça automatiquement ? »

La réponse est oui. La clé, c’est le langage de programmation Python.

Blender inclut un moteur de script intégré puissant, et avec quelques lignes de code, vous pouvez créer des objets, positionner des caméras, et même déclencher des rendus complets.

Vous n’aurez pas besoin de payer un add-on si vous savez comment en créer un vous-même. Et à la base, un add-on n’est rien d’autre qu’un script enveloppé dans une interface utilisateur Blender personnalisée.

Si vous n’avez jamais scripté dans Blender auparavant, découvrir le module bpy donne l’impression d’ouvrir une porte secrète à l’intérieur d’un outil que vous pensiez déjà connaître : soudain, chaque partie de l’interface devient programmable. Vous ne faites plus seulement des clics sur des boutons, vous donnez des instructions pour construire des systèmes reproductibles.

L’un des workflows les plus importants que vous pouvez automatiser, c’est le rendu. Non seulement pour accélérer votre pipeline, mais aussi pour aider à maintenir des réglages de rendu cohérents et prévisibles. Dans ce tutoriel, nous allons mettre en place un système de rendu programmatique de base pour animer automatiquement un texte 3D et le transformer en une vidéo Full HD. Nous partirons de zéro, en explorant comment exécuter Python pour Blender et comment l’utiliser pour contrôler la scène. À la fin, vous aurez une bonne vue d’ensemble de la manière d’automatiser des tâches d’animation courantes.

Cas d’usage

Le rendu programmatique débloque une grande variété de workflows puissants, bien au-delà de la construction manuelle traditionnelle de scènes :

• Motion graphics pilotés par les données — Graphiques animés, graphismes diffusés en temps réel via API, ou encore vidéos sociales générées automatiquement.
• Art génératif — Motifs procéduraux, champs de bruit, expériences de particules et illustrations algorithmiques qui évoluent à partir du code.
• Variantes rendues par lots — Publicités personnalisées, variations de couleur produit, recadrages automatiques au bon format, et génération massive d’assets sociaux.
• Contenu 3D procédural — Générateurs de terrain, modélisation paramétrique, peuplement de la végétation / monde, et variations automatisées d’assets 3D.
• UI & systèmes de design génératifs — SVG dynamiques, bannières pré-écrites, et graphismes cohérents avec la marque rendus à la demande.
• Scripting VFX et animation — Contrôles de rig automatisés, systèmes de foule, population de particules, et setups de simulation reproductibles.
• Visualisations de simulation — Simulations de fluide et de fumée, dynamique du trafic et de la foule, et rendus scientifiques ou basés sur la physique.

De nombreuses tâches de modélisation 3D sont répétitives et longues. En les intégrant à un pipeline automatisé piloté par script, les artistes peuvent se concentrer davantage sur la construction créative du monde, tandis que Python gère les parties fastidieuses en arrière-plan.

Dans tous les cas, le workflow de développement reste quasiment le même :

1. Configuration - définir les données d’entrée nécessaires et nettoyer la scène
2. Génération de géométrie - modéliser les assets nécessaires à la tâche
3. Animation - définir les transformations et leurs keyframes associées
4. Sortie - les assets souhaités (modèles 3D, vidéo, séquence d’images, etc.)

Et c’est exactement le chemin que nous allons suivre pour notre exemple de rendu vidéo de texte 3D.

1. Configuration de la scène

Avant de nous lancer dans la génération de scènes, il nous faut d’abord un point de départ propre. Lorsque vous ouvrez Blender, il charge une scène par défaut contenant généralement un cube, une caméra et une lumière. Pour ce tutoriel, nous n’aurons besoin que des deux derniers.

La première étape pour utiliser Blender de manière programmatique consiste à importer le module bpy. Cela vous donne un accès complet aux données, outils et pipeline de rendu de Blender directement depuis Python :

import bpy
bpy.data.objects.remove(bpy.data.objects.get("Cube"), do_unlink=True)

Ici, nous supprimons l’objet Cube par défaut. Le paramètre do_unlink=True garantit que Blender supprime non seulement l’objet, mais aussi le désunlinks de toute scène susceptible d’y faire référence.

2. Manipuler du texte 3D

Ensuite, nous ajoutons un objet de texte 3D à la scène pour en faire l’élément central que nous allons manipuler et, finalement, rendre de manière programmatique.

bpy.ops.object.text_add(location=(0, 0, 0))
text_obj = bpy.context.object
text_obj.name = "CaptionText"
text_obj.data.body = "Hello world!"

Ce fragment de code crée un nouvel objet texte à l’origine du monde, lui assigne un nom lisible, et définit le texte affiché sur "Hello world!".

Pour donner plus de présence au texte dans la scène, nous pouvons ajuster sa géométrie. En augmentant sa taille et en ajoutant une extrusion, on obtient un texte pleinement 3D, et le centrer sur les deux axes simplifie les futures transformations et animations :

text_obj.data.size = 0.6
text_obj.data.extrude = 0.05
text_obj.data.align_x = "CENTER"
text_obj.data.align_y = "CENTER"

Avec ces ajustements, le texte est proprement centré, correctement mis à l’échelle, et prêt pour un traitement ultérieur.

3. Ajouter des keyframes

Nous créons une animation simple en insérant des keyframes pour la position du texte au fil du temps.

Tout d’abord, nous déplaçons le curseur de la timeline sur la frame 1, positionnons le texte à l’emplacement de départ, puis enregistrons cette position avec une keyframe :

bpy.context.scene.frame_set(1)
text_obj.location = (-4.0, 0.0, 1.0)
text_obj.keyframe_insert(data_path="location", frame=1)

Ensuite, nous avançons à la frame 40, décalons le texte le long de l’axe X, et insérons une nouvelle keyframe pour marquer sa nouvelle position :

bpy.context.scene.frame_set(40)
text_obj.location = (0.0, 0.0, 1.0)
text_obj.keyframe_insert(data_path="location", frame=40)

Avec ces deux keyframes en place, Blender interpole automatiquement le mouvement entre elles, créant une animation fluide pendant que le texte glisse vers le centre de l’image.

4. Rendu vidéo

Il ne nous reste plus qu’à configurer les réglages de rendu de Blender et à générer la vidéo finale.

Le premier choix concerne le moteur de rendu à utiliser : Eevee ou Cycles.

Eevee est un moteur de rasterisation temps réel, ce qui le rend extrêmement rapide et idéal pour les aperçus ou les animations stylisées. Cycles, quant à lui, est un traceur de trajectoires physiquement basé qui produit un éclairage plus réaliste, mais nécessite des temps de rendu beaucoup plus longs. Pour un prototypage rapide et la plupart des workflows automatisés, Eevee est généralement le meilleur choix :

bpy.context.scene.render.engine = "BLENDER_EEVEE"

Ensuite, nous spécifions la résolution de sortie :

bpy.context.scene.render.resolution_x = 1920
bpy.context.scene.render.resolution_y = 1080

Puis nous définissons la fréquence d’images et la plage d’animation. Ici, un plan de 60 frames à 24 fps :

bpy.context.scene.render.fps = 24
bpy.context.scene.frame_start = 1
bpy.context.scene.frame_end = 60

Blender doit aussi savoir comment encoder la vidéo finale. Nous l’exportons en MP4 en utilisant l’encodage vidéo H.264 pour la vitesse de rendu :

bpy.context.scene.render.image_settings.file_format = "FFMPEG"
bpy.context.scene.render.ffmpeg.format = "MPEG4"
bpy.context.scene.render.ffmpeg.codec = "H264"

Enfin, nous choisissons où le fichier de sortie sera écrit, en utilisant le dossier courant pour plus de commodité :

bpy.context.scene.render.filepath = "//render.mp4"

Une fois tout configuré, nous pouvons lancer le rendu avec une seule commande :

bpy.ops.render.render(animation=True)

5. Tout réunir

Notre code est terminé : il ne reste plus qu’à le placer dans un fichier Python render.py :

import bpy
bpy.data.objects.remove(bpy.data.objects.get("Cube"), do_unlink=True)
bpy.ops.object.text_add(location=(0, 0, 0))
text_obj = bpy.context.object
text_obj.name = "CaptionText"
text_obj.data.body = "Hello world!"
text_obj.data.size = 0.6
text_obj.data.extrude = 0.05
text_obj.data.align_x = "CENTER"
text_obj.data.align_y = "CENTER"
bpy.context.scene.frame_set(1)
text_obj.location = (-4.0, 0.0, 1.0)
text_obj.keyframe_insert(data_path="location", frame=1)
bpy.context.scene.frame_set(40)
text_obj.location = (0.0, 0.0, 1.0)
text_obj.keyframe_insert(data_path="location", frame=40)
bpy.context.scene.render.engine = "BLENDER_EEVEE"
bpy.context.scene.render.resolution_x = 1920
bpy.context.scene.render.resolution_y = 1080
bpy.context.scene.render.resolution_percentage = 100
bpy.context.scene.render.fps = 24
bpy.context.scene.frame_start = 1
bpy.context.scene.frame_end = 60
bpy.context.scene.render.image_settings.file_format = "FFMPEG"
bpy.context.scene.render.ffmpeg.format = "MPEG4"  # container
bpy.context.scene.render.ffmpeg.codec = "H264"
bpy.context.scene.render.ffmpeg.constant_rate_factor = "HIGH"
bpy.context.scene.render.ffmpeg.gopsize = 12
bpy.context.scene.render.ffmpeg.audio_codec = "AAC"
bpy.context.scene.render.filepath = "//render.mp4"
bpy.ops.render.render(animation=True)

Maintenant, exécutez le script pour démarrer le rendu :

python3 render.py

Une fois le rendu terminé, vérifiez votre répertoire de travail et votre animation générée entièrement de manière programmatique devrait maintenant être prête à être visionnée.

Conclusion

Dans cette démo pas à pas, vous avez construit un pipeline automatisé complet à l’intérieur de Blender : configurer une scène propre, créer et modifier du texte 3D, l’animer avec des keyframes, puis rendre la séquence avec une interpolation fluide. Tout cela est géré via Python, sans aucun réglage manuel nécessaire !

Maintenant que vous avez vu à quel point l’API Blender offre du contrôle, vous pouvez aller beaucoup plus loin avec ces idées : automatiser vos workflows, générer des graphismes à partir de données, construire des outils internes qui assemblent des scènes, rendre des variantes, ou créer des animations entières avec une seule commande... la liste pour aider votre studio d’animation à gagner en productivité ne s’arrête jamais.