Réponse courte : après une mise à jour de Rust, vérifie d'abord le framework réellement en cours d'exécution. Sous Oxide, oxide.version, oxide.plugins et le log de démarrage t'aident à y voir clair. S'il ne manque qu'un seul plugin, distingue une erreur de compilation, une dépendance manquante et une erreur de configuration. Des plugins chargés n'excluent pas une erreur du framework. Sauvegarde les fichiers et la partie avant toute modification ; un wipe ou la suppression de toutes les configs n'est pas une première étape de diagnostic judicieuse.

Ce guide s'applique aux Rust Dedicated Servers de la version PC, auto-hébergés ou chez n'importe quel hébergeur. Pour les étapes d'administration, tu as besoin d'un accès à la véritable console du serveur ou à un RCON autorisé et, le cas échéant, aux fichiers du serveur. Un compte client chez SupremeTier n'est pas nécessaire. Si tu joues simplement sur le serveur concerné, commence par la section suivante.

État au 6 novembre 2026 ; nos propres tests d'erreurs : 29 octobre 2026. Les commandes de la procédure principale concernent Oxide. Carbon est traité séparément. Les scénarios d'erreur « un seul plugin ne compile pas » et « une dépendance manque » ont été déclenchés de manière contrôlée puis réparés sur notre propre serveur de test isolé. Ces tests simulent des états d'erreur ; ils ne constituent pas l'observation d'un plugin tiers tombé en panne après la mise à jour. Un état volontairement incohérent du framework a également été testé de façon isolée. Des plugins se chargeaient alors qu'un hook du framework échouait. Les sorties originales ci-après proviennent de tests d'erreurs contrôlés et ne sont pas présentées comme un incident réel survenu sur un serveur client.

En tant que joueur : que peux-tu faire ?

La disparition du menu /kit ne prouve pas que ton inventaire a été supprimé. Il manque peut-être seulement le plugin qui fournit la commande. Demande d'abord si d'autres joueurs constatent l'absence de la même fonction et si plusieurs fonctions indépendantes les unes des autres sont touchées. Note l'heure, la commande saisie et la réponse affichée. Une capture d'écran du message est utile ; tu peux masquer les noms de joueurs privés avant de la transmettre.

Tu peux par exemple signaler : « Depuis le redémarrage vers 19 h, ma commande de kit ne renvoie aucune réponse. La téléportation ne fonctionne pas non plus. La construction normale fonctionne. Avant le redémarrage, les deux marchaient. » L'administration peut ainsi rechercher précisément le démarrage correspondant. Affirmer « Tout a été wipé » sans vérification irait trop loin.

N'installe pas de fichiers client proposés au hasard comme prétendue réparation d'un plugin serveur. En tant que joueur, tu ne peux pas recharger le framework côté serveur. Si des fonctions de protection manquent, par exemple les règles PvE promises sur ce serveur, ne compte pas dessus tant que la situation n'est pas clarifiée. C'est à l'administration de décider si l'on peut continuer à jouer normalement en toute sécurité.

Commence par distinguer les trois niveaux

Pour ce diagnostic, un serveur Rust moddé se compose de trois niveaux. Rust lui-même fournit le monde et les mécaniques de jeu. Le framework, ici Oxide ou, en alternative, Carbon, rend les extensions possibles. Les plugins individuels mettent en œuvre par exemple des kits, la téléportation, des fonctions d'administration ou des modifications des règles du jeu. Certains plugins nécessitent d'autres plugins ou des extensions.

Si un niveau inférieur manque, de nombreuses fonctions situées au-dessus semblent cassées en même temps. Si une seule extension tombe en panne, les autres peuvent continuer à fonctionner. Cette distinction est le point de départ, mais pas encore une preuve : plusieurs plugins peuvent aussi dépendre de la même bibliothèque manquante. À l'inverse, un framework peut répondre et rencontrer malgré tout des problèmes lors de certains événements de jeu.

« Fichier présent », « compilé », « chargé » et « fonctionnel » sont quatre états différents. Un fichier .cs dans le bon dossier prouve seulement que du code source s'y trouve. Compiler signifie qu'un code exécutable en a été généré. Le chargement inclut l'initialisation. Seul un test ciblé de la fonction montre si le comportement souhaité fonctionne réellement avec tes paramètres et tes permissions.

La documentation officielle d'Oxide sur l'installation des plugins décrit les fichiers .cs, la compilation automatique et le répertoire des plugins. Ne confonds pas ce niveau des fichiers avec un résultat visible en jeu.

Le parcours de décision rapide

Une fois le démarrage du serveur terminé, commence dans la console du serveur, pas dans le chat normal du jeu. Cette première vérification ne modifie aucun plugin :

oxide.version
oxide.plugins

oxide.version interroge la version du framework. oxide.plugins liste les plugins, y compris les tentatives de chargement qui ont échoué. La référence officielle des commandes décrit la liste des plugins et les commandes de chargement ciblées ; le guide des propriétaires sur les commandes explique la console et le chat.

