Créer un thème enfant WordPress : pourquoi, comment et le cas d’Avada

Un thème enfant WordPress est un thème qui hérite du design et des fonctionnalités d’un thème parent, et dans lequel vous placez vos propres modifications : le parent peut ensuite être mis à jour sans écraser votre travail. Pour créer un thème enfant WordPress, il suffit d’un dossier dans wp-content/themes, d’un fichier style.css dont la ligne Template désigne le dossier du parent et, le plus souvent, d’un fichier functions.php qui charge les feuilles de style. On l’installe et on l’active ensuite comme n’importe quel thème, depuis Apparence > Thèmes.

Je travaille sur WordPress depuis 14 ans, et ce site, devwp.fr, tourne lui-même sur un thème enfant d’Avada. Ce guide reprend la méthode que j’applique : à quoi sert un thème enfant et quand s’en passer, la création pas à pas avec un code à jour pour WordPress 7.1, le cas des thèmes de blocs comme Twenty Twenty-Five, celui d’Avada et d’Elementor, puis les erreurs les plus fréquentes.

Thème enfant WordPress : à quoi ça sert ?

Un thème existant (Avada, Astra, Twenty Twenty-Five…) reçoit régulièrement des mises à jour : correctifs de sécurité, compatibilité avec les nouvelles versions de WordPress et de PHP, nouvelles fonctions. Chaque mise à jour remplace l’intégralité de ses fichiers. Le thème enfant sert à mettre vos modifications à l’abri de ce remplacement, dans un dossier que la mise à jour ne touche pas.

Ce que le thème enfant hérite du parent, et ce qu’il remplace

