Un guide 2026 pour le développement d’une interface d’add-on Blender

Si vous avez déjà écrit un script Blender, vous avez probablement réalisé que réussir la fonctionnalité ne représente qu’une partie du travail : l’autre partie, c’est d’amener quelqu’un à s’en servir ! Une interface utilisateur claire est indispensable pour partager et vendre des add-ons Blender.

Dans ce guide, vous apprendrez comment construire des interfaces pour vos add-ons Blender grâce au système de mise en page intégré. Nous couvrirons les types les plus courants de composants UI, où les panneaux peuvent apparaître, et nous passerons en revue un exemple minimal fonctionnel. À la fin, vous saurez comment donner à votre add-on une interface graphique native de Blender.

1. Les composants UI courants

Dans Blender, chaque élément de l’interface utilisateur a son équivalent dans la bibliothèque Python. Vous construisez l’UI en créant des classes qui héritent de l’un des types suivants :

• bpy.types.Panel - pour les panneaux personnalisés (les plus courants)
• bpy.types.Menu - pour les menus et sous-menus
• bpy.types.Operator - pour les actions ou outils qui peuvent être lancés via des boutons

Chacune de ces classes peut implémenter une méthode draw(self, context), dans laquelle vous décrivez à quoi l’interface doit ressembler en utilisant des commandes de mise en page. Le système de mise en page de Blender gère automatiquement l’espacement, l’alignement et le positionnement : c’est un système UI déclaratif où vous décrivez simplement ce qui doit apparaître et dans quel ordre.

Voici les éléments de mise en page les plus courants que vous utiliserez :

Éléments d’affichage de base

• Label - Affiche du texte simple, non interactif. Format : layout.label(text="Hello!")
• Separator - Ajoute un espace vertical entre les éléments pour la lisibilité. Format : layout.separator()

Boutons, entrées, propriétés (props) et opérateurs

• Bouton d’opérateur - Crée un bouton cliquable qui déclenche un opérateur (une fonction enregistrée comme commande Blender). Vous pouvez l’utiliser pour des actions comme exporter, dupliquer ou exécuter un script personnalisé. Syntaxe : layout.operator("myaddon.some_action", text="Run Action")

La méthode layout.prop() sert à afficher des propriétés Blender éditables, qui proviennent soit de données intégrées (comme context.object), soit de vos propres propriétés personnalisées. Par exemple, layout.prop(context.object, "name") affiche un champ de texte éditable pour le nom de l’objet. Blender choisit automatiquement le bon widget (zone de texte, curseur, case à cocher, etc.) en fonction du type de la propriété :

• Case à cocher (propriété booléenne) - Affiche une case à cocher de type bascule. Exemple : layout.prop(context.object, "hide_viewport")
• Champ numérique / curseur (Float ou Int) - Affiche une saisie numérique, souvent avec un curseur. Exemple : layout.prop(context.object, "location", index=0, text="X Location")
• Menu déroulant (propriété Enum) - Affiche une liste déroulante lorsque la propriété est une EnumProperty. Exemple : layout.prop(context.object, "type")
• Saisie de texte - Affiche une zone de texte pour les propriétés de type chaîne. Exemple : layout.prop(my_settings, "username")

Organiser la mise en page

Pour garder votre UI structurée et facile à comprendre, Blender fournit des conteneurs de mise en page comme des lignes, des colonnes et des boîtes.

Un panneau contient des lignes et des colonnes. Les lignes et les colonnes contiennent des propriétés, des opérateurs et des labels. Blender gère automatiquement les marges, l’alignement et la mise à l’échelle pour respecter le thème et les règles de mise en page.

• Une ligne (regroupement horizontal) place les éléments côte à côte horizontalement :

row = layout.row()
row.prop(obj, "location")
row.prop(obj, "rotation_euler")

• Une colonne (regroupement vertical) empile les éléments verticalement :

