Voltar para o Blog
Quest Log

C# vs GDScript no Godot: Qual Escolher em 2026 (Sem Mito)

Comparação visual entre código C# e GDScript no Godot Engine

C# vs GDScript no Godot: performance real com benchmarks, uso de .NET, velocidade de iteração e carreira. Veja qual linguagem escolher no seu projeto.

Ferramenta:GodotC#

Toda vez que alguém começa no Godot, a mesma pergunta aparece: GDScript ou C#? No Godot 3 a resposta era quase sempre GDScript, porque o suporte a C# ainda engatinhava. No Godot 4 isso mudou. As duas linguagens são cidadãs de primeira classe, e aí a escolha deixa de ser óbvia.

Vou ser direto com você desde já: pra maioria dos projetos, a linguagem que você escolhe importa muito menos do que você imagina. O jogo trava por falta de escopo definido, não por causa do for loop. Mas a pergunta é legítima, então vamos resolver ela de uma vez, com base no que cada linguagem realmente entrega no Godot, sem torcida e sem mito. Se você ainda nem decidiu por onde começar, vale o panorama mais amplo de qual linguagem aprender para fazer jogos antes de afunilar pra essa comparação. E se a sua dúvida for trocar o Godot por uma engine em Rust, o comparativo Bevy ou Godot trata dessa escolha.

O que é cada uma no contexto do Godot

GDScript foi criada pela própria equipe do Godot, pra rodar dentro do Godot. A sintaxe lembra Python (indentação define os blocos), é dinamicamente tipada por padrão e aceita tipagem estática opcional. Ela carrega junto o editor: autocomplete, documentação inline com Ctrl+Click, debugger integrado. Você abre o Godot e já programa, sem instalar mais nada.

C# é uma linguagem de propósito geral da Microsoft. Estaticamente tipada, compilada, com o ecossistema .NET inteiro por trás (NuGet, Visual Studio, Rider). No Godot ela roda pela versão .NET do engine, que você baixa separado da versão padrão. É a mesma linguagem que a Unity usa, então quem vem de lá já chega em casa. Se você ainda está decidindo entre as duas engines, vale ler antes o comparativo Godot vs Unity. O Rider, aliás, hoje atende GDScript também, como explico no post sobre o patrocínio da JetBrains à Godot e o que o Rider faz na engine.

Uma diferença prática que poucos comentam: GDScript é interpretada e roda dentro do engine, enquanto C# é compilada e roda sobre o runtime do .NET. Isso explica boa parte do que vem a seguir, desde a velocidade de iteração até o tamanho do build.

Performance: onde a diferença aparece de verdade

Performance costuma ser a primeira preocupação de quem escolhe linguagem, e quase sempre pela razão errada.

A real é a seguinte: a maior parte do trabalho pesado no Godot acontece em C++, dentro do engine. Quando você chama move_and_slide(), queue_free() ou move um nó, quem executa é o C++ do Godot, não o seu script. Tanto faz se você escreveu a chamada em GDScript ou em C#: o custo dela é praticamente o mesmo. Por isso, em código que é majoritariamente "conversa com a engine" (gameplay normal, UI, animação, input), a diferença de linguagem é pequena demais pra você sentir.

A diferença aparece quando o gargalo está no SEU código, não na engine. Loops apertados em puro script, processando milhares de iterações por frame, é onde C# ganha terreno, porque é compilado e tem um runtime mais maduro pra esse tipo de trabalho. GDScript melhorou muito no Godot 4, mas ainda é interpretada, e o quanto ela perde aqui depende de um detalhe que quase todo benchmark ignora: você tipou o código ou não. Já explico.

Onde C# tende a ganhar:

  • Loops longos rodando lógica pura em script, milhares de iterações por frame
  • Pathfinding complexo ou geração procedural escrita à mão (veja como isso aparece na prática em IA para jogos no Godot)
  • Simulações e manipulação de grandes volumes de dados na CPU

Onde a diferença some na prática:

  • Lógica de gameplay comum, máquinas de estado, timers
  • UI, menus, HUD
  • Qualquer chamada que delega o trabalho pesado pra engine