Observation
Première hypothèse de travail
Vérification suivante
Oxide ne répond pas, de nombreuses fonctions manquent
Framework absent, qui ne démarre pas, ou mauvais contexte de console
Vérifier le journal de démarrage, le framework réellement sélectionné et l'installation
Oxide répond, plusieurs plugins tournent, un seul échoue
Problème de ce plugin ou de ses prérequis
Lire le premier message d'erreur complet et la version du plugin
Plusieurs plugins concernés citent la même dépendance
Panne d'une dépendance commune
Examiner d'abord cette dépendance
Le plugin est chargé, seule une fonction manque
Permissions, paramètres, hook ou problème d'exécution
Tester la fonction concernée dans des conditions contrôlées
Nouvelles configs, autre monde ou données apparemment vides
Peut-être une autre instance du serveur ou un autre chemin de données
Comparer l'identité, les paramètres de démarrage et les montages avec l'état précédent

Une commande inconnue est un indice, pas un diagnostic définitif. Vérifie que tu as bien ouvert la console du serveur concerné, que le démarrage est terminé et que ce serveur utilise bien Oxide. Avec Carbon, un test propre à Oxide ne constitue pas à lui seul une base suffisante.

Avant toute réparation : conserve les preuves et assure un retour en arrière

Un bon diagnostic commence par un bref état des lieux. Note quand l'erreur a été remarquée pour la première fois, quelle mise à jour du jeu ou quel redémarrage l'a précédée et ce qui a déjà été modifié depuis. Sauvegarde le log de démarrage en un seul bloc, du lancement du processus jusqu'au premier message d'erreur. Une capture d'écran de la dernière ligne rouge ne suffit souvent pas, car elle ne montre que l'erreur consécutive.

Oxide écrit en plus les erreurs de chargement et de compilation dans ses propres fichiers de log, dans le dossier oxide/logs de ton installation serveur. Le message y est souvent plus complet que dans la partie visible de la console, par exemple lorsque celle-ci n'affiche que les dernières lignes. Choisis le fichier dont la date correspond au démarrage concerné et sauvegarde-le avec le log de la console.

Note la version de Rust ou les informations de build, la branche de release utilisée, le système d'exploitation, la version du framework et les versions des plugins concernés. Conserve la source de téléchargement des fichiers installés. « Dernière version » n'est pas une indication de version reproductible : le fichier a pu être remplacé depuis ton téléchargement, ou ton script de démarrage peut charger une autre version que celle attendue.

Que faut-il inclure dans la sauvegarde ?

Sauvegarde un état cohérent des données du monde et des joueurs, de la configuration de démarrage et des fichiers de modding. Avec Oxide, oxide/plugins, oxide/config et oxide/data font notamment partie de l'inventaire ; pense aussi aux données de permissions et à tes propres extensions. La structure de stockage exacte dépend de l'installation. Vérifie les chemins que tu utilises réellement au lieu de reprendre aveuglément un répertoire d'exemple.

Distingue les paramètres des données d'utilisation. Une config détermine par exemple le comportement d'un plugin ; ses données peuvent contenir des récompenses déjà attribuées, des positions enregistrées ou d'autres états permanents. Le contenu dépend du plugin. Vider oxide/data sans discernement peut donc modifier bien plus que la fonction défectueuse.

Pour obtenir une sauvegarde cohérente, suis la procédure de sauvegarde documentée de ton installation. Une copie réalisée pendant des écritures en cours peut être incohérente. Vérifie que la sauvegarde est réellement terminée et récupérable. Décompresse-la ou contrôle-la dans un emplacement séparé, sans écraser le serveur actuel. Le simple affichage du nom d'une sauvegarde ne constitue pas encore un retour en arrière vérifié.

Définis les limites de ton intervention

Avant d'intervenir, écris : « Je remplace uniquement ce fichier de plugin » ou « Je réinstalle le paquet Oxide correspondant à la version actuelle de Rust ». Note aussi l'ancien fichier sauvegardé, le nouveau fichier et le critère de réussite. Ne modifie pas en même temps le framework, plusieurs plugins, les configs et les paramètres de la map. Sinon, tu ne sauras pas ensuite quelle intervention a aidé ou causé des dégâts.

Si un plugin de protection, d'économie ou de gestion des accès tombe en panne, décide de la disponibilité du serveur avant de lancer le test. Un monde techniquement accessible n'est pas forcément jouable selon les règles promises. Annonce toute interruption nécessaire et utilise la procédure d'arrêt normale de ton installation. Des arrêts brutaux à répétition ne remplacent pas un diagnostic.

Cas A : le framework tombe en panne

Configuration typique : le serveur démarre après une mise à jour du jeu, mais de nombreuses fonctions de plugins sans lien entre elles manquent. Le log de démarrage actuel ne montre pas qu'Oxide s'est chargé correctement, ou la commande de version, exécutée dans le bon contexte de console, ne renvoie aucune version du framework.

La cause à vérifier ne se limite pas à « Oxide trop ancien ». La mise à jour du jeu peut remplacer des fichiers modifiés ; un script de démarrage peut ensuite restaurer les fichiers Vanilla ; le framework peut avoir été décompressé dans le mauvais répertoire du serveur. Un paquet destiné au mauvais système d'exploitation, une branche de jeu inadaptée ou un upload incomplet sont également possibles.