col = layout.column()
col.prop(obj, "scale")
col.prop(obj, "dimensions")

• Une boîte (regroupement visuel) dessine un cadre qui regroupe visuellement des contrôles associés, comme des sections :

box = layout.box()
box.label(text="Transform Settings")
box.prop(obj, "location")
box.prop(obj, "rotation_euler")

Pour la liste complète des composants UI, consultez la page Interface utilisateur de la documentation officielle Blender.

2. Où placer les panneaux UI

Lorsque vous créez un panneau personnalisé dans Blender, vous pouvez décider où dans l’interface il apparaît et quelle zone il occupe grâce à deux attributs de classe clés :

• bl_space_type - indique l’éditeur ou l’espace de travail auquel votre panneau appartient (par exemple, la Vue 3D, l’Éditeur des propriétés ou l’Éditeur de nœuds).
• bl_region_type - indique la partie de cet éditeur dans laquelle le panneau apparaît (par exemple, la barre latérale, la barre d’outils ou la fenêtre principale).

Voici une liste des zones les plus typiques où vous pourriez placer un panneau personnalisé :

• La barre latérale de la vue 3D apparaît dans la barre latérale du panneau N à droite de la Vue 3D. C’est l’emplacement le plus courant pour les outils de modélisation, de rigging ou de scène :

bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'

• Vous pouvez ajouter des panneaux dans l’Éditeur des propriétés, entre les onglets Objet, Matériau ou Scène. Utilisez cela lorsque votre add-on traite des matériaux, des objets, des réglages de rendu ou des propriétés de scène :

bl_space_type = 'PROPERTIES'
bl_region_type = 'WINDOW'

• Dans la barre latérale de l’Éditeur UV/Image (utile pour les outils de textures ou les utilitaires d’images) :

bl_space_type = 'IMAGE_EDITOR'
bl_region_type = 'UI'

• Dans la barre latérale des éditeurs Shader, Geometry Node ou Compositor pour les outils qui fonctionnent avec des nœuds, des shaders ou des systèmes procéduraux :

bl_space_type = 'NODE_EDITOR'
bl_region_type = 'UI'

L’emplacement de panneau le plus adapté dépend de l’objectif de votre outil :

• Outils de modélisation / objets → Barre latérale de la Vue 3D (VIEW_3D + UI)
• Réglages de matériau ou de rendu → Éditeur des propriétés (PROPERTIES + WINDOW)
• Utilitaires de textures → Barre latérale de l’éditeur d’image (IMAGE_EDITOR + UI)
• Outils Shader / Géométrie → Barre latérale de l’éditeur de nœuds (NODE_EDITOR + UI)

Choisir le bon espace aide les utilisateurs à trouver votre add-on là où ils s’attendent naturellement à ce qu’il soit, tout en gardant votre UI cohérente avec Blender.

3. Exemple minimal : panneau personnalisé dans la barre latérale de la Vue 3D

Faisons un test avec un plugin simple : un panneau personnalisé dans la barre latérale de la vue 3D qui affiche une alerte « hello world » quand on clique sur un bouton.

1) bl_info - métadonnées de l’add-on

On commence par définir les métadonnées de l’add-on pour indiquer à Blender comment le présenter à un utilisateur potentiel :

bl_info = {
    "name": "Simple Addon Example",
    "author": "Your Name",
    "version": (1, 0),
    "blender": (4, 0, 0),
    "location": "View3D > Sidebar > Simple Tab",
    "description": "A simple example addon that prints a message",
    "category": "3D View",
}

• bl_info est un dictionnaire au niveau du module que Blender utilise pour afficher les infos de l’add-on dans Préférences → Add-ons
  • name: nom lisible affiché dans la liste
  • author: chaîne de l’auteur
  • version: tuple représentant la version de l’add-on
  • blender: version minimale de Blender ciblée par cet add-on (tuple)
  • location: emplacement où apparaît l’UI de l’add-on (utile pour les utilisateurs)
  • description: courte description utilisée dans l’UI
  • category: catégorie de regroupement dans la liste Add-ons