Não vou te dar um número de "X% mais rápido", porque esse número depende do que você está medindo, da versão do Godot e de como o código foi escrito. Quem te promete um percentual fixo está vendendo certeza que não existe. Se performance for crítica pro seu caso, meça você mesmo: o Godot tem um profiler embutido (aba Debugger), e ele te diz exatamente qual função está custando caro.

O detalhe que quase todo benchmark erra: tipe o seu GDScript

Aqui está o ponto que derruba a maioria das comparações que você vê por aí. O GDScript é dinamicamente tipado por padrão, mas aceita tipagem estática opcional. E essa escolha muda muito a performance.

Quando você NÃO declara o tipo (var vida = 100), o interpretador precisa descobrir, a cada operação, qual é o tipo do valor e qual operação aplicar. Quando você declara (var vida: int = 100), o compilador do GDScript já sabe o tipo e usa instruções otimizadas, pulando essa checagem. O ganho é real e medido pela própria equipe do Godot no relatório de instruções tipadas: aritmética fica cerca de 25 a 50% mais rápida, chamadas de função de classe nativa de 70 a 150%, e iteração de 10 a 50%. Em teste independente de cálculo pesado (distância de Vector2 em bilhões de iterações), o código tipado chegou a rodar quase 60% mais rápido que o não tipado.

Por que isso importa pra essa comparação? Porque a maioria dos testes de "C# vs GDScript" que circulam mede o C# contra GDScript NÃO tipado, ou seja, contra o pior caso possível do GDScript. Aí o C# parece arrasar. Quando você tipa o GDScript, boa parte dessa distância evapora. Antes de acreditar em qualquer benchmark, olhe três coisas: o GDScript estava tipado? Qual versão do Godot? E o que exatamente estava sendo medido? Muito teste por aí falha em pelo menos uma dessas, e aí o número não vale o pixel em que está escrito.

O mesmo código, agora tipado, fica assim:

extends Node

var health: int = 100
var speed: float = 300.0

func take_damage(amount: int) -> void:
    health -= amount
    if health <= 0:
        die()

Repare nos : int, : float e -> void. É pouco esforço a mais pra escrever, deixa o código mais legível, e ainda faz o editor te avisar de erro de tipo antes de rodar. Se tipagem em GDScript ainda é novidade pra você, o guia de variáveis e tipos no GDScript mostra como declarar cada tipo direito.

Agora, a parte honesta que poucos completam: tipar encurta bastante a distância, mas não zera ela no trabalho mais pesado de CPU. Pra loop puro de número, simulação ou geração procedural intensa, o C# compilado ainda tende a sair na frente, porque roda sobre um runtime mais maduro. O que muda é a régua: a diferença sai de "gritante" (quando comparam com GDScript não tipado) para "existe, mas só pesa em caso extremo". No resto, que é a esmagadora maioria do seu jogo, ela some no ruído.

Concorrência: a porta que o C# abre e o GDScript entreabre

Tem um ponto técnico que quase nunca entra nessas comparações e que pode decidir o seu caso: processamento paralelo de verdade. O C# traz o modelo de async/await e a biblioteca de Task do .NET, além de acesso maduro a múltiplas threads do sistema. Se o seu jogo precisa rodar algo pesado em paralelo sem travar o frame (gerar um mundo grande, carregar e tratar dados em segundo plano, rodar uma simulação própria), o C# te dá ferramenta rodada pra isso.

O GDScript não fica sem saída: ele tem a classe Thread e o WorkerThreadPool, e dá pra tirar trabalho pesado da thread principal. O que muda é a maturidade e o conforto. O ecossistema .NET acumulou anos de biblioteca e padrão em cima de concorrência; em GDScript você monta mais na mão. Nos dois casos vale o mesmo aviso de segurança: a árvore de cena do Godot não é thread-safe, então nó só se mexe pela thread principal, e o resultado do trabalho paralelo volta por sinal ou call_deferred.