Dans son guide sur le serveur dédié, Facepunch indique expressément qu'une mise à jour du jeu peut nécessiter une réinstallation d'Oxide et que SteamCMD peut rétablir les fichiers Vanilla lors de la séquence de démarrage. L'ordre à respecter est donc essentiel : mettre à jour le jeu, installer la version correspondante du framework, puis démarrer le serveur. Une nouvelle synchronisation des fichiers du jeu après l'installation du framework peut réduire ce travail à néant.

Ordre à suivre en auto-hébergement

Sur un serveur auto-hébergé avec SteamCMD, l'ordre est le suivant. Le chemin n'est qu'un exemple ; remplace-le par le répertoire réel de ton serveur :

steamcmd +force_install_dir /pfad/zum/rustserver +login anonymous +app_update 258550 validate +quit

258550 est l'App ID du Rust Dedicated Server. validate vérifie les fichiers du jeu et rétablit au passage la version Vanilla. C'est précisément pour cette raison qu'Oxide vient seulement après : télécharge depuis la release officielle d'Oxide.Rust l'archive correspondant à ton système d'exploitation, Oxide.Rust-linux.zip pour Linux ou Oxide.Rust.zip pour Windows. Décompresse-la en conservant sa structure de dossiers dans le répertoire principal du serveur, c'est-à-dire là où se trouve RustDedicated ou RustDedicated.exe, et laisse les fichiers existants être écrasés. Ne démarre le serveur qu'ensuite, puis vérifie oxide.version.

Si ton script de démarrage appelle SteamCMD avant chaque lancement, il remplace de nouveau les fichiers d'Oxide à chaque redémarrage. Dans ce cas, intègre aussi l'installation d'Oxide au script de démarrage, entre la mise à jour et le lancement du serveur, ou retire la mise à jour automatique du script. En hébergement managé, utilise plutôt la fonction de framework de ton hébergeur.

Distinguer la release actuelle de la combinaison testée historiquement

Lors de notre vérification des releases du 6 novembre 2026, la release officielle Oxide.Rust 2.0.7894 était la plus récente publiée. Elle a été publiée le 6 novembre 2026 à 10:11:56 UTC et mentionne le premier hotfix Rust de ce jour pour 2636.290.1. Cette indication concerne Rust et n'est pas un numéro de version du paquet Oxide. Cette actualisation atteste uniquement la publication de la release, et non un test fonctionnel de notre part avec la nouvelle combinaison.

Nos propres tests d'erreur restent ceux du 29 octobre 2026 : le changelog uMod pour Rust indique 2635.289.1 pour la mise à jour du 22 octobre ; la release officielle Oxide.Rust 2.0.7839 correspondante a été publiée le 22 octobre 2026 à 18:02:03 UTC. Sur notre serveur de test isolé, version et oxide.version ont effectivement renvoyé le protocole Rust 2635.289.1 et Oxide.Rust 2.0.7839. Il s'agit d'une combinaison testée à un moment donné, et non d'une recommandation de conserver ces numéros après les mises à jour suivantes.

Au moment d'intervenir, vérifie de nouveau la release actuelle et la version de Rust de ton serveur. L'existence d'une note de release correspondante ne prouve pas que ton hébergeur ou ton script de démarrage a déjà installé cette version. Ce qui compte, c'est la version lue ensuite depuis l'instance en cours d'exécution, associée au log de démarrage actuel.

Notre test A : erreur de framework malgré des plugins chargés

Notre point de départ était le protocole Rust 2635.289.1 avec la version correspondante d'Oxide.Rust 2.0.7839. Après un arrêt normal et une sauvegarde de notre monde de test et du répertoire Oxide, nous avons volontairement installé, uniquement sur le serveur de test isolé, l'ancienne Oxide.Rust.dll issue de la release officielle 2.0.7072 du 19 février 2026. Le reste de l'installation actuelle est resté en place. Cela simule un état mixte et incohérent du framework ; il ne s'agit pas d'un test d'un paquet serveur historique complet.

La modification a été vérifiée grâce au SHA-256 de la DLL réellement installée. Au démarrage, ce message réel est apparu :

Failed to call hook 'IOnServerCommand' on plugin 'RustCore v2.0.7072' (MissingFieldException: Field not found: string .Arg.FullString Due to: Could not find field in class)

Dans le même temps, nos plugins de test ont atteint leurs marqueurs d'initialisation. Le processus du serveur a lui aussi continué de tourner. C'est la différence importante avec une règle empirique trop simple : un problème de framework n'empêche pas forcément tous les plugins de se charger. Une liste de plugins correcte ou un processus en cours d'exécution ne constitue pas une vérification complète de la compatibilité.

Le message désigne RustCore, donc un composant du framework, ainsi qu'un accès à un champ introuvable. Il ne s'agit pas d'une erreur JSON dans une configuration de kit. Dans cette combinaison créée délibérément, la cause réside dans l'incohérence de l'état du framework. Le même type d'erreur associé à un autre nom peut en revanche provenir d'un plugin isolé ; lis toujours ensemble le composant, le hook et le contexte.

