GDScript.CodeCompared.To/C#

C# has no global print. Output goes through Console.WriteLine, and the semicolon is not optional — statements are terminated rather than newline-delimited.

The $ prefix is what makes a string interpolated. Because the expression is written where it appears, adding a value never means renumbering anything, and the compiler checks each one.

The rename reaches the engine too — _ready is _Ready, queue_free is QueueFree, get_tree is GetTree. Godot renames its whole API for the C# bindings, so a method you know translates mechanically rather than needing to be looked up.

Indentation in C# is only for people — the compiler ignores it entirely. That means a misleadingly indented line is a readability bug rather than a behavior change, which is the opposite of the risk you are used to.

Reaching for object costs you everything the type system was going to do for you — you cannot call a string method on it without casting first. In practice C# code almost never uses it, which is the real difference: the escape hatch exists and is not the default.

The type is fixed at the declaration and cannot change afterwards, exactly as with :=. Assigning a string to speed on the next line is a compile error, not a runtime surprise.

This is the change most likely to catch you, and it fails loudly rather than quietly — if (health) does not compile. What you lose in brevity you gain in never having to remember which values a language considers empty.

GDScript writes the conversion as a call, float(x); C# writes it as a prefix cast, (float)x. C# also warns you far more often, because a conversion that could lose data has to be written down.

Printing a C# enum gives you Walking, not 1 — the name survives to runtime, so the State.keys()[current] lookup has no equivalent because it is not needed. Note the enum is declared after the statements: top-level statements come first in this runner.

The ? is the whole feature: it moves "can this be null?" out of your head and into the declaration, so the compiler can tell you about the case you forgot rather than the game finding it during a playtest.

A property is accessed like a field and computed like a method. You will meet the same pattern on Count for collections, which is why Length() is a compile error rather than a slower spelling.

Printing an array directly also differs — C# would show the type name rather than the contents, so this example joins it instead. That is a general habit worth forming early: collections do not print themselves in C#.

StringBuilder keeps one growable buffer and produces the finished string once. For a handful of items it does not matter, but this is the idiom C# code reaches for by default, so it is worth recognizing on sight.

TryParse returns whether it worked and writes the value through out, so one call does the checking and the converting together. The failed parse leaves parsed at 0 — the same value GDScript would have given you, but this time you were told.

Godot's C# bindings also ship Mathf, which offers the float-first, game-flavored versions of these — Mathf.Lerp, Mathf.DegToRad — matching the names you already know from GDScript.

Godot's C# API uses 32-bit float for positions and vectors, so the f suffix becomes reflex quickly. Leaving it off is one of the most common first-week compile errors, and it is caught at build time rather than in the game.

A counter that could exceed about two billion needs long, and the 1L suffix forces the arithmetic to happen in 64 bits rather than overflowing first and widening afterwards. Godot's own integer properties are int, so this mostly matters for your own tallies.

Next(1, 7) gives the inclusive-exclusive range directly, so the % 6 + 1 arithmetic disappears — along with the modulo bias it quietly carries. Godot's C# side also offers GD.Randi() if you want the engine's generator instead.

Negative indexing exists but is spelled differently: loot[^1] is the last element, where ^ means "from the end". Plain loot[-1] throws, because -1 is just an out-of-range index.

Writing List<object> is deliberately awkward, and that is the point — a heterogeneous collection is usually a design you would rather notice than inherit.

Note it is Length for an array and Count for a list — the two collections do not share a spelling. The unset slots are null rather than GDScript's <null> placeholder, which is why they are substituted here to print.

The C# side also swaps the dictionary for a tuple with named fields, so enemy.Hp is checked at compile time where enemy["hp"] could only fail when the frame ran. That substitution is the single most common shape change when porting GDScript data.

A missing key throws KeyNotFoundException rather than returning null, so the failure surfaces where the typo is rather than several lines later when something unexpectedly holds nothing.

That is why TryGetValue exists — it separates "was it there" from "what was it", so a legitimately stored zero cannot be confused with a missing key. In GDScript those two cases look identical.

The var (slot, item) form destructures each entry in place. Neither language promises an order here, so a sorted display still needs an explicit sort.

It also brings the set operations with it — UnionWith, IntersectWith, ExceptWith — which are the reason to use one rather than the deduplication alone.

Braces around a single statement are optional in C# but conventional, and Godot's own C# samples always include them. Omitting them is how the famous "second line looks like it is inside the if but is not" bug happens.

Forgetting break is a compile error rather than the silent fall-through C inherited, so the classic bug cannot happen. The _ catch-all is spelled default.

The compiler checks that every input is covered, so dropping the _ arm produces a warning about the case you did not handle. GDScript's match has no such check — a missing branch is simply a function that returns null.

The when clause adds a condition to a pattern, which is how the two int cases can differ. This is the feature with no GDScript equivalent at all, and it is what makes C# comfortable handling data whose shape is not known up front.

The loop variable is read-only inside the body, so a stray assignment to member is a compile error rather than a change that silently affects nothing.

The stop condition is written as the comparison rather than implied, which makes an inclusive range a matter of changing < to <= rather than remembering that range excludes its end.

The Select overload that takes an index is doing the work here. It reads as a mouthful the first time, and it removes the class of bug where the index and the collection drift apart.

C# adds do { ... } while (condition);, which runs the body once before testing. GDScript has no such form, so the pattern there is a while true with the test at the bottom.

The annotations are optional in GDScript and mandatory in C#. That is the trade in one line: you can no longer sketch a function and fill the types in later, and in exchange nothing can call it with the wrong ones.

The last call passes elite before count and still binds each to the right parameter. It also documents itself — Spawn("slime", 2, true) needs the declaration to interpret, and the named version does not.