De novo, isso só pesa se o seu jogo de fato faz processamento paralelo intenso. A maioria não faz, e aí essa porta fica fechada sem prejuízo nenhum.

A regra que vale pra 90% dos casos

Escreva primeiro. Faça o jogo funcionar. Se em algum momento o profiler apontar que uma função específica em script é o gargalo, aí sim você reescreve aquela parte em C# (ou otimiza o algoritmo, que muitas vezes resolve mais que trocar de linguagem). Otimizar antes de ter um problema medido é a forma mais comum de não terminar o jogo.

Black Friday: leve 3, pague 2
Travou no código ou na arte? Na Black Friday, leve os dois.

Curso de Godot + curso de Arte 2D + um curso bônus que você só descobre lá dentro. De R$ 2.691 por R$ 997, acesso vitalício, em até 18x no cartão.

Quero os 3 cursos com Godot
Suporte no WhatsAppAcesso vitalício7 dias de garantia

Facilidade de aprendizado

Se você está começando, a curva da linguagem pesa, e pesa mais do que a performance.

GDScript: menos cerimônia

GDScript foi feita pra você escrever pouco e ler fácil. Um controlador de movimento 2D completo cabe em poucas linhas:

extends CharacterBody2D

var speed = 300.0

func _physics_process(delta):
    var direction = Input.get_vector("left", "right", "up", "down")
    velocity = direction * speed
    move_and_slide()

Os nomes "left", "right", "up" e "down" são ações que você cadastra no Input Map do projeto; se nunca configurou isso, o guia de Input Map e controles no Godot mostra como mapear teclado e controle de uma vez. Repare no que NÃO está aí: nenhum using, nenhum modificador de acesso, nenhum tipo declarado obrigatoriamente. A indentação define a estrutura, e pronto. Isso reduz o atrito pra quem está aprendendo lógica de jogo pela primeira vez, porque você gasta sua energia pensando no jogo, não na cerimônia da linguagem.

Outros pontos a favor de quem começa:

  • Tipagem estática é opcional. Você pode começar dinâmico e adicionar tipos (var speed: float = 300.0) quando se sentir confortável.
  • A documentação do engine abre dentro do próprio editor com Ctrl+Click no nome de qualquer classe.
  • Todo tutorial, exemplo e resposta de fórum do Godot, na esmagadora maioria, está em GDScript. Quando você travar, vai achar a solução pronta. Se quiser partir do absoluto zero, o guia de GDScript do zero cobre a sintaxe sem pressupor nada.

C#: mais estrutura, mais a digitar

O mesmo controlador em C# fica assim:

using Godot;

public partial class Player : CharacterBody2D
{
    private float speed = 300.0f;

    public override void _PhysicsProcess(double delta)
    {
        Vector2 direction = Input.GetVector("left", "right", "up", "down");
        Velocity = direction * speed;
        MoveAndSlide();
    }
}

Funciona igual, mas você teve que escrever mais: o using, a classe public partial, o tipo de retorno, os tipos das variáveis. Para quem nunca programou, são vários conceitos chegando de uma vez (namespace, classe, modificador de acesso, tipo). Isso atrasa o "primeiro jogo rodando", que é o momento que mais segura iniciante.

Dois detalhes que pegam quem vem da Unity: no Godot, os callbacks têm underscore na frente (_PhysicsProcess, _Ready, _Process) e os métodos da API seguem PascalCase em C#, mas snake_case em GDScript. É o mesmo método por baixo, só muda a convenção de nome conforme a linguagem.

Em compensação, depois que você passa da curva, a estrutura do C# vira vantagem: o compilador te avisa de erros de tipo antes de rodar, o IntelliSense do Visual Studio ou Rider é excelente, e refatorar código grande é mais seguro.

Sobre "quanto tempo leva pra aprender": isso varia demais de pessoa pra pessoa pra eu cravar semanas ou meses. O que é consistente é a ordem: GDScript te coloca rodando algo mais rápido, C# cobra mais antes de te dar o primeiro jogo, mas paga melhor em projeto grande.

Recomendação por perfil