Pour annuler le changement au minimum, nous avons restauré la DLL 2.0.7839 correspondante, épinglée au préalable, puis redémarré de manière contrôlée. Ensuite, oxide.version a de nouveau répondu 2.0.7839, oxide.plugins a listé nos quatre plugins de test et la MissingFieldException observée auparavant n'apparaissait plus dans le nouveau tampon de console disponible. Le retour au framework correspondant est donc vérifié pour ce test précis. Pour ton serveur de production, cela ne signifie pas qu'il est recommandé de copier des DLL isolées depuis des archives quelconques : utilise la procédure d'installation complète du framework correspondant afin de garantir un état cohérent.

Ce test utilise volontairement une release nettement plus ancienne. Il ne prétend ni que toute version antérieure échoue de la même manière, ni que ce tableau d'erreur précis apparaît à chaque mise à jour d'octobre. Une panne de framework peut aussi simplement signifier un serveur Vanilla sans Oxide chargé. C'est pourquoi il reste nécessaire de combiner la version réelle, le premier diagnostic du log et un test fonctionnel.

Réparation minimale

  1. Sauvegarde l'état initial et le log. Vérifie si un programme de mise à jour automatique est en cours d'exécution. Ne lance pas une seconde installation concurrente.
  2. Compare la version de Rust, la branche de release, le système d'exploitation et la release du framework prévue pour cette configuration.
  3. Arrête le serveur normalement si l'installation nécessite de modifier les fichiers du framework.
  4. Suis la procédure d'installation documentée. En auto-hébergement, décompresse l'archive fiable et compatible dans la bonne installation en conservant sa structure de répertoires, dans l'ordre décrit plus haut. En hébergement managé, utilise la fonction de framework prévue ; ne transpose pas à ton hébergeur les menus du panel d'un autre.
  5. Contrôle l'ordre des mises à jour et effectue un seul démarrage contrôlé. Lis le nouveau log de démarrage.
  6. Vérifie la version du framework, la liste des plugins et au moins une fonction qui ne marchait plus.

Réussite : le framework attendu répond depuis la bonne instance, les plugins attendus se chargent et la fonction vérifiée marche. Retour en arrière : conserve l'état antérieur à l'intervention. Ne réinstalle pas à l'aveugle un ancien fichier de framework sur une version récente du jeu. Si seul un ancien paquet complet était compatible, il faut vérifier séparément qu'il peut être restauré, y compris le format du monde et la compatibilité des clients. Si ce point reste incertain, le serveur demeure hors service de manière contrôlée jusqu'à ce qu'une version compatible soit disponible.

Cas B : un plugin ne compile pas

Configuration typique : Oxide répond, d'autres plugins se chargent, mais un plugin précis apparaît en échec. Le log indique une erreur de compilation, souvent avec le fichier, la ligne, la colonne et un symbole manquant ou une méthode devenue incompatible.

Une erreur de compilation signifie d'abord une seule chose : le code source présent ne peut pas être compilé avec les références disponibles. Une mise à jour du jeu a pu modifier une interface utilisée. Mais il peut aussi s'agir d'un téléchargement corrompu, de ton propre code modifié ou d'une dépendance stricte manquante. « Failed to compile » ne veut donc pas automatiquement dire « l'auteur n'a qu'à publier une nouvelle version ».

Notre test B : une erreur de compilation

Sur notre serveur de test isolé, avec le protocole Rust 2635.289.1 et Oxide.Rust 2.0.7839, seul le plugin de test Guide7CompileBroken.cs contenait une ligne #error volontaire. Le plugin témoin Guide7Probe, déjà chargé, n'était pas concerné. Voici la véritable sortie de la console :

Error while compiling Guide7CompileBroken: #error: 'GUIDE7_INTENTIONAL_COMPILE_FAILURE' | Line: 1, Pos: 8

Pour la réparation minimale, nous avons uniquement retiré la ligne d'erreur insérée volontairement. La console a ensuite affiché :

Guide7CompileBroken was compiled successfully in 362ms
Loaded plugin Guide7CompileBroken v1.0.0 by Guide7 isolated test fixture

Pour revenir en arrière dans ce test contrôlé, il suffit de restaurer le fichier d'erreur d'origine, ce qui reproduirait la même erreur de compilation volontaire. Pour un véritable plugin tiers, « supprimer une ligne au hasard » n'est absolument pas une méthode de réparation. Notre test démontre la séparation entre le framework et le compilateur de plugins, et non une rupture d'API précise causée par la mise à jour d'octobre. Les 362 ms observées ne décrivent que ce test isolé, pas un temps de chargement général.

Dans le vrai log, dans la console ou dans oxide/logs, cherche d'abord le nom du fichier concerné et le premier diagnostic du compilateur. Un message ultérieur du type « le plugin n'a pas pu être chargé » ne fait souvent que répéter le résultat. Vérifie si plusieurs plugins citent exactement le même symbole manquant : dans ce cas, il peut s'agir d'un changement d'API ou d'une référence commune plutôt que de plusieurs défauts indépendants.

Télécharge une mise à jour uniquement depuis la source documentée du plugin. Lis les notes de version : corrigent-elles ton problème, exigent-elles une nouvelle dépendance ou modifient-elles le format des données ? Un numéro de version plus élevé ne garantit pas à lui seul la compatibilité avec ta combinaison.