Because the delegate carries its parameter and return types, passing a two-argument lambda where one is expected is a compile error. In GDScript that same mistake reaches you as a runtime error on the frame the callback fires.

Misspelling parts.Fyre does not compile, where parts["fyre"] would hand back null and fail somewhere else entirely. The tuple also costs no allocation, which the dictionary does.

The caller writes Describe either way and the compiler chooses by argument type. Overloading belongs to members of a type, which is why the two live in a class here — plain nested functions cannot share a name any more than GDScript's can. This is how Godot's C# API offers several shapes of one call, GetNode(path) and GetNode<T>(path), where GDScript would need two names.

Note public: C# members are private unless you say otherwise, where every GDScript member is reachable from anywhere. The class appears after the statements here because top-level statements must come first in this runner.

A read-only property is the C# default and takes one line. Adding { get; set; } makes it writable, and a full set body is where you would put the clamping that a health bar usually wants.

Both keywords are mandatory, which turns two silent GDScript bugs into compile errors: overriding a method the parent never meant to expose, and misspelling the name so you accidentally add a new method instead of replacing one.

The payoff is on the last two GDScript lines: first == second is false there, because two objects with identical contents are still two objects. A record compares by value, so the same expression is true and no hand-written equals is needed.

The interface is extra typing that buys a guarantee: adding a third class to that array without an Open method is a compile error rather than a crash the first time a player walks into the room containing it.

Every call above infers T from the arguments, so the generality costs nothing at the call site. Mixing them — a List<int> with a string fallback — does not compile, which the GDScript version would accept and then return the wrong kind of thing.

This is the distinction that decides most surprises when porting. A struct passed to a method is a copy, so mutating it inside changes nothing outside — which is exactly why Godot makes Vector2 one.

as is the other half — it converts, or yields null rather than throwing, which pairs with ?? to supply a fallback. A hard cast, (string)thing, throws instead, and that is the one to use when being wrong is a bug rather than a case.

Look at what the GDScript column has to do — return the unchanged balance, which is indistinguishable from a withdrawal of zero. C# stops the function, and an unhandled throw is loud rather than silent. The cost is that you must now decide where to catch.

finally runs whether the block completed, returned, or threw, so the cleanup is written once. This is the pattern behind using, which is how C# closes files and streams without anyone remembering to.

Catching LevelFormatException specifically means an unrelated failure is not swallowed by the same handler — the distinction the {"ok": false} dictionary cannot make, because every failure has the same shape.

Each step names what it does rather than how — Where keeps, Select transforms. Nothing runs until the result is consumed, so adding a .Take(2) on the end would stop the whole chain after two matches rather than filtering the entire list first.

Average returns a double without being asked, so the integer-division trap in the GDScript column simply does not arise. Min, Count and Any round out the set you will reach for daily.

The chain reads as the sentence you would say out loud: group by kind, order by key, then for each group list the names. Every step is checked, so a typo in unit.Kind stops the build rather than silently creating a bucket nobody looks in.

It stops at the first match exactly as the break did — the whole list is not scanned. First without OrDefault throws when nothing matches, which is the right choice when finding nothing is a bug rather than an answer.

GDScript awaits a signal — await get_tree().create_timer(1.0).timeout is the one every Godot developer writes first. C# awaits a Task, and inside Godot you bridge the two with await ToSignal(node, "signal_name"), which turns any signal into something awaitable.

C# puts it in the return type: Task<int> means "an int, later". Forgetting the await gives you the task instead of the number, and the compiler warns about it — the same mistake, caught before it ships.

This matters for exactly the case a loading screen has: three independent asset loads that need not be sequential. The GDScript column runs them in order because that is the only shape available.

Two things a Godot C# file always has: partial, because the build generates a companion half for the engine bindings, and delta as a double rather than a float. The cast to float when it meets a Vector2 is the most common first-day compile error.

That type parameter is doing real work: the returned value has the node's own members without a cast, and a path pointing at the wrong kind of node fails immediately with a clear message rather than at the first property you touch.

The ?.Invoke is there because an event with no subscribers is null — firing into nothing has to be written down rather than silently doing nothing as emit does. The handler's parameter types are checked when you subscribe, not when the signal fires.

The EventHandler suffix is required and then dropped — declare HealthChangedEventHandler, use HealthChanged. SignalName.HealthChanged is a generated constant, so emitting a signal you have not declared is a compile error rather than a silent no-op.

The hint variants translate as arguments rather than as separate annotation names: @export_range(0, 100) is [Export(PropertyHint.Range, "0,100")]. The field must be public, since the editor cannot reach a private one.

Look at the last line of each column: the variable is not null after the object is gone. In GDScript that leaves you a freed reference; in C# it leaves a live wrapper whose engine half has been destroyed, and touching a property on it throws ObjectDisposedException. The check is GodotObject.IsInstanceValid — is_instance_valid under its C# name — and it is worth reaching for anywhere a reference outlives a QueueFree. Nothing about .NET's garbage collector removes the need for it.

Every call has the same name with different capitalization, and entry.pressed.connect(...) becomes entry.Pressed += ... because a signal is an event on this side. The one real translation is the enum: Control.SIZE_EXPAND_FILL is SizeFlags.ExpandFill, since C# enums are nested types rather than integer constants on the class.

This row is also the clearest case for not reaching for C#. The per-frame work is eight points and one draw_polyline_colors, so the build step buys nothing. The rule worth taking away: move to C# where the work is per element, per frame — a particle solver, a mesh build, a pathfinder over thousands of cells — not where it is a fixed handful of engine calls, because every call across the boundary has a conversion cost that GDScript does not pay.