Vai de GDScript se você:

  • Nunca programou, ou só conhece Python
  • Quer ver um jogo rodando o quanto antes
  • Está fazendo protótipo ou game jam, onde velocidade de iteração é tudo

Vai de C# se você:

  • Já manja C#, Java, C++ ou veio da Unity
  • Está confortável com tipagem estática e quer o compilador te protegendo
  • Já sabe que o projeto vai ser grande e durar meses

Ecossistema e ferramentas

A linguagem não vive sozinha. O que existe em volta dela muda o dia a dia.

GDScript é casada com o Godot. A vantagem é a integração total: hot reload de script que reflete na hora, debugger e profiler já ali, documentação inline, zero setup. A desvantagem é o outro lado da mesma moeda: você só usa GDScript dentro do Godot, e a biblioteca disponível é basicamente o que a API do engine oferece. Não existe um "NuGet do GDScript".

C# traz o ecossistema .NET junto. Isso significa milhares de pacotes no NuGet, IDEs poderosas (Visual Studio, Rider) com refatoração avançada, e bibliotecas maduras pra coisas que a API do Godot não cobre nativamente. O custo: setup mais chato (você precisa da versão .NET do Godot e de um SDK instalado), build maior, e o hot reload não é tão imediato quanto em GDScript, porque envolve recompilação.

.NET vs Godot: não é uma escolha, é o mesmo engine com C# ligado

Vale desfazer uma confusão comum de quem pesquisa ".NET vs Godot". Não existe disputa entre as duas coisas: ".NET" não é uma engine concorrente do Godot, é o runtime da Microsoft que roda C#. O que existe é o Godot .NET (antigo Godot Mono), um build oficial do próprio Godot que vem com o suporte a C# embutido. O Godot padrão e o Godot .NET são o mesmo editor, as mesmas cenas, os mesmos nós; o build .NET só adiciona a camada que deixa você programar em C# além de GDScript.

Isso vale igual nas versões estáveis atuais da linha 4.7.x: os dois binários saem do mesmo lançamento, na mesma data, com as mesmas features de engine. Na prática, a decisão é só qual binário baixar na página de downloads:

  • Godot padrão: menor, abre e roda na hora, GDScript e GDExtension (C++). É o suficiente pra esmagadora maioria dos projetos.
  • Godot .NET: o mesmo engine + suporte a C#. Exige um SDK do .NET instalado na máquina, gera build final um pouco maior e o ciclo de recompilação é um pouco mais lento. Só faz sentido se você de fato vai escrever C#.

Um projeto feito no Godot padrão abre sem problema no Godot .NET; o contrário também, desde que ele não use scripts C#. Ou seja: você não fica preso à escolha, dá pra migrar depois se mudar de ideia. Quem programa só em GDScript não ganha nada baixando a versão .NET, ela só adiciona peso e um passo de setup que você não vai usar. Se você decidir pelo C#, o passo a passo de baixar o binário certo e ligar o ambiente está em como usar C# na Godot 4.

Sobre multiplayer

Os dois fazem multiplayer. O Godot tem uma API de alto nível (High-Level Multiplayer) que funciona bem em GDScript pra sincronização de estado, RPCs e spawner de rede. Pra muito projeto, isso já basta.

Quando o multiplayer fica pesado, com lógica de rede customizada, serialização sob medida ou integração com serviços externos, o ecossistema .NET dá mais opções de bibliotecas testadas. Não é que GDScript "não dá conta", é que em C# você acha mais ferramenta pronta pra casos complexos.

O ciclo de iteração: onde o GDScript ganha tempo todo dia

Performance de execução é o que todo mundo compara. O que quase ninguém mede é a performance de iteração: quantas vezes por hora você muda uma linha e vê o resultado. E aí o GDScript tem uma vantagem concreta, que pesa mais no dia a dia do que qualquer benchmark de loop.

Em GDScript, você salva o script e o Godot recarrega na hora, sem recompilar nada. Com o jogo rodando, muita mudança já reflete sem nem reiniciar a cena. O loop "mudo, salvo, vejo" é quase instantâneo.