• Les fichiers de modèle (header.php, single.php, ou templates/*.html pour un thème de blocs) : WordPress cherche d’abord le fichier dans le thème enfant, puis dans le parent. Un fichier de même nom dans l’enfant remplace donc celui du parent.
• Le fichier functions.php : celui de l’enfant ne remplace pas celui du parent. Les deux sont chargés, l’enfant juste avant le parent.
• Le fichier style.css : il est obligatoire, car c’est lui qui déclare le thème enfant. En revanche, son CSS n’est appliqué que s’il est chargé (étape 4).
• Le fichier theme.json (thèmes de blocs) : celui de l’enfant est fusionné avec celui du parent.

Il n’existe que deux niveaux : un thème enfant ne peut pas avoir lui-même d’enfant. La documentation officielle des thèmes enfants le confirme.

Pourquoi ne jamais modifier le thème parent directement

Une modification faite dans les fichiers du parent disparaît à la mise à jour suivante. Le réflexe qui en découle est pire encore : ne plus mettre le thème à jour pour ne pas perdre le travail, et laisser le site exposé aux failles corrigées depuis. Quand je reprends un site existant, je vérifie toujours si le thème parent a été modifié avant de lancer la moindre mise à jour.

Le thème enfant a un second avantage : tout votre code personnalisé est rangé au même endroit. Vous savez exactement ce qui a été changé, et vous pouvez comparer facilement le comportement du site avec et sans vos modifications, sur une copie de préproduction.

Attention à une idée reçue : un thème enfant n’est pas un bac à sable. Une fois activé, c’est lui qui sert votre site en production. Testez vos modifications sur une copie du site, jamais directement en ligne. Il n’accélère pas non plus votre site : il ajoute au contraire une petite feuille de style.

Quand un thème enfant n’est pas nécessaire

• Quelques lignes de CSS : le champ CSS additionnel de l’outil de personnalisation (thème classique) ou les styles de l’éditeur de site (thème de blocs) suffisent.
• Un site construit entièrement dans un constructeur (Avada Builder, Elementor) : la mise en page est enregistrée dans le contenu et les options du constructeur, pas dans les fichiers du thème.
• Une fonctionnalité (type de contenu, intégration, shortcode) : elle a sa place dans une extension, pas dans un thème (voir plus bas).

Dès que vous touchez au PHP ou aux fichiers de modèle, le thème enfant devient indispensable. Comme il ne coûte presque rien à mettre en place, je le crée dès le début d’un projet basé sur un thème du marché, même s’il reste vide au départ.

Créer un thème enfant WordPress pas à pas (thème classique)

La méthode manuelle prend une dizaine de minutes et ne demande qu’un éditeur de code et un accès aux fichiers du site (SFTP ou gestionnaire de fichiers de l’hébergeur). En résumé :

1. Repérer le nom exact du dossier du thème parent.
2. Créer le dossier du thème enfant dans wp-content/themes.
3. Écrire le fichier style.css et son en-tête.
4. Charger les feuilles de style depuis functions.php.
5. Ajouter une capture d’écran (facultatif).
6. Installer et activer le thème enfant, après avoir noté vos réglages.

Étape 1 : repérer le dossier du thème parent

Ouvrez wp-content/themes et notez le nom du dossier du parent, tel qu’il est écrit : twentytwentyfive, astra, Avada… Ce n’est pas forcément le nom affiché dans l’administration, et la casse compte sur la plupart des serveurs. Avant de commencer, faites une sauvegarde complète et travaillez de préférence sur une copie de préproduction du site.

Étape 2 : créer le dossier du thème enfant

Créez un dossier à côté de celui du parent, avec un nom en minuscules et des tirets, sans espace ni accent : par exemple mon-theme-enfant ou astra-child.

Étape 3 : le fichier style.css et son en-tête

Dans ce dossier, créez un fichier style.css qui commence par ce commentaire d’en-tête :

/*
Theme Name:  Mon thème enfant
Theme URI:   https://example.com/
Description: Thème enfant de Nom du thème parent.
Author:      Votre nom
Author URI:  https://example.com/
Template:    nomduparent
Version:     1.0.0
Text Domain: mon-theme-enfant
License:     GNU General Public License v2 or later
License URI: https://www.gnu.org/licenses/gpl-2.0.html
*/

/* Vos règles CSS commencent ici. */

• Theme Name (obligatoire) : le nom affiché dans Apparence > Thèmes.
• Template (obligatoire pour un thème enfant) : le nom exact du dossier du parent, relevé à l’étape 1. C’est la ligne qui transforme un thème ordinaire en thème enfant.
• Version : à augmenter à chaque modification ; elle servira à vider le cache des navigateurs.
• Text Domain : l’identifiant des traductions de l’enfant, en général le nom de son dossier. C’est une valeur simple, sans commentaire ni espace.

Les autres champs sont facultatifs. Vous pouvez aussi ajouter Requires at least et Requires PHP pour indiquer les versions minimales de WordPress et de PHP (WordPress 7.1 fonctionne encore à partir de PHP 7.4, mais wordpress.org recommande PHP 8.3 ou plus) ; la liste complète figure dans la documentation de la feuille de style principale.

Étape 4 : le fichier functions.php qui charge les feuilles de style

Le CSS du thème enfant n’est pas appliqué automatiquement : tout dépend de ce que fait déjà le parent. Oubliez la vieille méthode @import dans le style.css : elle bloque le rendu et charge les feuilles l’une après l’autre. On utilise wp_enqueue_style() dans un fichier functions.php, et il faut d’abord vérifier, dans le code source de la page (Ctrl+U), quelles balises <link rel="stylesheet"> le parent ajoute. Trois cas se présentent :

• Le parent charge déjà les deux feuilles (la sienne et celle du thème actif) : vous n’avez rien à faire.
• Le parent ne charge que sa propre feuille : c’est le cas le plus courant aujourd’hui. Vous chargez celle de l’enfant, avec celle du parent en dépendance pour qu’elle passe après.
• Le parent charge la feuille du thème actif avec get_stylesheet_uri() : c’est alors celle de l’enfant qui est chargée, et c’est la feuille du parent qu’il faut ajouter.

Pour le cas le plus courant, créez functions.php dans le dossier de l’enfant :

<?php
/**
 * Fonctions du thème enfant « Mon thème enfant ».
 *
 * @package mon-theme-enfant
 */

defined( 'ABSPATH' ) || exit;

/**
 * Charge la feuille de style du thème enfant après celle du parent.
 */
function mon_theme_enfant_enqueue_styles() {
	wp_enqueue_style(
		'mon-theme-enfant-style',
		get_stylesheet_uri(),
		array( 'nomduparent-style' ), // Handle de la feuille du parent : à adapter.
		wp_get_theme()->get( 'Version' )
	);
}
add_action( 'wp_enqueue_scripts', 'mon_theme_enfant_enqueue_styles' );

Remplacez nomduparent-style par le « handle » de la feuille du parent : c’est l’attribut id de sa balise <link>, sans le suffixe -css. Pour Twenty Twenty-Five, par exemple, id="twentytwentyfive-style-css" donne le handle twentytwentyfive-style. Le préfixe mon_theme_enfant_ évite tout conflit de nom avec le parent ou une extension, et la ligne defined( 'ABSPATH' ) empêche l’appel direct du fichier.

Dans le troisième cas, ajoutez plutôt la feuille du parent, avec la priorité 5 (au lieu de 10 par défaut) pour qu’elle soit ajoutée en premier :

/**
 * Cas où le parent charge la feuille du thème actif (get_stylesheet_uri()) :
 * on ajoute celle du parent, plus tôt, avec la version du parent.
 */
function mon_theme_enfant_enqueue_parent_style() {
	$parent = wp_get_theme()->parent();

	wp_enqueue_style(
		'mon-theme-enfant-parent-style',
		get_parent_theme_file_uri( 'style.css' ),
		array(),
		$parent ? $parent->get( 'Version' ) : null
	);
}
add_action( 'wp_enqueue_scripts', 'mon_theme_enfant_enqueue_parent_style', 5 );

La version passée en quatrième argument est celle de l’en-tête du style.css : en l’augmentant, vous forcez les navigateurs à télécharger la nouvelle feuille. Pour ne plus y penser, vous pouvez aussi utiliser filemtime( get_stylesheet_directory() . '/style.css' ) : la version change alors à chaque enregistrement du fichier. C’est ce que j’utilise sur le thème enfant de ce site. Pas de balise ?> à la fin du fichier : elle ne sert à rien et expose à l’erreur « headers already sent ». Pour aller plus loin sur les dépendances et le chargement différé, mon article explique comment charger correctement scripts et styles avec wp_enqueue_style.

Étape 5 : ajouter une capture d’écran

Une image nommée screenshot.png (ou .jpg, .webp…) placée à la racine du thème enfant s’affiche dans Apparence > Thèmes. Le format recommandé est 1 200 × 900 pixels. C’est facultatif, mais pratique pour distinguer l’enfant du parent dans la liste.

Étape 6 : installer et activer le thème enfant

Si vous avez créé le dossier directement sur le serveur, le thème apparaît déjà dans Apparence > Thèmes. Sinon, compressez le dossier en zip, puis passez par Apparence > Thèmes > Ajouter un thème > Téléverser un thème. Le thème parent doit rester installé : il n’est simplement plus le thème actif. Pour un thème classique, l’aperçu en direct permet de vérifier le rendu avant de cliquer sur Activer.

Avant d’activer, notez vos réglages. WordPress enregistre les réglages de l’outil de personnalisation (logo, couleurs, image d’en-tête…) et le CSS additionnel séparément pour chaque thème : le thème enfant démarre sans eux, et il faut les refaire. Les emplacements de menus et les widgets sont, eux, réaffectés automatiquement dans la plupart des cas, mais vérifiez-les. Vos contenus (pages, articles, médias, produits) ne changent pas.

Personnaliser son thème enfant

Ajouter du CSS

Écrivez vos règles sous l’en-tête du style.css de l’enfant. Comme sa feuille est chargée après celle du parent, une règle de même spécificité l’emporte. Si une règle ne s’applique pas, rendez le sélecteur plus précis plutôt que d’empiler des !important, qui rendent le CSS impossible à maintenir.

Surcharger un fichier de modèle

Copiez le fichier du parent dans le thème enfant en respectant le même chemin (footer.php à la racine, template-parts/content.php dans un sous-dossier template-parts…), puis modifiez la copie. Vous pouvez aussi ajouter des modèles qui n’existent pas chez le parent, en suivant la hiérarchie des modèles.

Le revers : la copie est figée. Si le parent corrige un bug ou une faille dans ce fichier, votre version ne reçoit pas le correctif. Je limite donc les surcharges au strict nécessaire, je préfère un hook ou un filtre quand le parent en propose un, et je compare les fichiers surchargés avec ceux du parent après chaque mise à jour majeure.

Modifier une fonction du parent depuis functions.php

Ne copiez jamais le functions.php du parent dans l’enfant : les deux étant chargés, vous obtiendriez une erreur fatale « Cannot redeclare ». Deux techniques propres existent :

• Les fonctions « enfichables » : si le parent entoure une fonction d’un test if ( ! function_exists( 'nom_de_la_fonction' ) ), déclarez une fonction du même nom dans l’enfant. Elle est chargée en premier, et le parent ne déclare plus la sienne.
• Les hooks : retirez l’action ou le filtre du parent avec remove_action() ou remove_filter(), avec le même hook et la même priorité, puis ajoutez la vôtre. Comme le parent n’est pas encore chargé quand le functions.php de l’enfant s’exécute, faites-le sur le hook after_setup_theme.

/**
 * Remplace les crédits du pied de page ajoutés par le parent.
 * Le functions.php du parent n'est pas encore chargé quand celui-ci s'exécute :
 * on attend donc le hook after_setup_theme pour retirer son action.
 */
function mon_theme_enfant_remplacer_credits() {
	remove_action( 'nomduparent_footer', 'nomduparent_credits', 10 );
	add_action( 'nomduparent_footer', 'mon_theme_enfant_credits' );
}
add_action( 'after_setup_theme', 'mon_theme_enfant_remplacer_credits', 20 );

/**
 * Affiche les nouveaux crédits.
 */
function mon_theme_enfant_credits() {
	printf(
		'<p class="site-credits">%s</p>',
		esc_html__( 'Site réalisé avec WordPress.', 'mon-theme-enfant' )
	);
}

Les noms nomduparent_footer et nomduparent_credits sont à remplacer par ceux que vous trouverez dans le code du parent.

Ce qu’il ne faut pas mettre dans un thème enfant

Un thème gère l’apparence. Tout ce qui doit survivre à un changement de thème a sa place dans une extension : types de contenu et taxonomies, shortcodes, intégrations avec un CRM ou une API, règles métier d’une boutique WooCommerce, codes de suivi. Placé dans le thème enfant, ce code disparaît le jour où vous changez de thème, et les contenus qui en dépendent deviennent inaccessibles. Pour quelques lignes, une petite extension maison ou un « mu-plugin » suffit ; pour une vraie fonctionnalité, il vaut mieux développer une extension sur mesure. Le même principe s’applique aux extensions elles-mêmes : voyez comment modifier une extension sans perdre ses changements.

Thème enfant d’un thème de blocs (Twenty Twenty-Five et autres)

Les thèmes de blocs, comme Twenty Twenty-Five, se personnalisent dans l’éditeur de site et décrivent leurs réglages dans un fichier theme.json. Le principe du thème enfant est le même, mais les fichiers changent un peu.

style.css et theme.json : le minimum

Le style.css reste obligatoire, avec la ligne Template :

/*
Theme Name:        Mon enfant de Twenty Twenty-Five
Template:          twentytwentyfive
Version:           1.0.0
Requires at least: 6.7
Text Domain:       mon-enfant-tt5
License:           GNU General Public License v2 or later
License URI:       https://www.gnu.org/licenses/gpl-2.0.html
*/

Ajoutez ensuite un theme.json qui ne déclare que ce qui change : WordPress le fusionne avec celui du parent. Cet exemple élargit la colonne de contenu et utilise l’une des couleurs de la palette de Twenty Twenty-Five pour les liens :

{
	"$schema": "https://schemas.wp.org/trunk/theme.json",
	"version": 3,
	"settings": {
		"layout": {
			"contentSize": "720px"
		}
	},
	"styles": {
		"elements": {
			"link": {
				"color": {
					"text": "var:preset|color|accent-3"
				}
			}
		}
	}
}

Un piège à connaître : les listes de préréglages (palette de couleurs, tailles de police…) ne sont pas fusionnées couleur par couleur. Une palette déclarée dans l’enfant remplace entièrement celle du parent : redéclarez toutes les couleurs dont vous avez besoin.

Pour un thème enfant de blocs, le functions.php est souvent inutile, car le style passe par theme.json. Si vous voulez tout de même du CSS dans le style.css de l’enfant, chargez-le comme à l’étape 4, avec twentytwentyfive-style en dépendance. Le détail des réglages se trouve dans la documentation de theme.json.

Surcharger les modèles, les parties et les compositions

Un fichier templates/single.html ou parts/footer.html dans l’enfant remplace celui du parent ; une composition (pattern) est remplacée si elle porte le même slug. Attention : les modifications faites dans l’éditeur de site sont enregistrées en base de données, rattachées au thème actif, et prennent le pas sur les fichiers. Celles que vous aviez faites sur le parent ne suivent pas quand vous activez l’enfant, et un fichier modifié dans l’enfant n’apparaît pas si le modèle a déjà été personnalisé dans l’éditeur : il faut alors réinitialiser ce modèle.

Créer le thème enfant avec Create Block Theme

Pour un thème de blocs, l’extension Create Block Theme, publiée par l’équipe de WordPress.org et toujours maintenue (dernière mise à jour le 1^er octobre 2026), crée le thème enfant à votre place. Activez le thème parent, installez l’extension, ouvrez l’éditeur de site, puis le menu Create Block Theme (l’icône à droite du bouton Enregistrer) et choisissez la création d’un thème enfant. Les modifications déjà faites dans l’éditeur sont reprises dans le nouveau thème, que vous pouvez aussi exporter en zip. C’est un outil de développement : utilisez-le sur une copie du site, puis désactivez-le.

Le cas d’Avada (et d’Elementor)

Avada : utiliser le thème enfant fourni

Avada est livré avec son thème enfant. Dans votre compte ThemeForest, téléchargez le paquet complet (« All files & documentation ») : il contient le thème Avada et un thème enfant prêt à l’emploi. Installez d’abord Avada, puis le thème enfant, et activez ce dernier. Son style.css indique Template: Avada, avec un A majuscule, comme le dossier du thème.

Les options globales d’Avada sont enregistrées dans une option de WordPress qui ne dépend pas du thème actif. Elles restent en place quand vous passez au thème enfant, tout comme vos mises en page Avada Builder, qui font partie du contenu.

Avada charge ses propres feuilles de style mais pas celle de l’enfant. Le functions.php d’origine s’en charge, avec une fonction au nom très générique (theme_enqueue_styles) et sans numéro de version. Voici la version que je recommande pour cette partie ; le reste du fichier d’origine (chargement des traductions depuis le dossier languages de l’enfant) peut être conservé :

<?php
/**
 * Fonctions du thème enfant d'Avada.
 *
 * @package mon-avada-child
 */

defined( 'ABSPATH' ) || exit;

/**
 * Charge le style.css du thème enfant après la feuille principale d'Avada.
 */
function mon_avada_child_enqueue_styles() {
	wp_enqueue_style(
		'mon-avada-child-style',
		get_stylesheet_uri(),
		array(),
		wp_get_theme()->get( 'Version' )
	);
}
add_action( 'wp_enqueue_scripts', 'mon_avada_child_enqueue_styles', 20 );

Un point propre à Avada : sa feuille compilée (styles des options globales et des éléments) est ajoutée après celle de l’enfant. À spécificité égale, c’est donc la règle d’Avada qui l’emporte : rendez vos sélecteurs plus précis plutôt que d’ajouter des !important.

Sur un site Avada, le thème enfant sert surtout au CSS qui dépasse le champ « CSS personnalisée » (Custom CSS) des options globales, aux fonctions PHP branchées sur les nombreux hooks et filtres d’Avada, et plus rarement à la surcharge de modèles : les mises en page d’Avada Builder couvrent la plupart des besoins sans toucher aux fichiers. Si vous hésitez sur ce thème, lisez mon avis sur le thème Avada ; pour un site existant, je propose aussi la mise à jour et la personnalisation d’un site Avada.

Elementor : un thème enfant pour Hello Elementor

Avec Elementor, les pages construites dans l’éditeur sont enregistrées dans le contenu, pas dans le thème. Un thème enfant n’est donc utile que si vous ajoutez du PHP, des modèles ou du CSS en dehors du constructeur. Pour le thème Hello Elementor, Elementor publie un thème enfant officiel sur GitHub, à installer et activer comme n’importe quel autre.

Thème enfant qui ne fonctionne pas : les erreurs fréquentes

• « Le thème parent est manquant » : la ligne Template ne correspond pas au nom du dossier du parent (faute de frappe, casse), ou le parent n’est pas installé.
• Le CSS de l’enfant ne s’applique pas : la feuille n’est pas chargée (vérifiez le code source), ou le handle mis en dépendance n’existe pas. Dans ce dernier cas, WordPress ne charge pas du tout la feuille de l’enfant (depuis WordPress 6.9.1, un avertissement le signale en mode débogage). Sinon, c’est souvent le cache : videz celui de votre extension de cache et du navigateur, et augmentez la Version.
• La feuille du parent est chargée deux fois : vous l’avez ajoutée alors que le parent la chargeait déjà. Retirez votre wp_enqueue_style() pour le parent.
• Erreur fatale « Cannot redeclare … » : une fonction du parent a été copiée dans l’enfant, ou deux fonctions portent le même nom générique. Préfixez toutes vos fonctions.
• « Il y a eu une erreur critique sur ce site » après une modification de functions.php : il s’agit le plus souvent d’une erreur de syntaxe. Corrigez ou renommez le fichier par SFTP, ou utilisez le lien du mode de récupération que WordPress envoie à l’adresse de l’administrateur. Le journal de débogage indique la ligne fautive.
• « Cannot modify header information – headers already sent » : un espace ou une ligne vide avant <?php ou après un ?> final. Supprimez la balise de fermeture.

Quand le thème enfant ne suffit plus

Un thème enfant qui surcharge la plupart des modèles du parent, désactive la moitié de ses fonctions et contourne ses choix de conception devient difficile à maintenir : chaque mise à jour du parent est une source de surprise. La documentation officielle le dit elle-même : pour des personnalisations très étendues, mieux vaut un thème à soi. Pour comparer les solutions, consultez mon guide pour choisir un thème WordPress, gratuit, premium ou sur mesure. Et si votre projet le justifie, vous pouvez faire développer un thème WordPress sur mesure, conçu pour votre site et rien d’autre.

Questions fréquentes sur le thème enfant WordPress

Votre thème enfant a pris l’ampleur d’un thème complet, ou vous préférez qu’un développeur s’en occupe ? Parlez-moi de votre projet.

Pour aller plus loin : la documentation des thèmes enfants sur developer.wordpress.org (en anglais) et, pour les thèmes classiques, la vidéo « Créer un thème WordPress : Chapitre 29, Thème enfant » de Grafikart, publiée en 2020 et toujours valable sur le principe.

Mis à jour en octobre 2026 par un développeur WordPress freelance senior.