Réparation minimale

Sauvegarde le fichier .cs actuel ainsi que la config et les données associées. Commence par remplacer uniquement le plugin concerné par la version corrigée prévue. Oxide surveille normalement les modifications dans le dossier des plugins : évite donc les envois en double et les rechargements supplémentaires précipités. Suis l'opération dans la console, puis vérifie la version réellement chargée.

Si un rechargement ciblé est nécessaire, la commande prend cette forme :

oxide.reload Pluginname

Pluginname désigne ici le véritable nom du fichier du plugin sans .cs, et non le titre commercial d'un téléchargement. La référence officielle des commandes documente ce rechargement ciblé. Pendant la recherche de la cause, n'utilise pas de rechargement global de tous les plugins avec un joker. Il modifie inutilement de nombreux états et peut provoquer de nouvelles erreurs.

Réussite : le diagnostic du compilateur disparaît, la version attendue du plugin est chargée et la fonction concernée passe le test. Retour en arrière : si la mise à jour échoue, sauvegarde aussi ce nouveau log. Ne restaure l'ancienne version du plugin, avec les données nécessaires, que si cette combinaison correspond à la version actuelle du jeu. Un ancien fichier déjà cassé après la mise à jour du jeu ne constitue pas un rollback fonctionnel.

S'il n'existe aucun correctif compatible, il peut être judicieux de désactiver temporairement le seul plugin concerné. Vérifie d'abord quels autres plugins et quelles règles de jeu en dépendent. Une fois le serveur arrêté normalement, déplace le fichier source sauvegardé hors du répertoire de plugins surveillé, vers un dossier de sauvegarde séparé. Ne supprime ni la config ni les données utilisateur. Note quelle fonction restera indisponible jusqu'à la réparation.

Cas C : une dépendance manque

Situation typique : un plugin signale un prérequis manquant. D'autres fonctions continuent de marcher, ou plusieurs plugins en panne dépendent de la même bibliothèque. Le fichier réclamé peut même être présent, mais ne pas réussir à se charger lui-même.

La directive d'Oxide sur les dépendances distingue les dépendances optionnelles, requises et strictes. Une intégration optionnelle étend le comportement. Un prérequis requis est nécessaire au fonctionnement. Une dépendance stricte peut empêcher dès la compilation. Ces notions expliquent pourquoi « dépendance manquante » et « erreur de compilation » peuvent se recouper.

Notre test C : une dépendance manquante

Sur le même serveur de test, notre plugin de test Guide7Consumer.cs a été chargé avec le prérequis déclaré // Requires: Guide7Dependency. La dépendance correspondante n'était volontairement pas installée au départ. Voici les véritables sorties de ce test contrôlé :

Guide7Consumer plugin requires missing dependency: Guide7Dependency
Ignored unexpected plugin compilation failure: Guide7Consumer
Error while compiling Guide7Consumer: Missing dependency: Guide7Dependency

On retrouve ici aussi « Error while compiling ». Mais l'élément décisif est la mention explicite de la dépendance manquante. Nous avons installé uniquement Guide7Dependency.cs, puis rechargé le plugin consommateur de manière ciblée. Les deux marqueurs d'initialisation et les deux confirmations de chargement sont alors apparus :

[Guide7Dependency] GUIDE7_DEPENDENCY_READY
Loaded plugin Guide7Dependency v1.0.0 by Guide7 isolated test fixture
[Guide7Consumer] GUIDE7_CONSUMER_READY
Loaded plugin Guide7Consumer v1.0.0 by Guide7 isolated test fixture

Ces marqueurs prouvent l'initialisation des deux plugins de test, et non le bon fonctionnement d'une boutique, d'une téléportation ou d'une protection d'un plugin tiers. Pour annuler ce test, il suffirait de décharger le plugin consommateur, puis de retirer uniquement notre dépendance. Recharger plusieurs fois le plugin consommateur n'installe pas pour autant son prérequis. Si, dans ton vrai log, c'est d'abord la dépendance elle-même qui échoue, corrige en priorité sa première erreur. Une bibliothèque au nom similaire provenant d'une source de téléchargement quelconque n'est pas un substitut.

Consulte la page du plugin et sa documentation pour connaître le nom exact, le type de dépendance et, le cas échéant, les versions exigées. Un autre plugin .cs et une extension compilée sont deux choses différentes. Ils peuvent avoir des emplacements d'installation et des exigences de redémarrage différents. Pour les extensions, suis leur propre guide d'installation ; ne copie pas une DLL dans oxide/plugins au petit bonheur.

Réparation minimale

Établis une petite chaîne : plugin concerné → prérequis nécessaire → état de ce prérequis. Vérifie le prérequis dans la liste des plugins et dans le log de démarrage. S'il manque réellement, installe exactement celui-ci depuis sa source officielle. S'il est déjà présent, corrige sa première erreur au lieu de renvoyer sans cesse le même fichier.

Pour une dépendance de plugin ordinaire, tu peux ensuite charger de manière ciblée d'abord le prérequis, puis le plugin consommateur, si leur documentation prend en charge cette procédure. Pour une extension ou une initialisation de démarrage modifiée, un redémarrage contrôlé peut être nécessaire. Considère un redémarrage comme une étape vérifiable avec un nouveau log, et non comme un remède automatique.