Em C#, salvar não basta: o Godot .NET precisa recompilar o assembly antes de rodar. Num projeto pequeno isso leva poucos segundos; num projeto grande, o tempo cresce e some com aquele estado de fluxo em que você testa dez variações de um pulo em dois minutos. O hot reload de C# no Godot existe e melhorou, mas ainda é menos imediato que o do GDScript, e algumas mudanças estruturais pedem reiniciar a cena de qualquer jeito.

Por que isso decide mais do que parece: no começo de um jogo, você passa a maior parte do tempo ajustando número (velocidade, dano, alcance, timing). Cada segundo de espera entre salvar e testar, multiplicado por centenas de ajustes por dia, vira hora perdida. É por isso que, pra protótipo e game jam, o GDScript costuma ganhar até de quem já sabe C#: não é a linguagem que é melhor, é o ciclo que é mais curto.

O critério prático: se o seu dia é ajustar gameplay no detalhe, priorize o ciclo curto (GDScript). Se o seu dia é construir sistema grande que compila uma vez e roda muito, o custo de compilar se dilui no resto e a estrutura do C# compensa. Vale experimentar os dois direto no editor; se ainda não tem o Godot configurado, o hub de tutoriais e recursos de Godot reúne o material por tema.

Empregabilidade e mercado de trabalho

Se a sua meta é trabalhar pra fora, vale pensar em transferibilidade.

C# é uma habilidade que viaja. É a mesma linguagem que a Unity usa, e a Unity ainda domina grande parte das vagas de games no mercado. Se o seu caminho acabar indo pra ela, o hub de tutoriais e recursos de Unity reúne o material por tema. Mais que isso: C# é usado fora de games inteiro (web com .NET, desktop, backend), então a mesma habilidade abre porta em outras áreas de tech. Quem aprende C# não fica preso ao Godot nem a games. Se quer um plano de estudo pra essa linha, vale avaliar se um curso de C# para jogos vale a pena.

GDScript é específica do Godot. Como o Godot é uma fatia menor do mercado profissional do que a Unity ou a Unreal, vagas pedindo GDScript explicitamente são mais raras. A boa notícia: como a linguagem é simples, um estúdio que usa Godot raramente exige experiência prévia em GDScript. Quem já programa aprende em pouco tempo, e o que esses estúdios olham de verdade é o seu portfólio de jogos publicados, não a linha "GDScript" no currículo.

Não vou te jogar percentuais de vaga aqui, porque número de mercado muda rápido e varia por região e por fonte. O padrão que se sustenta é esse: C# tem mais transferibilidade imediata pra emprego; GDScript te faz publicar mais rápido, e portfólio publicado é o que mais pesa quando o estúdio é Godot.

Estratégia de carreira que faz sentido

  1. Aprenda GDScript primeiro, porque ela te leva ao primeiro jogo publicado mais rápido.
  2. Publique de verdade. Dois ou três jogos pequenos terminados valem mais que dez protótipos na gaveta.
  3. Quando tiver base, aprenda C#. Depois de dominar uma linguagem, a segunda vem rápido, porque os conceitos se repetem.
  4. Tenha as duas no portfólio com projetos que você consiga mostrar rodando.

Casos de uso

Diferentes projetos pedem ferramentas diferentes.

GDScript brilha em:

  • Protótipos e game jams, onde iterar rápido vale mais que tudo
  • Jogos 2D em geral, a performance sobra
  • Seu primeiro projeto no Godot, pra você focar em fazer jogo, não em sintaxe
  • Projetos solo ou de equipe pequena
  • Jogos narrativos, puzzle e qualquer coisa que não seja pesada de CPU

C# faz mais sentido em:

  • Projetos grandes com várias pessoas, onde a tipagem estática segura o código
  • Multiplayer complexo que precisa de bibliotecas .NET
  • Geração procedural ou simulação intensiva escrita à mão
  • Portar lógica de um projeto Unity existente
  • Integrações com SDKs e serviços externos que já vêm com wrapper C#

Dá pra usar as duas no mesmo projeto

