Lua.CodeCompared.To/GDScript

Godot also offers print_rich for BBCode markup and printerr for the error stream. The one to avoid out of habit is prints, which joins its arguments with spaces — it looks like a typo for print and is not.

Godot's editor uses tabs by default and mixing them with spaces is a parse error, not a style complaint. There is no end to hunt for when a block closes in the wrong place — the indentation is the only signal.

There is no multi-line comment at all — the editor's comment-selection shortcut exists because commenting a region means prefixing every line. A triple-quoted string is sometimes used as a stand-in, but it is a real string that gets evaluated and discarded.

That is why every GDScript file starts with extends and why its variables are the node's state rather than a table you built. The right column cannot run on this page for exactly that reason: there is no scene tree here, and the runner evaluates snippets at method scope.

The := form infers the type and locks it in; the : String = form states it. Both are checked at compile time and both let Godot generate faster code, which is the practical reason to bother — an untyped GDScript variable is a Variant and every operation on it goes through a slower path.

typeof returns a numeric constant rather than a name, so the printed values are Godot's TYPE_INT and TYPE_STRING enum members. That is a small but real difference from Lua's type, which returns a readable string.

A const must be computable at compile time, so it cannot hold anything built at run time. Godot also has enum for a named set of integers, which Lua approximates with a table of numbers and no checking.

Every name must be declared before use, so the typo becomes a compile error rather than a mysterious shared variable. Godot's equivalent of a deliberate global is an autoload singleton, which is registered in the project settings rather than created by assignment.

GDScript also has no multiple return values, so this limitation shows up again in the Functions section — a function that wants to hand back two things returns an array or a dictionary.

So if health then in Lua is true for a health of zero — a dead player passes the check — and the same shape in GDScript correctly reports empty. Any guard ported between the two changes meaning silently, and a zero health or an empty inventory is exactly where it bites.

Indexing a dictionary with a key it does not have raises at run time. Use get(key), which returns null, or get(key, default), or test with has(key) first. This is a genuine source of crashes for anyone carrying Lua habits over.

erase is the removal operation, and it returns whether the key was actually there. Carrying the Lua habit over produces a dictionary that keeps growing and whose size() never goes down.

GDScript's conditional expression is written value if condition else other, borrowed from Python. Spelling the test out — != null rather than relying on truthiness — is the habit that keeps a legitimate zero from being replaced by a default.

This is the most common numeric bug when moving from Lua. 7 / 2 is 3, with no warning, and it appears most often in halving a screen dimension or averaging two positions. Make one side a float.

A var count: int assigned a float truncates rather than erroring, which is worth knowing when a computed position feeds an index. Godot's float is 64-bit in GDScript but many engine APIs store 32-bit, so round-tripping through a Vector loses precision.

Godot adds the ones a game needs and Lua lacks: clamp, lerp, move_toward, deg_to_rad, snapped, and randi_range. Note also the % operator on a string, which is GDScript's string.format.

The % operator takes a single value or an array of them and uses the same printf-style placeholders Lua's string.format does. Godot also has format with named placeholders, which Lua has no equivalent of.

So Lua's sub(2, 3) — characters two through three — becomes substr(1, 2): start at index one, take two characters. Translating positions and endpoints in one step is where off-by-ones creep in.

Note the receiver on join: the separator is the string and the array is the argument, which is the opposite of Lua's table.concat(parts, "|") and easy to write backwards.

That ceremony is why simple work usually reaches for split, begins_with or contains instead. Compiling in a loop is a real performance mistake — build the RegEx once and keep it.

That means the common Lua entity table — array part for children, named fields for properties — has to be split in two, or become a class. It is usually the largest mechanical change in porting a LÖVE codebase.

Unlike Lua, reading past the end is an error rather than nil, so an off-by-one crashes instead of quietly producing an empty value. That is friendlier in the long run and startling at first.

There is no built-in equivalent of ipairs giving you the index alongside the value — use range(array.size()) when you need it. Dictionary iteration order is insertion order and is guaranteed, unlike Lua's pairs, which is explicitly unspecified.

Godot ships considerably more of them than Lua does — filter, map, reduce, any, all, find, pick_random, shuffle — where Lua leaves you to write the loop.

A typed array rejects a wrong-typed append at run time and lets Godot store the elements more compactly. Godot also ships packed arrays — PackedInt32Array, PackedVector2Array — which are contiguous native memory and matter for mesh and particle data.

duplicate() is the shallow copy, matching Lua's table.unpack idiom, and duplicate(true) is a deep copy — which Lua has no built-in equivalent of at all. Note that Godot's built-in value types such as Vector2 are copied, not shared, which is the opposite of what a Lua table holding {x, y} would do.

Remember the truthiness section applies to the condition itself: a bare if count: is false for zero here and true in Lua, so the port needs reading rather than translating.

It matches on value, on type, on array shape with a binding ([x, y]), and on dictionary shape, with _ as the catch-all. There is no fall-through between arms, so no break is needed. This is one of the genuinely nicer things waiting on the Godot side.

A single argument, range(5), counts 0 through 4 — which pairs with zero-based indexing and is the form you will write most. The three-argument form takes a step, negative included, exactly as Lua's third expression does.

