Resposta rápida: depois de uma atualização do Rust, verifica primeiro qual é o framework que está realmente em execução. No Oxide, ajudam-te oxide.version, oxide.plugins e o registo de arranque. Se faltar apenas um plugin, distingue entre erro de compilação, dependência em falta e erro de configuração. O facto de haver plugins carregados não exclui um erro do framework. Faz cópia dos ficheiros e do progresso do jogo antes de alterares seja o que for; um wipe ou apagar todas as configs não é um primeiro passo de diagnóstico sensato.
Este guia aplica-se a servidores dedicados de Rust da versão para PC, alojados por ti ou em qualquer fornecedor. Para os passos administrativos, precisas de acesso à verdadeira consola do servidor ou a RCON autorizado e, se necessário, aos ficheiros do servidor. Não é necessária uma conta de cliente na SupremeTier. Se apenas jogas no servidor afetado, começa pela secção seguinte.
Atualizado a 6 de novembro de 2026; testes de erros próprios: 29 de outubro de 2026. Os comandos do procedimento principal referem-se ao Oxide. O Carbon é tratado em separado. Os cenários de erro «um único plugin não compila» e «falta uma dependência» foram provocados de forma controlada e reparados num servidor de testes próprio e isolado. Estes testes simulam estados de erro; não são a observação de um plugin de terceiros avariado após uma atualização. Também foi verificado, de forma isolada, um estado do framework propositadamente misto. Nesse teste, os plugins carregaram enquanto um hook do framework falhava. Os resultados originais apresentados a seguir provêm de testes de erros controlados e não são apresentados como um incidente real no servidor de um cliente.
Como jogador: o que podes fazer?
O desaparecimento do menu /kit não prova que o teu inventário foi apagado. Pode faltar apenas o plugin que disponibiliza o comando. Pergunta primeiro se outros jogadores também notam a falta dessa função e se foram afetadas várias funções independentes entre si. Aponta a hora, o comando introduzido e a resposta visível. Uma captura de ecrã da mensagem ajuda; podes tapar os nomes privados dos jogadores antes de a partilhares.
Por exemplo, comunica: «Desde o reinício por volta das 19h, o meu comando de kit não dá qualquer resposta. O teletransporte também não funciona. Construir normalmente funciona. Antes do reinício, ambos funcionavam.» Assim, a administração pode procurar de forma direcionada o arranque correspondente. A afirmação «Foi feito wipe a tudo» seria, sem verificação, exagerada.
Não instales ficheiros de cliente oferecidos ao acaso como suposta reparação de um plugin do servidor. Como jogador, não consegues recarregar o framework do lado do servidor. Se faltarem funções de proteção, como as regras PvE prometidas neste servidor, não contes com elas até a situação ficar esclarecida. Cabe à administração decidir se é seguro continuar a jogar normalmente.
Primeiro, distingue os três níveis
Para este diagnóstico, um servidor de Rust modificado é composto por três níveis. O próprio Rust fornece o mundo e a mecânica do jogo. O framework, neste caso o Oxide ou, em alternativa, o Carbon, possibilita as extensões. Os plugins individuais implementam, por exemplo, kits, teletransporte, funções de administração ou alterações às regras do jogo. Alguns plugins precisam de outros plugins ou de extensões.
Quando falta um nível inferior, muitas funções assentes nele parecem avariadas ao mesmo tempo. Quando falha uma única extensão, as restantes podem continuar a funcionar. Esta distinção é o ponto de partida, mas ainda não é uma prova: vários plugins também podem precisar da mesma biblioteca em falta. Inversamente, um framework pode responder e, ainda assim, ter problemas em determinados eventos do jogo.
«Ficheiro presente», «compilado», «carregado» e «a funcionar» são quatro estados diferentes. Um ficheiro .cs na pasta certa prova apenas que ali existe código-fonte. Compilar significa que foi gerado código executável a partir dele. O carregamento inclui a inicialização. Só um teste direcionado da função mostra se o comportamento pretendido funciona realmente com as tuas definições e permissões.
A documentação oficial do Oxide sobre a instalação de plugins descreve os ficheiros .cs, a compilação automática e o diretório de plugins. Não confundas este nível dos ficheiros com o sucesso visível no jogo.
O caminho rápido para decidir
Depois de o servidor concluir o arranque, começa na consola do servidor, não no chat normal do jogo. Esta primeira verificação não altera nenhum plugin:
oxide.version
oxide.plugins
oxide.version consulta a versão do framework. oxide.plugins lista os plugins, incluindo as tentativas de carregamento falhadas. A referência oficial de comandos descreve a lista de plugins e os comandos de carregamento específicos; o guia de comandos para proprietários explica a consola e o chat.
| Observação | Primeira hipótese de trabalho |
Verificação seguinte |
|---|---|---|
| O Oxide não responde, faltam muitas funções | O framework está em falta, não arranca ou o contexto da consola está errado |
Verifica o registo de arranque, o framework realmente escolhido e a instalação |
| O Oxide responde, vários plugins funcionam, um falha | Problema desse plugin ou dos seus requisitos |
Lê a primeira mensagem de erro completa e a versão do plugin |
| Vários plugins afetados indicam a mesma dependência | Falha de uma dependência comum |
Analisa primeiro essa dependência |
| O plugin está carregado, só falta uma função | Permissões, definições, hook ou problema em tempo de execução |
Testa a função concreta em condições controladas |
| Configs novas, outro mundo ou dados aparentemente vazios | Possivelmente outra instância do servidor ou outro caminho de dados |
Compara a identidade, os parâmetros de arranque e os mounts com o estado anterior |
Um comando desconhecido é um indício, não um diagnóstico definitivo. Verifica se abriste mesmo a consola do servidor afetado, se o arranque terminou e se este servidor usa realmente o Oxide. No caso do Carbon, um teste específico do Oxide não constitui, por si só, uma base suficiente.
Antes de qualquer reparação: guarda as provas e garante uma forma de voltar atrás
Um bom diagnóstico começa com um breve levantamento da situação. Regista quando o erro foi notado pela primeira vez, que atualização do jogo ou reinício o antecedeu e o que já foi alterado desde então. Guarda o registo de arranque completo, desde o início do processo até à primeira mensagem de erro. Uma captura de ecrã da última linha vermelha muitas vezes não chega, porque mostra apenas o erro subsequente.
O Oxide também escreve os erros de carregamento e de compilação em ficheiros de registo próprios, na pasta oxide/logs da instalação do teu servidor. Aí, a mensagem surge muitas vezes mais completa do que no excerto visível da consola, por exemplo quando a consola mostra apenas as últimas linhas. Escolhe o ficheiro cuja data corresponde ao arranque em causa e guarda-o juntamente com o registo da consola.
Aponta a versão do Rust ou a informação da build, o ramo de lançamento utilizado, o sistema operativo, a versão do framework e as versões dos plugins afetados. Guarda a origem de transferência dos ficheiros instalados. «Versão mais recente» não é uma indicação de versão reproduzível: o ficheiro pode ter sido substituído desde que o transferiste, ou o teu script de arranque pode carregar uma versão diferente da esperada.
O que deve constar da cópia de segurança?
Guarda um estado coerente dos dados do mundo e dos jogadores, da configuração de arranque e dos ficheiros de modding. No Oxide, devem constar do levantamento sobretudo oxide/plugins, oxide/config e oxide/data; tem também em conta os dados de permissões e as tuas próprias extensões. A estrutura concreta de armazenamento depende da instalação. Verifica os caminhos que realmente usas, em vez de copiares às cegas um diretório de exemplo.
Distingue as definições dos dados de utilização. Uma config determina, por exemplo, o comportamento de um plugin; os dados desse plugin podem incluir recompensas já atribuídas, posições guardadas ou outros estados permanentes. O conteúdo depende do plugin. Por isso, esvaziar oxide/data de forma generalizada pode alterar muito mais do que a função com erro.
Para obteres uma cópia consistente, usa o procedimento de cópia de segurança documentado da tua instalação. Uma cópia feita durante operações de escrita em curso pode ficar inconsistente. Verifica se a cópia de segurança foi realmente concluída e se está acessível. Extrai-a ou verifica-a num local separado, sem substituir o servidor atual. Um nome de cópia de segurança apresentado no ecrã não é, por si só, uma forma de voltar atrás verificada.
Define o limite da tua alteração
Antes de intervires, escreve: «Vou substituir apenas este ficheiro de plugin» ou «Vou reinstalar o pacote do Oxide compatível com a versão atual do Rust». Inclui o ficheiro antigo guardado, o novo ficheiro e o critério de sucesso. Não alteres ao mesmo tempo o framework, vários plugins, as configs e os parâmetros do mapa. Caso contrário, depois não saberás que intervenção ajudou ou prejudicou.
Se um plugin de proteção, de economia ou de acesso falhar, decide sobre a disponibilidade do servidor antes de testar. Um mundo tecnicamente acessível não é automaticamente jogável segundo as regras prometidas. Anuncia qualquer interrupção necessária e usa o procedimento normal de paragem da tua instalação. Repetir paragens forçadas não substitui um diagnóstico.
Caso A: a framework falha
Cenário típico: o servidor arranca depois de uma atualização do jogo, mas faltam inúmeras funções de plugins independentes entre si. No log de arranque atual não há sinal de que o Oxide tenha sido carregado com sucesso, ou a consulta da versão, feita no contexto de consola correto, não devolve nenhuma versão da framework.
A causa a verificar não é apenas «Oxide demasiado antigo». A atualização do jogo pode substituir ficheiros modificados; um script de arranque pode repor depois os ficheiros Vanilla; a framework pode ter sido extraída para o diretório errado do servidor. Também podem estar em causa um pacote para o sistema operativo errado, um ramo do jogo incompatível ou um carregamento incompleto.
No guia do Dedicated Server, a Facepunch indica expressamente que uma atualização do jogo pode exigir uma nova instalação do Oxide e que o SteamCMD pode repor os ficheiros Vanilla durante o processo de arranque. Daí resulta esta ordem importante: atualizar o jogo, instalar a versão correspondente da framework e só depois arrancar o servidor. Uma nova verificação dos ficheiros do jogo depois de instalares a framework pode deitar todo o trabalho a perder.
Ordem a seguir no alojamento próprio
Num servidor alojado por ti com SteamCMD, a ordem é a seguinte. O caminho é um exemplo; substitui-o pelo diretório real do teu servidor:
steamcmd +force_install_dir /pfad/zum/rustserver +login anonymous +app_update 258550 validate +quit
258550 é o ID de aplicação do Rust Dedicated Server. validate verifica os ficheiros do jogo e, ao fazê-lo, repõe a versão Vanilla. É precisamente por isso que o Oxide só vem depois: descarrega da release oficial do Oxide.Rust o arquivo para o teu sistema operativo, Oxide.Rust-linux.zip para Linux ou Oxide.Rust.zip para Windows. Extrai-o com a respetiva estrutura de pastas para o diretório principal do servidor, ou seja, onde também se encontra RustDedicated ou RustDedicated.exe, e deixa substituir os ficheiros existentes. Só então arranca o servidor e verifica oxide.version.
Se o teu script de arranque chamar o SteamCMD antes de cada arranque, volta a substituir os ficheiros do Oxide em cada reinício. Nesse caso, a instalação do Oxide também tem de fazer parte do script de arranque, entre a atualização e o arranque do servidor, ou então retiras a atualização automática do script. Num alojamento gerido, usa antes a função de framework do teu fornecedor.
Distinguir a release atual da combinação de teste histórica
Na nossa verificação de releases de 6 de novembro de 2026, a release oficial 2.0.7894 do Oxide.Rust era a versão publicada mais recente. Foi publicada a 6 de novembro de 2026, às 10:11:56 UTC, e refere o primeiro hotfix do Rust desse dia para 2636.290.1. A indicação do Rust não é um número de versão do pacote Oxide. Esta atualização comprova a release publicada, não um teste funcional nosso com a nova combinação.
Os nossos próprios testes de erro continuam a referir-se ao estado de 29 de outubro de 2026: o changelog do uMod para o Rust indica 2635.289.1 para a atualização de 22 de outubro; a correspondente release oficial 2.0.7839 do Oxide.Rust foi publicada a 22 de outubro de 2026, às 18:02:03 UTC. No nosso servidor de teste isolado, version e oxide.version indicaram efetivamente o protocolo Rust 2635.289.1 e o Oxide.Rust 2.0.7839. Trata-se de uma combinação de teste histórica e não de uma recomendação permanente para manteres estes números após atualizações posteriores.
Quando fores mesmo intervir, volta a verificar a release atual e o estado do Rust no teu servidor. A existência de uma nota de release correspondente não prova que o teu fornecedor ou o teu script de arranque já tenham instalado essa versão. O que conta é a versão lida depois na instância em execução, em conjunto com o log de arranque atual.
Teste próprio A: erro de framework apesar de os plugins estarem carregados
O nosso ponto de partida era o protocolo Rust 2635.289.1 com o respetivo Oxide.Rust 2.0.7839. Depois de uma paragem normal e de uma cópia de segurança do nosso mundo de teste, incluindo o diretório do Oxide, colocámos intencionalmente, apenas no servidor de teste isolado, o antigo Oxide.Rust.dll da release oficial 2.0.7072, de 19 de fevereiro de 2026. O resto da instalação atual manteve-se. Isto simula um estado misto e incompatível da framework; não é um teste de um pacote de servidor histórico completo.
A alteração foi confirmada através do SHA-256 da DLL efetivamente utilizada. No arranque, surgiu esta mensagem real:
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)
Ao mesmo tempo, os nossos plugins de teste chegaram aos respetivos marcadores de inicialização. O processo do servidor também continuou em execução. É esta a diferença importante em relação a uma regra demasiado simplista: um problema de framework não tem de impedir o carregamento de todos os plugins. Uma lista de plugins carregados com sucesso ou um processo em execução não constituem uma verificação completa de compatibilidade.
A mensagem refere RustCore, ou seja, um componente da framework, e um acesso a um campo que não foi encontrado. Não é um erro de JSON na configuração de um kit. Nesta combinação criada de propósito, a causa está no estado incompatível da framework. Já um erro do mesmo tipo com outro nome pode ter origem num único plugin; lê sempre o componente, o hook e o contexto em conjunto.
Para a reversão mínima, repusemos a DLL 2.0.7839 compatível, previamente fixada, e reiniciámos de forma controlada. Depois disso, oxide.version voltou a responder com 2.0.7839, oxide.plugins listou os quatro plugins de teste e a MissingFieldException observada anteriormente já não constava do novo buffer disponível da consola. O regresso à framework compatível fica assim verificado para este teste concreto. Para o teu servidor de produção, isto não significa que recomendemos juntar DLLs individuais de arquivos quaisquer: usa aí o procedimento completo de instalação da framework compatível, para que o estado seja consistente.
O teste usa propositadamente uma release bastante mais antiga. Não afirma que todas as versões mais antigas falhem da mesma forma, nem que este quadro de erro surja em todas as atualizações de outubro. Uma falha da framework também pode significar simplesmente um servidor Vanilla sem o Oxide carregado. Por isso, continua a ser necessária a combinação da versão real, do primeiro diagnóstico no log e de um teste funcional.
Reparação mínima
- Guarda o estado inicial e o log. Verifica se há algum atualizador automático em execução. Não inicies um segundo processo de instalação em conflito.
- Compara a versão do Rust, o ramo de release, o sistema operativo e a release da framework prevista para essa combinação.
- Para o servidor de forma normal, se a instalação exigir alterações aos ficheiros da framework.
- Usa o procedimento de instalação documentado. No alojamento próprio, extrai o arquivo fidedigno e compatível para a instalação correta, mantendo a estrutura de diretórios e seguindo a ordem descrita acima. Num alojamento gerido, usa a respetiva função de framework; não assumas que os menus de painéis de outros fornecedores se aplicam ao teu.
- Verifica a ordem de atualização e arranca uma vez de forma controlada. Lê o novo log de arranque.
- Verifica a versão da framework, a lista de plugins e, pelo menos, uma função que tenha falhado antes.
Sucesso: a framework esperada responde a partir da instância correta, os plugins esperados são carregados e a função verificada está a funcionar. Reversão: preserva o estado anterior à intervenção. Não reponhas às cegas um ficheiro antigo da framework sobre um jogo novo. Se apenas um pacote completo mais antigo era compatível, a possibilidade de o restaurar tem de ser verificada à parte, incluindo o formato do mundo e a compatibilidade com o cliente. Se isso não estiver claro, o servidor deve permanecer fora de serviço de forma controlada até existir uma versão compatível.
Caso B: um plugin não compila
Cenário típico: o Oxide responde e outros plugins são carregados, mas um determinado plugin aparece como falhado. O log indica um erro de compilação, muitas vezes com ficheiro, linha, coluna e um símbolo em falta ou um método que já não é compatível.
Um erro de compilação significa, antes de mais, apenas isto: o código-fonte existente não pode ser compilado com as referências disponíveis. Uma atualização do jogo pode ter alterado uma interface utilizada. Mas também pode tratar-se de uma transferência danificada, de código alterado por ti ou de uma dependência obrigatória em falta. Por isso, «Failed to compile» não significa automaticamente «o autor só tem de publicar uma nova versão».
Teste próprio B: um erro de compilação
No nosso servidor de testes isolado, com o protocolo Rust 2635.289.1 e Oxide.Rust 2.0.7839, apenas o plugin de teste Guide7CompileBroken.cs continha uma linha #error intencional. O plugin de controlo Guide7Probe, já carregado, manteve-se separado deste teste. O resultado real na consola foi:
Error while compiling Guide7CompileBroken: #error: 'GUIDE7_INTENTIONAL_COMPILE_FAILURE' | Line: 1, Pos: 8
Para a reparação mínima, removemos apenas a linha de erro inserida intencionalmente. Depois disso, a consola indicou:
Guide7CompileBroken was compiled successfully in 362ms
Loaded plugin Guide7CompileBroken v1.0.0 by Guide7 isolated test fixture
A reversão deste teste controlado consiste em restaurar o ficheiro com erro inalterado, o que voltaria a produzir o mesmo erro de compilação intencional. Num plugin real de terceiros, «apagar uma linha qualquer» não é, de forma alguma, um método de reparação. O nosso teste comprova a separação entre a framework e o compilador de plugins, e não uma quebra concreta da API causada pela atualização de outubro. Os 362 ms observados descrevem apenas este teste individual, e não um tempo de carregamento geral.
No log real, na consola ou em oxide/logs, procura primeiro o nome do ficheiro afetado e o primeiro diagnóstico do compilador. Uma mensagem posterior de que o plugin não pôde ser carregado muitas vezes apenas repete o resultado. Verifica se vários plugins indicam exatamente o mesmo símbolo em falta: nesse caso, o problema pode estar numa alteração comum da API ou numa referência partilhada, e não em vários defeitos independentes.
Transfere uma atualização exclusivamente da fonte documentada do plugin. Lê as notas de alteração: resolvem o teu problema, exigem uma nova dependência ou alteram o formato dos dados? Um número de versão mais alto, por si só, não garante compatibilidade com a tua combinação.
Reparação mínima
Faz uma cópia de segurança do ficheiro .cs atual, bem como da configuração e dos dados associados. Substitui primeiro apenas o plugin afetado pela versão corrigida prevista. Normalmente, o Oxide monitoriza as alterações na pasta de plugins; por isso, evita carregamentos duplicados e recarregamentos adicionais precipitados. Acompanha o processo na consola e verifica depois o estado real.
Se for necessário um recarregamento específico, o formato é:
oxide.reload Pluginname
Aqui, Pluginname representa o nome real do ficheiro do plugin sem .cs, e não o título comercial de uma transferência. A referência oficial de comandos documenta este recarregamento específico. Enquanto estiveres a isolar o problema, não uses um recarregamento com wildcard de todos os plugins. Isso altera desnecessariamente muitos estados e pode gerar novos erros.
Sucesso: o diagnóstico do compilador desaparece, a versão esperada do plugin é carregada e a função concretamente afetada passa no teste. Reversão: se a atualização falhar, guarda também este novo log. Restaura a versão antiga do plugin, juntamente com os dados necessários, apenas se essa combinação for compatível com o jogo atual. Um ficheiro antigo que já estava avariado depois da atualização do jogo não é uma reversão funcional.
Se não existir uma correção compatível, pode fazer sentido desativar temporariamente apenas o plugin afetado. Verifica primeiro que outros plugins e regras de jogo dependem dele. Com o servidor parado de forma normal, move o ficheiro-fonte guardado da pasta de plugins monitorizada para uma pasta de cópias de segurança separada. Não apagues a configuração nem os dados de utilização. Documenta que função ficará em falta até à reparação.
Caso C: falta uma dependência
Situação típica: um plugin indica um requisito em falta. Outras funções continuam a trabalhar, ou vários plugins avariados dependem da mesma biblioteca. O ficheiro em falta pode até existir, mas não conseguir ser carregado.
A diretriz do Oxide sobre dependências distingue dependências opcionais, necessárias e obrigatórias. Uma integração opcional expande o comportamento. Um requisito necessário é preciso para a função. Uma dependência obrigatória pode impedir logo a compilação. Estes termos explicam por que motivo «dependência em falta» e «erro de compilação» se podem sobrepor.
Teste próprio C: uma dependência em falta
No mesmo servidor de testes, carregámos o nosso plugin de teste Guide7Consumer.cs com o requisito declarado // Requires: Guide7Dependency. A dependência correspondente não estava inicialmente instalada, de forma intencional. Estes são resultados reais do teste controlado:
Guide7Consumer plugin requires missing dependency: Guide7Dependency
Ignored unexpected plugin compilation failure: Guide7Consumer
Error while compiling Guide7Consumer: Missing dependency: Guide7Dependency
Também aqui aparece «Error while compiling». O acréscimo decisivo, porém, é a indicação expressa da dependência em falta. Instalámos exclusivamente Guide7Dependency.cs e, em seguida, recarregámos especificamente o plugin dependente. Depois disso, surgiram ambos os marcadores de inicialização e ambas as confirmações de carregamento:
[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
Os marcadores comprovam a inicialização dos dois plugins de teste, e não um teste de funções de loja, teletransporte ou proteção de um plugin de terceiros. Para reverter este teste, bastaria remover a nossa dependência depois de descarregar o plugin dependente. Recarregar repetidamente o plugin dependente não instala, por si só, o respetivo requisito. Se, no teu log real, for a própria dependência a falhar primeiro, resolve primeiro o erro inicial dela. Uma biblioteca com nome semelhante, obtida numa fonte de transferência aleatória, não é um substituto.
Consulta a página do plugin e a documentação para confirmares o nome exato, o tipo de dependência e, se aplicável, as versões exigidas. Outro plugin .cs e uma extensão compilada são coisas diferentes. Podem ter locais de instalação e requisitos de reinício diferentes. Para extensões, segue as respetivas instruções de instalação; não copies uma DLL para oxide/plugins só por suspeita.
Reparação mínima
Cria uma pequena cadeia: plugin afetado → requisito necessário → estado desse requisito. Verifica o requisito na lista de plugins e no log de arranque. Se estiver mesmo em falta, instala exatamente esse requisito a partir da fonte oficial. Se já existir, resolve o primeiro erro dele, em vez de carregares o mesmo ficheiro vezes sem conta.
No caso de uma dependência normal de plugin, podes depois carregar especificamente primeiro o requisito e a seguir o plugin dependente, desde que a documentação suporte este procedimento. No caso de uma extensão ou de uma inicialização de arranque alterada, pode ser necessário um reinício controlado. Encara o reinício como um passo verificável com um novo log, e não como uma cura automática.
Sucesso: o requisito e o plugin dependente são carregados nas versões previstas e a função que os liga funciona. Uma simples lista com os dois plugins carregados não basta para o confirmar. Reversão: restaura a combinação compatível guardada ou desativa o plugin dependente enquanto o requisito estiver em falta. Antes de um downgrade, verifica se a nova versão já reescreveu configurações ou dados.
Carregado, mas sem funcionar
Se um plugin aparecer como carregado, passa do diagnóstico da instalação para o teste funcional. Verifica primeiro se estás a testar a função certa com a conta certa. Um administrador pode ter permissões diferentes das de um jogador comum. Por isso, o resultado de uma única tentativa como administrador não se aplica automaticamente a todos os jogadores.
Em seguida, verifica as permissões e as definições documentadas. A função, o mundo, a zona ou o grupo de utilizadores necessários estão ativados? Existem condições como cooldown, estado de combate ou um requisito dentro do jogo? Estes exemplos são áreas possíveis de verificação, e não uma afirmação sobre todos os plugins. O decisivo é a documentação da tua extensão específica.
Além disso, um arranque bem-sucedido não prova que todos os hooks funcionam. Um hook é um ponto de ligação a um evento do jogo disponibilizado pela framework. Se essa interface for alterada, um plugin pode carregar e só falhar, ou deixar de reagir, quando ocorrer o evento em causa. Por isso, repete o gatilho real e observa o log exatamente nesse momento.
Perante uma exceção em tempo de execução, guarda o stack trace relevante completo e a ação que a antecedeu. Alterar muitas permissões «para testar» não é um bom substituto: pode alargar acessos e ocultar o erro original. Uma comparação limpa usa uma conta definida e permissões documentadas.
Porque é que apagar as configs raramente é o melhor começo
Um ficheiro de configuração pode mesmo ter erros. Alguns indícios são, por exemplo, um erro de parsing de JSON comunicado de forma explícita ou um erro que surge precisamente ao ler uma definição. Já um erro de compilação sobre um método do jogo em falta não se resolve repondo todas as configs.
O guia do Oxide sobre configurações também alerta para plugins que voltam a escrever as definições ao serem descarregados. Nesse caso, uma edição feita com o plugin em execução pode ser substituída. Faz uma cópia de segurança do ficheiro, segue as instruções do plugin e, se necessário, descarrega-o antes de editar.
Valida primeiro o JSON localmente com uma ferramenta adequada. Valores confidenciais, como credenciais de acesso ou endereços de webhook, não devem ser colocados em validadores públicos online. No entanto, um JSON válido só confirma a sintaxe: um campo bem escrito pode, ainda assim, conter um valor não permitido ou seguir um esquema desatualizado.
Se precisares de uma config nova para comparar, trabalha, sempre que possível, numa cópia isolada. Mantém o ficheiro original inalterado. Depois, compara as definições uma a uma e aplica apenas as alterações que consigas justificar. Uma reposição completa pode alterar regras, preços, referências a permissões ou outras predefinições dependentes do plugin, sem que isso se note no primeiro teste funcional.
Um wipe não repara plugins
Um wipe afeta o estado do jogo ou determinados dados de progresso. Um erro de compilação de um plugin afeta o código e os respetivos requisitos. São níveis diferentes. Um mundo novo não volta a disponibilizar um método de API removido nem instala uma biblioteca em falta.
O facto de um erro surgir num dia de wipe não prova que esteja relacionado com dados do mundo danificados. A atualização do jogo, da framework e dos plugins e o wipe acontecem muitas vezes na mesma manutenção. Separa estes eventos na tua cronologia. Verifica também se, após o reinício, foi usada outra identidade do servidor ou outro diretório de dados.
Se suspeitares mesmo de um problema no mundo ou nos dados, trata-o como um diagnóstico à parte, com a sua própria cópia de segurança e o seu próprio critério de sucesso. Não o faças como um último passo casual da reparação de um plugin. Antes de restaurares uma cópia de segurança mais antiga, tens de saber que progresso alcançado desde então se perderia e se esse estado é sequer compatível.
Carbon: a mesma lógica de diagnóstico, um processo de instalação próprio
Se o servidor usar Carbon, começa por consultar a respetiva versão:
c.version
A configuração do Carbon e as notas de lançamento oficiais documentam as funcionalidades próprias do Carbon e as informações de versão. Usa os comandos e caminhos da tua instalação real do Carbon. Por si só, um comando do Oxide que falhe não prova, nesse ambiente, que a framework esteja inoperacional.
As perguntas fundamentais continuam a ser as mesmas: a framework está a funcionar? Que extensões estão realmente carregadas? Falha um único consumidor ou um requisito comum? Que função foi verdadeiramente testada? Daqui não se conclui, porém, que todos os plugins do Oxide funcionem sem alterações em qualquer versão do Carbon nem que mudar de framework seja uma reparação imediata e sem riscos.
Não alternes casualmente entre Oxide e Carbon enquanto estiveres a delimitar o problema. Uma migração altera vários requisitos ao mesmo tempo. Planeia-a à parte, faz uma cópia de segurança dos dados e das permissões e testa os plugins de que precisas. Para um único erro de compilação, a menor alteração adequada costuma ser mais fácil de acompanhar do que uma mudança completa de plataforma.
Três casos em comparação direta
| Caso | Indício decisivo |
Menor intervenção sensata |
O que fica expressamente intacto |
Comprovação posterior |
|---|---|---|---|---|
| A framework está em falta ou não é compatível | Arranque da framework não confirmado; muitas funções afetadas |
Instalar corretamente a versão adequada da framework após a atualização do jogo |
Mundo, configs dos plugins e dados de utilizador |
Versão, log de arranque, lista de plugins, função |
| Um único plugin não compila | A framework funciona; o primeiro diagnóstico indica esse plugin |
Instalar uma versão compatível do plugin ou desativá-lo de forma isolada |
Outros plugins e dados guardados |
Verificar separadamente a compilação, o carregamento e a função |
| Falta uma dependência | O consumidor indica um requisito que está em falta ou falha |
Reparar o requisito e depois verificar o consumidor |
Extensões não envolvidas |
A dependência e a função comum funcionam |
Esta comparação mostra o processo de diagnóstico, não tempos de reparação medidos. Nem todos os erros cabem claramente numa linha. Por exemplo, a falta de uma DLL referenciada pode provocar um erro de compilação. Classifica o problema pela primeira causa comprovada, não pela última mensagem a vermelho.
Como verificar a reparação de forma fiável
Antes de fazeres a alteração, define um pequeno teste que torne visível a falha original. Num plugin de kits, pode ser, por exemplo, um pedido documentado com uma conta de teste destinada a esse fim e um kit de teste conhecido. Num plugin de proteção, deves verificar em condições controladas a proteção prometida. Não uses construções de outros jogadores nem valores reais da economia do servidor.
Depois, compara o mesmo teste antes e depois de uma única alteração. Regista o tipo de conta, as permissões relevantes, a versão do plugin, as definições, a ação e o resultado. Verifica também uma função próxima que não estivesse avariada. Assim, percebes quando uma reparação resolve o problema visível, mas altera outra regra importante.
Um encerramento sensato inclui cinco perguntas:
- A framework esperada responde a partir da instância de servidor correta?
- As versões dos plugins realmente carregadas correspondem às previstas?
- O primeiro erro desapareceu do novo log sem dar origem a outro?
- O caso de utilização concreto funciona com a conta de utilizador adequada?
- O resultado mantém-se após o próximo arranque controlado planeado?
O último ponto verifica sobretudo a ordem de instalação e o arranque automático. Não forces desnecessariamente mais um reinício enquanto há jogadores no servidor. Se esta comprovação ainda estiver pendente, documenta a reparação como testada funcionalmente, com a comprovação do arranque por concluir.
Um relatório de erro útil
Não envies um conjunto desordenado de capturas de ecrã. Um relatório curto e reproduzível acelera a delimitação do problema. As indicações do Oxide para comunicar problemas recomendam incluir dados do ambiente, passos, resultado esperado e resultado real, bem como os logs relevantes.
Função afetada:
Primeiro erro observado, com data e fuso horário:
Versão do Rust e ramo de lançamento:
Framework e versão realmente lida:
Nome do plugin, versão e origem da transferência:
Dependências necessárias e respetivo estado:
Última alteração antes do erro:
Primeira mensagem de erro completa:
Passos para reproduzir:
Resultado esperado / resultado real:
Alteração individual já tentada e resultado:
Cópia de segurança disponível e forma de reverter:
Remove da cópia as palavras-passe, os tokens, os endereços de webhook e os dados pessoais desnecessários. Guarda o original inalterado num local protegido. Uma cópia limpa do log deve preservar a causa técnica: não removas por engano o nome do ficheiro do plugin nem a mensagem de erro necessária para o diagnóstico.
Dirige o pedido à entidade certa. Se a ordem de instalação estiver errada ou não for possível selecionar a framework, o suporte do alojamento pode ajudar. Perante um erro reproduzível num único plugin, o respetivo programador é muitas vezes o contacto adequado. Se houver dúvidas em vários níveis, envia as conclusões em vez de atribuíres culpas precipitadamente.
Antes da próxima atualização do Rust
Mantém uma pequena lista dos teus plugins críticos e das respetivas dependências. Regista quais as regras de jogo que deixam de se aplicar sem eles e quais as funções que apenas oferecem comodidade. Assim, depois de uma atualização, podes verificar primeiro o que é decisivo para a vossa comunidade, em vez de mexer em cada extensão por ordem alfabética.
Antes de alterações planeadas, guarda um estado rastreável e conserva as informações de versão correspondentes. Consulta os avisos atuais do projeto do framework e dos principais programadores de plugins. Não confies num tempo de espera fixo: uma versão pode sair rapidamente, mas um determinado plugin pode continuar a precisar de uma adaptação.
Verifica também o que o teu script de arranque ou o teu fornecedor automatiza. Atualiza o Rust, o framework, ambos ou nenhum deles? Por que ordem? Um fornecedor de alojamento pode fazê-lo em cada arranque, outro através de uma função de atualização separada. O guia de um painel alheio não descreve automaticamente o teu servidor.
Para comunidades maiores, compensa ter um processo de testes separado com dados de teste conhecidos. Um teste tem de usar as mesmas versões e definições relevantes; caso contrário, o seu sucesso tem um valor informativo limitado. Documenta os limites dos testes, em vez de deduzires promessas gerais de estabilidade a partir de um servidor de testes vazio.
FAQ
Tenho de reiniciar o servidor inteiro depois de cada atualização de um plugin?
Não necessariamente. O Oxide suporta a deteção automática de alterações nos plugins e o recarregamento seletivo. Já os ficheiros do framework, as extensões e determinados processos de inicialização podem exigir um reinício. O que conta é a documentação do componente em causa. Depois de recarregares, verifica o log e a função; não basta o comando ter sido aceite com sucesso.
Faltam todos os plugins. A culpa é de certeza do Oxide?
Não. É uma pista forte, mas verifica o contexto da consola, se o arranque foi concluído, a escolha do framework, a instância do servidor e as dependências comuns. Um diretório de dados errado ou vários plugins com o mesmo requisito também podem parecer uma falha total. Só a combinação das observações permite delimitar o erro com fiabilidade.
Um reinício resolve assim que sai um novo framework?
Só se o teu processo de instalação instalar efetivamente esse framework durante o reinício ou se o tiveres atualizado corretamente antes. Em alojamento próprio, um reinício, por si só, não faz qualquer transferência. Compara a versão do framework lida depois do arranque com a versão prevista. Se continuar igual, investiga o processo de atualização.
Posso apagar a config e deixar que seja criada de novo?
Uma config nova pode ajudar a comparar numa cópia de teste segura. Como reparação generalizada não é adequada e pode repor as tuas próprias regras. Procura primeiro um erro de configuração concreto. Faz uma cópia de segurança do original e dos dados e tem em conta se o plugin volta a escrever definições ao ser descarregado.
Porque é que um plugin continua a aparecer como carregado depois da atualização, mas não funciona?
O carregamento é apenas uma etapa. A função concreta pode falhar devido a permissões, definições, uma dependência que só é necessária mais tarde ou um hook alterado. Testa o acionador em condições controladas e lê o log do mesmo momento. Não afirmes que a função está reparada apenas com base na entrada da lista.
Quanto tempo tenho de esperar pelo Oxide ou por uma correção do plugin?
Não é possível prometer com seriedade um prazo fixo. Verifica o canal de lançamentos atual e o estado do plugin em causa. Se uma proteção crítica não estiver disponível, decide qual é o estado de funcionamento seguro do servidor, em vez de confiares numa hora estimada.
Posso simplesmente voltar a uma versão anterior?
Só com uma combinação compatível verificada e um caminho de regresso seguro. Um framework antigo com um Rust novo pode voltar a falhar. Uma nova versão de um plugin pode ter alterado dados que a versão antiga não compreende. Guarda também o estado atual e verifica a compatibilidade dos dados antes de restaurares.
Termos que aparecem frequentemente no log
Framework: base para as extensões, como o Oxide ou o Carbon. Plugin: extensão individual com uma função específica. Compilador: traduz o código-fonte do plugin em código executável. Dependência: outro componente de que uma extensão necessita. Extension: extensão adicional do framework, frequentemente uma biblioteca compilada com um processo de instalação próprio. Hook: ligação a um evento no jogo. RCON: acesso remoto autorizado à consola do servidor. Rollback: restauro verificado de um estado anterior e coerente. Wipe: reposição de determinados dados de jogo; não é uma reparação geral de plugins.
O próximo passo mais sensato no servidor afetado é pequeno: guarda o log de arranque atual, verifica o framework que está realmente em execução e segue a primeira mensagem de erro. Só depois decides qual o componente individual que tem de ser alterado.
Fontes e estado da verificação
- Versões do Oxide.Rust no GitHub: versão atual 2.0.7894, de 6 de novembro de 2026, para o Rust 2636.290.1; testes históricos com a versão 2.0.7839, de 22 de outubro de 2026, e a versão 2.0.7072, de 19 de fevereiro de 2026.
- Registo de alterações do uMod para o Rust: entradas de outubro, incluindo a atualização de 22 de outubro de 2026.
- Documentação do Oxide: instalação de plugins,
oxide/logs, comandos, configuração, dependências e relatórios de erros. - Guia da Facepunch sobre o servidor dedicado: SteamCMD, App ID 258550 e Oxide após atualizações do jogo.
- Documentação do Carbon: comando de versão e configuração.
Estado da verificação: informações de versão verificadas a 6 de novembro de 2026; sem novo teste funcional com o Oxide.Rust 2.0.7894. Os três testes de erros foram realizados a 29 de outubro de 2026 num servidor de testes próprio e isolado, com o protocolo Rust 2635.289.1 e o Oxide.Rust 2.0.7839; o servidor de testes foi depois eliminado. Os números de versão destes testes históricos são, após novas atualizações do Rust, apenas um exemplo.