O Godot permite misturar. Você pode ter o gameplay e a UI em GDScript, pela velocidade de iteração, e escrever em C# só aquele sistema específico que precisa de performance ou de uma biblioteca .NET. Um nó em GDScript consegue acessar um nó em C# e vice-versa, contanto que você esteja na versão .NET do engine. Não é a configuração mais comum pra quem está começando, mas é uma porta que existe quando o projeto pede.

Na prática: um nó C# e um nó GDScript conversando

Dá pra sair do "é possível" e ver como fica na mão. Imagine um sistema de cálculo de dano que você escreveu em C# por causa de uma biblioteca .NET, com o resto do inimigo em GDScript. Primeiro o nó em C#, tipado:

using Godot;

public partial class DamageSystem : Node
{
    [Export] public float Multiplier { get; set; } = 1.5f;

    public int CalculateDamage(int baseDamage, bool isCritical)
    {
        float result = baseDamage * Multiplier;
        if (isCritical)
            result *= 2.0f;
        return (int)result;
    }
}

Do lado do GDScript, você pega esse nó e chama o método como se fosse qualquer outro. O nome segue o PascalCase do C# (CalculateDamage), não o snake_case do GDScript:

extends CharacterBody2D

@onready var damage_system: Node = $DamageSystem

func hit_enemy(enemy: Node, is_critical: bool) -> void:
    var final_damage: int = damage_system.CalculateDamage(20, is_critical)
    enemy.take_damage(final_damage)

O caminho inverso também vale: um nó em C# acessa um método GDScript com Call("take_damage", 20). Dois avisos honestos pra não te pegar de surpresa. Primeiro, nessa fronteira você perde parte da checagem de tipo: o GDScript enxerga o nó C# como Node genérico, então erro de nome de método só estoura em runtime, não no editor. Segundo, toda chamada que cruza de uma linguagem pra outra tem um custo a mais que uma chamada dentro da mesma linguagem; é irrelevante pra uma chamada por frame, mas evite cruzar a fronteira dentro de um loop apertado, que é justo o lugar onde você foi pro C# buscar performance.

Por isso o padrão que funciona é desenhar a divisão por sistema, não por linha. Um sistema inteiro fica em C#, outro inteiro em GDScript, e os dois se falam em pontos de contato poucos e claros. Picar o mesmo sistema entre as duas linguagens só multiplica a travessia de fronteira e te entrega o pior dos dois mundos. Na dúvida, comece tudo numa linguagem só e abra a exceção em C# apenas quando o profiler apontar um gargalo real de CPU no seu código.

Migrar de uma pra outra é tranquilo

Você não casa com a primeira escolha. A lógica do seu jogo não muda quando você troca de linguagem, só a sintaxe muda.

Veja a mesma função de dano nas duas. Em GDScript:

extends Node2D

var health: int = 100
var speed: float = 300.0

func take_damage(amount: int) -> void:
    health -= amount
    if health <= 0:
        die()

E o equivalente em C#:

using Godot;

public partial class Player : Node2D
{
    private int health = 100;
    private float speed = 300.0f;

    public void TakeDamage(int amount)
    {
        health -= amount;
        if (health <= 0)
            Die();
    }
}

A lógica é a mesma linha por linha. O que muda na prática quando você converte:

  • Snake_case (take_damage) vira PascalCase (TakeDamage) nos métodos e propriedades da API
  • Os tipos viram obrigatórios e explícitos em C#
  • Entram as chaves e o ;, e a indentação deixa de ser o que define o bloco
  • A classe ganha public partial e os using necessários no topo

Por isso, se você já escreve GDScript com tipagem estática, a passagem pra C# é quase mecânica. Eu não recomendo confiar em conversor automático pra isso: faz mais sentido reescrever à mão num projeto pequeno, porque é nessa hora que você de fato aprende a segunda linguagem.

Meça você mesmo: o micro-benchmark que encerra a discussão

Eu repeti "meça" várias vezes aqui. Então vamos sair do discurso e ver como medir de verdade, porque benchmark de internet quase sempre compara coisas diferentes. A ideia é rodar o MESMO cálculo pesado nas duas linguagens, no mesmo Godot, e cronometrar com o relógio de alta resolução do próprio engine.