Réussite : le prérequis et le plugin consommateur se chargent dans les versions prévues, et la fonction qui les relie fonctionne. Une simple liste de deux plugins chargés ne suffit pas à le prouver. Retour en arrière : restaure la combinaison compatible sauvegardée ou désactive le plugin consommateur tant que son prérequis manque. Avant un downgrade, vérifie si la nouvelle version a déjà réécrit des configs ou des données.

Chargé, mais sans effet

Si un plugin apparaît comme chargé, passe du diagnostic d'installation au test fonctionnel. Vérifie d'abord que tu testes la bonne fonction avec le bon compte. Un admin peut avoir d'autres droits qu'un joueur ordinaire. Le résultat d'un seul essai en admin ne s'applique donc pas automatiquement à tous les joueurs.

Contrôle ensuite les permissions et les paramètres documentés. La fonction, le monde, la zone ou le groupe d'utilisateurs nécessaires sont-ils activés ? Existe-t-il des conditions comme un cooldown, un état de combat ou un prérequis en jeu ? Ces exemples sont des pistes de vérification possibles et ne valent pas pour tous les plugins. Ce qui compte, c'est la documentation de ton extension précise.

Un démarrage réussi ne prouve pas non plus que chaque hook fonctionne. Un hook est un point d'ancrage fourni par le framework et lié à un événement du jeu. Si une telle interface est modifiée, un plugin peut se charger puis échouer ou cesser de réagir uniquement lorsque l'événement concerné se produit. Reproduis donc le véritable déclencheur et observe le log précisément à ce moment-là.

En cas d'exception à l'exécution, sauvegarde la stack trace pertinente complète ainsi que l'action qui l'a précédée. Modifier de nombreuses permissions « pour tester » n'est pas une bonne alternative : cela peut élargir des accès et masquer l'erreur d'origine. Une comparaison propre repose sur un compte défini et des droits documentés.

Pourquoi supprimer les configs est rarement le bon point de départ

Un fichier de configuration peut effectivement être défectueux. Parmi les indices, on trouve par exemple une erreur d'analyse JSON explicitement signalée ou une erreur survenant directement à la lecture d'un paramètre. En revanche, une erreur de compilation concernant une méthode du jeu manquante ne se corrige pas en réinitialisant toutes les configs.

Le guide Oxide sur les configurations met aussi en garde contre les plugins qui réécrivent leurs paramètres lors du déchargement. Une modification effectuée pendant que le plugin tourne peut alors être écrasée. Sauvegarde le fichier, suis les instructions du plugin et décharge-le si nécessaire avant de le modifier.

Vérifie d'abord le JSON en local avec un validateur adapté. Les valeurs confidentielles, comme les identifiants ou les adresses de webhook, n'ont rien à faire dans des validateurs publics en ligne. Un JSON valide ne garantit toutefois que la syntaxe : un champ correctement écrit peut quand même contenir une valeur non autorisée ou suivre un schéma obsolète.

Si une config neuve est nécessaire pour comparer, travaille autant que possible sur une copie isolée. Conserve le fichier d'origine intact. Compare ensuite les paramètres un par un et ne reprends que les modifications dont tu comprends l'effet. Une réinitialisation complète peut modifier des règles, des prix, des références de permissions ou d'autres réglages propres au plugin, sans que cela se remarque lors du premier test fonctionnel.

Pas de wipe pour réparer un plugin

Un wipe concerne la sauvegarde de la partie ou certaines données de progression. Une erreur de compilation d'un plugin concerne le code et ses prérequis. Ce sont deux niveaux différents. Un nouveau monde ne rend pas de nouveau disponible une méthode d'API supprimée et n'installe pas une bibliothèque manquante.

Qu'une erreur survienne un jour de wipe ne prouve aucun lien avec des données de monde endommagées. La mise à jour du jeu, celle du framework, celle des plugins et le wipe ont souvent lieu au cours de la même opération de maintenance. Distingue ces événements dans ta chronologie. Vérifie aussi si une autre identité de serveur ou un autre répertoire de données a été utilisé après le redémarrage.

Si tu soupçonnes réellement un problème de monde ou de données, il s'agit d'un diagnostic à part entière, avec sa propre sauvegarde et son propre critère de réussite. Ne le traite pas comme une dernière étape anodine de la réparation d'un plugin. Avant de restaurer une sauvegarde plus ancienne, tu dois savoir quelle progression acquise depuis serait perdue et si cette sauvegarde est encore compatible.

Carbon : même logique de diagnostic, installation différente

Si le serveur utilise Carbon, commence par interroger sa version :

c.version

La configuration de Carbon et les notes de version officielles documentent les fonctions propres à Carbon et les informations de version. Utilise les commandes et les chemins de ton installation Carbon réelle. Sur ce type de serveur, l'échec d'une commande Oxide ne prouve pas à lui seul une panne du framework.

Les questions de base restent les mêmes : le framework tourne-t-il ? Quelles extensions sont réellement chargées ? Est-ce un seul plugin dépendant qui échoue ou un prérequis commun ? Quelle fonction a vraiment été testée ? Cela ne signifie pas pour autant que chaque plugin Oxide fonctionne sans modification sous n'importe quelle version de Carbon, ni qu'un changement de framework soit une réparation immédiate sans risque.