Il est essentiel de garder votre bl_info exact, car Blender le lit lors du scan des add-ons installés.

2) Définir une classe d’opérateur

On définit ensuite une sous-classe Operator. Les opérateurs sont la manière officielle d’exécuter des actions dans Blender : ils peuvent être invoqués depuis l’UI, via des raccourcis, via le menu de recherche, etc.

class SIMPLEADDON_OT_hello(bpy.types.Operator):
    bl_idname = "simple_addon.say_hello"
    bl_label = "Say Hello"
    bl_description = "Prints a message to the console"
    def execute(self, context):
        self.report({'INFO'}, "Hello from Blender Addon!")
         print("Hello from Blender Addon!")
        return {'FINISHED'}

• bl_idname - une chaîne d’identifiant unique sous la forme "module_name.operator_name", en minuscules et avec un point. C’est ainsi que vous appelez l’opérateur depuis le code ou l’UI (bpy.ops.simple_addon.say_hello()).
• bl_label - libellé visible côté utilisateur, qui apparaît sur les boutons/menus.
• bl_description - infobulle/description affichée dans l’UI.
• execute(self, context) - méthode principale appelée lorsque l’opérateur s’exécute (exécution synchrone). context donne accès à l’état actuel de Blender (objet actif, scène, zone, etc.). self.report({'INFO'}, "…") affiche un petit message dans la barre d’infos / statut de Blender (utile pour le retour utilisateur). print("…") envoie un message dans la console système / Blender (utile pour le débogage). Renvoie un ensemble comme {'FINISHED'} ou {'CANCELLED'}. Blender utilise ce résultat pour savoir si l’opérateur s’est terminé avec succès.

3) Classe de panneau - emplacement UI

On arrive ensuite à la sous-classe Panel pour ajouter de l’UI dans Blender :

class SIMPLEADDON_PT_panel(bpy.types.Panel):
    bl_label = "Simple Addon Panel"
    bl_idname = "SIMPLEADDON_PT_panel"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'
    bl_category = 'Simple'
    def draw(self, context):
        layout = self.layout
        layout.operator("simple_addon.say_hello")

• bl_label - titre du panneau affiché dans l’UI.
• bl_idname - identifiant unique du panneau.
• bl_space_type = 'VIEW_3D' indique à Blender que ce panneau appartient à la zone de la Vue 3D.
• bl_region_type = 'UI' l’affiche dans la zone à droite (le panneau N). D’autres zones existent (par exemple, 'TOOLS', 'WINDOW').
• bl_category = 'Simple' - le nom de l’onglet dans la barre latérale. Le panneau apparaîtra sous un onglet intitulé « Simple ».
• draw(self, context) est appelé pour dessiner la mise en page UI.
• self.layout est un objet UILayout utilisé pour placer boutons, labels, propriétés, etc.
• layout.operator("simple_addon.say_hello") crée un bouton qui, une fois cliqué, appelle l’opérateur avec l’identifiant bl_idname "simple_addon.say_hello". Le texte du bouton est pris de la valeur bl_label de l’opérateur.

4) Fonctions register / unregister

Blender exige que les classes qui définissent l’UI, les opérateurs, les panneaux, les propriétés, etc., soient enregistrées afin que Blender sache qu’elles existent :

def register():
    bpy.utils.register_class(SIMPLEADDON_OT_hello)
    bpy.utils.register_class(SIMPLEADDON_PT_panel)
def unregister():
    bpy.utils.unregister_class(SIMPLEADDON_PT_panel)
    bpy.utils.unregister_class(SIMPLEADDON_OT_hello)