Em GDScript, sempre tipado, usando Time.get_ticks_usec() (tempo em microssegundos):

extends Node

func _ready() -> void:
    var iteracoes: int = 20_000_000
    var inicio: int = Time.get_ticks_usec()

    var soma: float = 0.0
    for i: int in range(iteracoes):
        soma += sqrt(float(i)) * 0.5

    var fim: int = Time.get_ticks_usec()
    var ms: float = (fim - inicio) / 1000.0
    print("GDScript tipado: %.1f ms (soma=%.2f)" % [ms, soma])

O equivalente em C#, com o Stopwatch do .NET:

using Godot;
using System.Diagnostics;

public partial class Benchmark : Node
{
    public override void _Ready()
    {
        int iteracoes = 20_000_000;
        var sw = Stopwatch.StartNew();

        double soma = 0.0;
        for (int i = 0; i < iteracoes; i++)
            soma += Mathf.Sqrt(i) * 0.5f;

        sw.Stop();
        GD.Print($"C#: {sw.Elapsed.TotalMilliseconds:F1} ms (soma={soma:F2})");
    }
}

Três cuidados que fazem o número valer alguma coisa:

  • Rode a build de release exportada, não o editor. No editor o GDScript carrega verificações extras de debug e o C# nem sempre está com todas as otimizações ligadas. Numa build exportada a comparação muda de figura, pra valer.
  • Compare tipado com tipado. Se você rodar o GDScript acima SEM os : int e : float, o tempo dispara, e aí você estaria medindo o pior caso do GDScript contra o C#, que é exatamente o erro que denunciei lá em cima.
  • Rode algumas vezes e descarte a primeira. A primeira passada paga custo de aquecimento (o JIT do C# compilando, cache frio nos dois). O número que importa é o das rodadas seguintes, já estáveis.

Quando você faz isso direito, o padrão costuma se repetir: o C# sai na frente nesse tipo de loop puro de número, mas por uma margem bem menor do que os benchmarks com GDScript não tipado alardeiam. E o detalhe decisivo: troque esse loop sintético por código real do seu jogo, que a cada linha chama a engine, e a diferença encolhe de novo, porque o trabalho pesado volta pro C++ do Godot nos dois casos. É por isso que eu insisto: meça o SEU gargalo, não o benchmark genérico de outra pessoa.

Resumo rápido

AspectoGDScriptC#
SetupZero, já vem no GodotVersão .NET do Godot + SDK
Curva inicialMais suaveMais íngreme
IteraçãoHot reload imediatoRecompila, um pouco mais lento
PerformanceÓtima pra gameplay; perde em loop pesadoGanha em loop pesado de CPU
TipagemOpcionalObrigatória
EcossistemaAPI do Godot.NET inteiro (NuGet)
TransferibilidadeSó GodotUnity, web, desktop, backend
Tutoriais/comunidadeMaioria do material GodotMenos material específico de Godot
BuildMenorMaior

Conclusão: qual escolher

Não tem resposta única, tem resposta pro seu caso.

Se você está começando, é iniciante em programação, ou quer ver um jogo rodando rápido: comece com GDScript. Você publica antes, constrói portfólio antes, e aprende os fundamentos de game dev sem brigar com a linguagem. C# pode entrar depois, quando você precisar.

Se a sua prioridade é emprego e transferibilidade, ou se você já vem da Unity e domina C#: vá de C#. Ele abre mais portas fora do Godot e te dá o compilador como rede de segurança em projetos grandes.

Se você pretende viver disso a longo prazo, vai acabar conhecendo as duas. Depois da primeira, a segunda vem em semanas, e poder escolher a ferramenta certa pra cada situação é uma vantagem real.

No fim, as duas publicam jogos de verdade. O que decide se você termina o projeto não é a escolha entre C# e GDScript: é definir o escopo, sentar e construir. Escolha uma, comece hoje, e aprenda a outra quando o jogo pedir.

Se o seu interesse por C# for além do Godot, vale saber que existem caminhos que usam a linguagem sem editor visual nenhum: veja o que muda no MonoGame 3.8.5, o framework em C# que exige montar o jogo só no código.

Perguntas frequentes

C# é mais rápido que GDScript no Godot 4?

Em código que conversa com a engine (gameplay normal, UI, animação, input) a diferença é pequena demais para sentir, porque o trabalho pesado roda em C++ dentro do Godot nos dois casos. C# ganha terreno quando o gargalo está no seu próprio código: loops apertados, pathfinding complexo ou geração procedural escrita à mão. Mas tem um detalhe que muda muito o resultado: tipe seu GDScript (use var x: int). GDScript tipado é bem mais rápido que o não tipado, e a maioria dos benchmarks que mostram o C# arrasando usa GDScript não tipado, que é o pior caso. Tipando, boa parte da diferença some, embora o C# ainda saia na frente no compute pesado de verdade.

GDScript tipado é mais rápido que o não tipado?

É, e a diferença é grande. Quando você declara os tipos (var vida: int = 100), o GDScript usa instruções otimizadas e pula a checagem de tipo que o código dinâmico faz a cada operação. A própria equipe do Godot mediu ganhos da ordem de 25 a 50% em aritmética e de 70 a 150% em chamadas de função nativa. Por isso, se você liga para performance em GDScript, tipe o seu código. E desconfie de benchmark de C# contra GDScript que usa GDScript não tipado: está medindo contra o pior caso.

GDScript ou C# para quem está começando no Godot?

GDScript. A sintaxe lembra Python, não exige declarar tipos nem classes, e todo tutorial e resposta de fórum do Godot está em GDScript. Você vê um jogo rodando mais rápido e foca em aprender game dev em vez de brigar com a cerimônia da linguagem. C# faz mais sentido depois, quando você já tem base ou já vem da Unity.

Qual a diferença entre o Godot normal e a versão .NET?

A versão .NET (também chamada Godot Mono) é um build separado do engine que adiciona suporte oficial a C#. O Godot padrão roda só GDScript e C++ via GDExtension. Para programar em C# você precisa baixar a versão .NET e ter um SDK do .NET instalado; o build final fica um pouco maior e o hot reload é menos imediato por causa da recompilação.

Dá para usar C# e GDScript no mesmo projeto?

Dá, desde que você esteja na versão .NET do Godot. Um nó em GDScript acessa um nó em C# e vice-versa. O padrão comum é gameplay e UI em GDScript, pela velocidade de iteração, e só os sistemas que pedem performance ou uma biblioteca .NET específica em C#.

Aprender GDScript vale a pena para o mercado de trabalho?

GDScript é exclusivo do Godot, então a sintaxe não transfere para outras engines, mas a lógica de programação sim. Estúdios que usam Godot raramente exigem GDScript prévio porque a linguagem é simples de pegar. O que pesa de verdade na contratação é portfólio de jogos publicados. Se a meta é empregabilidade ampla, C# transfere para Unity, web e backend .NET.

C# funciona em todas as plataformas de export do Godot?

Na maioria sim (desktop e mobile), mas o export de C# para web (HTML5) historicamente foi o ponto fraco do Godot .NET e demorou a ficar disponível. Se web é destino do seu jogo, confirme o suporte a C# na versão exata que você vai usar antes de se comprometer; em GDScript o export para web não tem essa ressalva. Para o resto das plataformas, as duas linguagens caminham juntas.

Vale a pena migrar um projeto de GDScript para C# no meio do caminho?

Só se você tiver um gargalo medido no profiler que seja de fato código seu rodando em loop pesado, e não chamada de engine. Reescrever um projeto inteiro que já funciona raramente paga: você gasta semanas convertendo sintaxe e reintroduzindo bugs em vez de terminar o jogo. O caminho mais sensato, quando precisa, é misturar: deixe o que já roda em GDScript e escreva só o sistema pesado novo em C#, já que o Godot .NET deixa as duas linguagens conversarem no mesmo projeto.