Ne passe pas d'Oxide à Carbon, ou inversement, en cours de diagnostic. Une migration modifie plusieurs prérequis à la fois. Planifie-la séparément, sauvegarde les données et les permissions, puis teste les plugins dont tu as besoin. Pour une erreur de compilation isolée, le plus petit changement adapté est généralement plus facile à suivre qu'un changement complet de plateforme.

Trois cas comparés directement

Cas
Constat déterminant
Plus petite intervention pertinente
Ce qui reste expressément intact
Preuve après coup
Framework absent ou incompatible
Démarrage du framework non confirmé ; nombreuses fonctions touchées
Installer correctement la version adaptée du framework après la mise à jour du jeu
Monde, configs des plugins et données utilisateur
Version, log de démarrage, liste des plugins, fonction
Un seul plugin ne compile pas
Le framework tourne ; le premier diagnostic cite ce plugin
Installer une version compatible du plugin ou le désactiver isolément
Autres plugins et données sauvegardées
Vérifier séparément la compilation, le chargement et la fonction
Dépendance manquante
Le plugin dépendant cite un prérequis absent ou en échec
Réparer le prérequis, puis vérifier le plugin dépendant
Extensions non concernées
La dépendance et la fonction commune marchent

Cette comparaison présente la démarche de diagnostic, pas des temps de réparation mesurés. Toutes les erreurs ne correspondent pas clairement à une seule ligne. Une référence DLL manquante peut par exemple provoquer une erreur de compilation. Classe le problème selon la première cause avérée, pas selon le dernier message rouge.

Comment vérifier la réparation de manière fiable

Avant toute modification, définis un petit test qui rend visible la panne d'origine. Pour un plugin de kits, il peut s'agir d'une récupération documentée avec un compte de test prévu à cet effet et un kit de test connu. Pour un plugin de protection, il faut vérifier dans des conditions contrôlées la protection promise au préalable. N'utilise pour cela ni les constructions d'autres joueurs ni de véritables valeurs économiques.

Compare ensuite ce même test avant et après une seule modification. Note le type de compte, les droits concernés, la version du plugin, les paramètres, l'action et le résultat. Vérifie aussi une fonction voisine qui n'était pas cassée. Tu remarqueras ainsi si une réparation résout le problème visible tout en modifiant une autre règle essentielle.

Une conclusion sérieuse répond à cinq questions :

  • Le framework attendu répond-il depuis la bonne instance de serveur ?
  • Les versions de plugins réellement chargées correspondent-elles à celles prévues ?
  • La première erreur a-t-elle disparu du nouveau log sans en provoquer une autre ?
  • Le cas d'utilisation concret fonctionne-t-il avec le compte utilisateur approprié ?
  • Le résultat persiste-t-il après le prochain démarrage contrôlé prévu ?

Le dernier point vérifie notamment l'ordre d'installation et le démarrage automatique. Ne force pas pour cela un redémarrage supplémentaire inutile pendant que des joueurs sont connectés. Tant que cette preuve manque, documente la réparation comme vérifiée sur le plan fonctionnel, avec preuve de démarrage en attente.

Un rapport d'erreur utile

N'envoie pas une collection de captures d'écran en vrac. Un rapport court et reproductible accélère le diagnostic. Les conseils d'Oxide pour signaler un problème recommandent d'indiquer les données d'environnement, les étapes, le résultat attendu et le résultat réel, ainsi que les logs pertinents.

Fonction concernée :
Première erreur observée, avec date et fuseau horaire :
Version de Rust et branche de release :
Framework et version réellement relevée :
Nom du plugin, version et source de téléchargement :
Dépendances requises et leur état :
Dernière modification avant l'erreur :
Premier message d'erreur complet :
Étapes pour reproduire :
Résultat attendu / résultat réel :
Modification isolée déjà essayée et résultat :
Sauvegarde disponible et plan de retour arrière :

Retire de la copie les mots de passe, les tokens, les adresses de webhook et les données personnelles inutiles. Conserve l'original non modifié en lieu sûr. Une copie de log nettoyée doit préserver la cause technique : ne supprime pas par mégarde le nom de fichier du plugin ou le message d'erreur nécessaire au diagnostic.

Adresse ta demande au bon interlocuteur. En cas d'ordre d'installation incorrect ou de framework impossible à sélectionner, le support de l'hébergeur peut t'aider. Pour une erreur reproductible dans un seul plugin, son développeur est souvent le bon contact. Si plusieurs niveaux restent flous, transmets tes constats plutôt que de désigner trop vite un responsable.

Avant la prochaine mise à jour de Rust

Tiens un petit inventaire de tes plugins critiques et de leurs dépendances. Note quelles règles de jeu ne s'appliquent plus sans eux et quelles fonctions relèvent du simple confort. Ainsi, après une mise à jour, tu pourras d'abord vérifier ce qui compte vraiment pour votre communauté, au lieu de passer en revue chaque extension par ordre alphabétique.