GDScript has the keyword outright and also has compound assignment (countdown -= 1), which Lua lacks entirely — every Lua increment must be written x = x + 1.

The translation is a while true with the test moved to the bottom as a break. Note the condition keeps Lua's sense — it stops when the condition becomes true — rather than being inverted the way a do…while translation would require.

A named func must live at class scope, which is why this column cannot run on this page — both runners evaluate a snippet inside a method body. The lambda in the next row is the form that does work there.

That .call() is easy to forget and the error is not obvious. The payoff is that a Callable plugs straight into map, filter, reduce and sort_custom, and into signal connections — none of which Lua ships.

A dictionary is usually the better choice: the caller reads result["low"] rather than remembering which position came first. Godot's own APIs mostly return a single object with named properties for the same reason.

A real default parameter applies only when the argument is genuinely absent, so it has no such hole. GDScript also checks the argument count, so calling with too few arguments is an error rather than silently passing nil.

The workaround is to capture something mutable — an array or dictionary — and mutate through it, as above. Anyone porting Lua code that leans on upvalue mutation needs to check every closure; the code compiles and silently keeps returning 1.

The correspondence is close: Enemy.__index = Enemy is what the class already is, setmetatable is what new() does, and the colon method is a func with an implicit self. Having it built in mostly means everyone writes it the same way.

Writing self.count is legal and occasionally necessary — to disambiguate from a local of the same name, or to pass the instance itself. The everyday case needs no prefix at all, and there is no colon-versus-dot mistake to make.

extends does the same wiring in one line, and super.speak() reaches the parent method — which in Lua means calling Animal.speak(self) directly. Godot supports only single inheritance; composing nodes in a scene is the intended alternative.

Godot's built-in types — Vector2, Vector3, Transform2D, Color — do have overloaded operators because they are implemented in the engine. Anything of your own becomes a named method, and there is no __index fallback to give a class default values either.

The underscore prefix marks a virtual method the engine calls, and there are many others — _ready, _process, _input. That naming convention is the closest thing GDScript has to Lua's metamethod table, but the set is fixed by the engine rather than open.

Godot inverts that: every node in the tree gets its own _process(delta), called by the engine, and a node you never mention still runs. Gaining a node means it starts updating; freeing it means it stops. The habit of maintaining your own list of things to step disappears.

Godot provides it: _physics_process runs at a fixed rate set in the project settings, while _process runs once per rendered frame. Putting movement in the wrong one is the common beginner mistake — anything touching the physics engine belongs in _physics_process.

In Godot the scene tree is the world. add_child is the spawn, and from that moment the node processes, renders and receives input on its own. queue_free is the removal, deferred to the end of the frame so it is safe to call mid-iteration — something the Lua version has to be careful about by hand.

Godot puts that in a .tscn file authored visually, and instantiate() stamps out a copy. The consequence worth internalizing is that much of what you would express in Lua as data in code becomes data in files, edited outside the script and referenced through @export.

The names differ only by convention — dt in LÖVE, delta in Godot — and both are seconds as a float. Anything that moves and is not multiplied by it will run at a different speed on a different monitor, in either engine.

A signal is declared on the class, emitted when the event happens, and connected to by anything interested — including from the editor. Nothing polls, nothing needs a dead flag, and the emitter does not know who is listening.

Because a Callable is an ordinary value, the hand-rolled version works in GDScript too, and the right column runs it. The advantage of real signals is that Godot manages the connections' lifetime: a freed node's connections go with it, where the Lua list would keep a dead closure alive.

That is a real convenience for game code — waiting a second, or waiting for an animation to finish, becomes one line rather than a state machine. It is also less controllable: you cannot resume it early, and the function returns immediately to its caller while the rest runs later.

push_error writes to the error log and to the debugger, and execution carries straight on. There is no construct that stops a runtime error from taking down the current call, so the discipline is to validate before acting and return a status or null on failure.

Because OK is zero and zero is falsy, if error: reads as "if there was an error" and happens to be correct — the opposite of how the same shape behaves in Lua. Godot's string type also carries validators like is_valid_int, which Lua leaves to tonumber returning nil.

Godot's stops execution in the debugger and is removed from release builds, so it is strictly a development check — never a validator for input that might legitimately be wrong. With no pcall to pair it with, the only safe use is for conditions you believe cannot happen.

The extra hazard is Godot-specific: a node that has been freed is not null, and touching it is a crash. is_instance_valid(node) is the check that covers both cases, and it has no counterpart in Lua because a Lua table cannot be destroyed out from under a reference.

In Lua the guard is meaningless and always passes. In GDScript it correctly reports empty. Neither language warns, and the bug looks like a logic error somewhere else entirely.

Multiplying by 0.5 is the common Godot idiom because it cannot be got wrong. Note the symptom is a one-pixel drift rather than an obvious failure, which is exactly why it survives review.

Nothing errors — the lambda runs, the arithmetic happens, and the outer variable is simply never touched. Capturing a mutable container and going through it is the workaround, and it is worth grepping every ported closure for this.

The three safe forms are get(key), get(key, default) and a has(key) test. This is the single most common crash when porting Lua code that treats missing data as ordinary.