• bpy.utils.register_class(Class) enregistre une classe ; unregister_class la retire.
• Il est important de désenregistrer les classes dans l’ordre inverse de l’enregistrement, surtout quand les classes se référencent entre elles. C’est pourquoi le panneau est désenregistré avant l’opérateur.
• Lorsque l’add-on est activé dans les Préférences, Blender appelle register(). Lorsqu’il est désactivé, il appelle unregister().

On met le code complet dans un fichier Python addon.py :

bl_info = {
    "name": "Simple Addon Example",
    "author": "Your Name",
    "version": (1, 0),
    "blender": (4, 0, 0),
    "location": "View3D > Sidebar > Simple Tab",
    "description": "A simple example addon that prints a message",
    "category": "3D View",
}
import bpy
class SIMPLEADDON_OT_hello(bpy.types.Operator):
    bl_idname = "simple_addon.say_hello"
    bl_label = "Say Hello"
    bl_description = "Prints a message to the console"
    def execute(self, context):
        self.report({'INFO'}, "Hello from Blender Addon!")
        print("Hello from Blender Addon!")
        return {'FINISHED'}
class SIMPLEADDON_PT_panel(bpy.types.Panel):
    bl_label = "Simple Addon Panel"
    bl_idname = "SIMPLEADDON_PT_panel"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'
    bl_category = 'Simple'
    def draw(self, context):
        layout = self.layout
        layout.operator("simple_addon.say_hello")
def register():
    bpy.utils.register_class(SIMPLEADDON_OT_hello)
    bpy.utils.register_class(SIMPLEADDON_PT_panel)
def unregister():
    bpy.utils.unregister_class(SIMPLEADDON_PT_panel)
    bpy.utils.unregister_class(SIMPLEADDON_OT_hello)

4. Lancer et empaqueter votre add-on

Une fois que vous avez écrit votre script d’add-on, vous pouvez le charger dans Blender et le tester immédiatement. Aucun outil requis.

1. Enregistrez votre script - Enregistrez votre fichier Python avec un nom clair comme my_addon.py.
2. Ouvrez les Préférences des add-ons de Blender - Allez dans Edition → Préférences → Add-ons. C’est ici que Blender gère toutes les extensions installées.
3. Installez l’add-on - Cliquez sur le bouton Installer… en haut de la fenêtre des préférences. Sélectionnez votre fichier my_addon.py puis cliquez sur Installer l’add-on.
4. L’activez - Après l’installation, votre add-on doit apparaître dans la liste. Trouvez-le (vous pouvez rechercher « Mon add-on ») puis cochez la case pour l’activer s’il n’est pas déjà activé.

5. Testez-le dans l’interface - Ouvrez la Vue 3D, ouvrez la barre latérale et cherchez l’onglet appelé Simple. Votre panneau personnalisé devrait y être, prêt à être utilisé !

Quand vous voulez partager votre add-on avec d’autres, vous pouvez le téléverser sur GitHub, Blender Artists ou Gumroad pour la distribution. Ajoutez un README.md court qui explique ce que fait l’add-on et comment l’installer.

Pour les add-ons composés de plusieurs fichiers (par ex. modules séparés, icônes ou ressources), créez un dossier puis compressez l’ensemble du dossier (my_addon.zip) et partagez-le. Blender peut installer des archives .zip directement via le même bouton Installer… : il n’est donc pas nécessaire de l’extraire au préalable. Le point d’entrée principal doit s’appeler init.py, car Blender le traite comme un package Python.

Conclusion

Créer une UI pour les add-ons Blender peut sembler intimidant au début, mais c’est l’une des façons les plus simples de partager un outil que vous avez créé. Une fois que vous comprenez comment fonctionnent les panneaux et les mises en page, vous pouvez ajouter rapidement des boutons, des propriétés et des sections bien organisées que les utilisateurs trouveront intuitives.

Jetez un œil au dépôt de code sur Github pour tester l’exemple par vous-même.

Commencez modestement en ajoutant un panneau simple, un label et un bouton pour créer une action, puis développez à partir de là !