Avant tout changement planifié, sauvegarde un état clairement identifiable et conserve les informations de version correspondantes. Consulte les annonces récentes du projet du framework et des développeurs de tes principaux plugins. Ne te fie pas à un délai d'attente fixe : une release peut sortir rapidement, alors qu'un plugin donné peut encore nécessiter une adaptation.

Vérifie aussi ce que ton script de démarrage ou ton hébergeur automatise. Met-il à jour Rust, le framework, les deux ou aucun des deux ? Dans quel ordre ? Un hébergeur peut s'en charger à chaque démarrage, un autre via une fonction de mise à jour séparée. Le guide d'un autre panel ne décrit pas forcément ton serveur.

Pour les grandes communautés, une procédure de test séparée avec des données de test connues est utile. Un essai doit utiliser les mêmes versions et réglages pertinents, sinon sa réussite n'a qu'une valeur limitée. Documente les limites de tes tests au lieu de tirer d'un serveur de test vide des promesses générales de stabilité.

FAQ

Dois-je redémarrer tout le serveur après chaque mise à jour de plugin ?

Pas forcément. Oxide prend en charge la détection automatique des modifications de plugins et le rechargement ciblé. Les fichiers du framework, les extensions et certaines procédures d'initialisation peuvent en revanche exiger un redémarrage. C'est la documentation du composant concerné qui fait foi. Après un rechargement, vérifie le log et la fonction : une commande acceptée avec succès ne suffit pas à elle seule.

Tous les plugins ont disparu. Oxide est-il forcément en cause ?

Non. C'est une piste sérieuse, mais vérifie le contexte de la console, le démarrage complet, le choix du framework, l'instance du serveur et les dépendances communes. Un mauvais répertoire de données ou plusieurs plugins ayant le même prérequis peuvent aussi ressembler à une panne totale. Seule la combinaison des constats permet de cerner l'erreur de façon fiable.

Un redémarrage suffit-il dès qu'un nouveau framework est sorti ?

Seulement si ta procédure d'installation installe réellement ce framework à cette occasion ou si tu l'as correctement mis à jour au préalable. En auto-hébergement, un redémarrage seul ne télécharge rien. Compare la version du framework lue ensuite avec celle prévue. Si elle n'a pas changé, examine la procédure de mise à jour.

Puis-je supprimer la config et la laisser se recréer ?

Une nouvelle config peut aider à comparer dans une copie de test sauvegardée. Comme réparation systématique, elle ne convient pas et peut réinitialiser tes propres règles. Cherche d'abord une erreur de configuration précise. Sauvegarde l'original et les données, et vérifie si le plugin réécrit des paramètres lors de son déchargement.

Pourquoi un plugin reste-t-il affiché comme chargé après la mise à jour, sans pour autant fonctionner ?

Le chargement n'est qu'une étape. La fonction concernée peut échouer à cause de permissions, de réglages, d'une dépendance requise seulement plus tard ou d'un hook modifié. Teste le déclencheur dans des conditions contrôlées et lis le log au même moment. N'affirme pas que la fonction est réparée sur la seule base de sa présence dans la liste.

Combien de temps dois-je attendre Oxide ou un correctif de plugin ?

Impossible de promettre sérieusement un délai fixe. Consulte le canal de release actuel et le statut du plugin concerné. Si une protection critique n'est pas disponible, décide de l'état de fonctionnement sûr du serveur au lieu de te fier à une heure estimée.

Puis-je simplement revenir à une version antérieure ?

Seulement avec une combinaison compatible vérifiée et un retour arrière sécurisé. Un ancien framework avec un Rust récent peut échouer à nouveau. Une nouvelle version de plugin peut avoir modifié des données que l'ancienne version ne comprend pas. Sauvegarde en plus l'état actuel et vérifie la compatibilité des données avant de restaurer.

Termes fréquents dans le log

Framework : base des extensions, par exemple Oxide ou Carbon. Plugin : extension individuelle dotée d'une fonction précise. Compilateur : traduit le code source du plugin en code exécutable. Dépendance : autre composant dont une extension a besoin. Extension : module complémentaire du framework, souvent une bibliothèque compilée avec sa propre procédure d'installation. Hook : point d'accroche à un événement du jeu. RCON : accès distant autorisé à la console du serveur. Rollback : restauration vérifiée d'un état antérieur cohérent. Wipe : réinitialisation de certaines données de jeu ; ce n'est pas une réparation générale des plugins.

Sur le serveur concerné, ta prochaine étape la plus judicieuse est modeste : sauvegarde le log de démarrage actuel, vérifie le framework réellement en cours d'exécution et remonte jusqu'au premier message d'erreur. Ce n'est qu'ensuite que tu décideras quel composant précis doit être modifié.

Sources et état des vérifications

État des vérifications : informations de release vérifiées le 6 novembre 2026 ; aucun nouveau test fonctionnel avec Oxide.Rust 2.0.7894. Les trois essais d'erreurs ont été réalisés le 29 octobre 2026 sur notre propre serveur de test isolé avec le protocole Rust 2635.289.1 et Oxide.Rust 2.0.7839 ; le serveur de test a ensuite été supprimé. Après d'autres mises à jour de Rust, les numéros de version de ces essais historiques ne sont plus qu'un exemple.