Lua.CodeCompared.To/Forth

Defining HELLO and then running it are two separate acts, and the second is what a reader would type at the prompt. Lua's print adds the newline; Forth's CR is a separate word, because printing and ending the line are separate things.

Lua's variadic print and Forth's .S look similar and are not — .S is a debugging tool that leaves the stack untouched, and there is no way to ask it for only some of the values. To consume and print one, use ..

It reads backwards until you notice it is a pipeline running right to left, and then it is hard to unsee. It exists because . always prints a trailing space, so a number with anything after it has to be assembled this way.

Both languages ship their compiler at run time, which is unusual company to be in and is part of why both get embedded. The difference is that Lua hands you a function to call later, while EVALUATE simply runs it now — there is no chunk object to hold on to.

This is the single biggest adjustment coming from Lua: there is no local, and this Forth has no locals word either. A word that needs a value twice says DUP, and one that needs them the other way round says SWAP.

The difference is that Lua's multiple returns are adjusted to fit the call site, padding with nil or discarding extras. Forth does no adjusting at all: whatever the word left is still there, and a caller that expected a different number is simply wrong.

Forth has a small vocabulary for exactly this — SWAP, OVER, ROT, NIP, TUCK, DUP, DROP — and learning it is learning the language. Needing more than three or four in a row is the sign that a word is doing too much.

Choosing 0 for that is a convention with a cost: a real measurement of zero is indistinguishable from an absent one. Where the difference matters the idiom is a second cell carrying a flag, which is the same shape Lua's nil saves you from needing.

The body has nowhere to put a parameter name, so the stack comment carries the whole interface — and it is a comment, checked by nobody. Lua does not check types either, but it does check that square is called with parentheses and gets something.

That difference shows up with globals: a Lua function can call a global defined later, because the lookup happens at call time. Forth resolves the name once, at compile time, and never looks again — which is what makes a call a direct jump with no lookup at all.

Writing FACTORIAL inside its own body would find an earlier word of that name, which is occasionally what you want when redefining something in terms of the version it replaces. Lua's plain function f has the mirror-image trap: it assigns a global that the body then looks up at call time.

Passing the count explicitly is the standard Forth answer, and it is why so many stack comments end in a number. DEPTH does report the whole stack depth, but a word that consults it is reaching outside its own arguments and will surprise its caller.

The second line is the whole row: Lua answers 0.5 and Forth answers 0. A Lua programmer reaching for / out of habit gets a float; in Forth the surprise runs the other way, and there is no warning and no other operator to have meant instead.

Fixed point is what both languages do on a microcontroller with no floating-point unit, and Forth having dedicated words for printing it is a fair hint about where it is used. The value on the stack is an ordinary integer the whole time; only the printing knows where the point goes.

Because the width belongs to the system rather than to the value, the same source prints something else on a 64-bit Forth: gforth on a desktop answers 64 and 2147483648 for these two lines. Lua's integer stays 64 bits wherever it runs, and overflows into a float rather than wrapping.

Lua prints true where Forth prints -1, because a Forth true flag is all bits set — which is exactly what makes AND and OR work on flags and on numbers with one set of words. Comparing a flag against 1 is therefore a bug waiting.

Forth arrays are 0-based because an index is an offset from the start, and Lua's are 1-based because an index is a key. That is one of the two places a Lua programmer will slip; the other is that nothing here stops 3 READING from reading whatever follows.

This is the whole of Forth's data modelling, and it is why CREATE … DOES> in the next section matters — generating those offset words is the only way to avoid writing them out. A Lua table can grow a new key at run time; this layout is fixed the moment it is compiled.

Changing the array without changing the constant is a bug nothing will catch, which is why the two are written adjacent. It is the same discipline as the /SAMPLE stride convention: a name that stands in for a fact the machine does not track.

There is no garbage collector, no free and no allocator — memory use is decided when the source is read, which is why a Forth system has no collection pause to reason about. Lua's incremental collector is one of the reasons it is embeddable and also the thing a hard-real-time program must budget for. 🚨 collectgarbage itself is not implemented in Fengari, so this row cannot measure the heap the way it would on a desktop Lua.

This is the closest thing Forth has to a constructor plus a metatable, and it is an ordinary word rather than a separate mechanism. The values are baked in at definition time — PLUM has no state to look up, which is why there is no __index to chase.

Nothing forces anyone to call EFFECTIVE rather than TIMEOUT @, so the convention is the whole mechanism. That is the recurring shape of this comparison: Lua provides a hook, and Forth provides a place to write the same behavior by hand.

Three lines replace writing POINT CELL+ by hand everywhere, and adding a field in the middle re-numbers the rest automatically. This is the idiom that makes structs bearable in Forth, and it is built from the same CREATE … DOES> as the color above.

Nothing binds the two cells together, so NIP can throw the address away and keep the length. Taking a substring is free — add to the address, subtract from the length — which is the compensation for having no string library at all.

🚨 /STRING is not in this Forth, so the row defines it — which is ordinary practice rather than a workaround, and is how a Forth system grows. It is one line because the operation really is just "add to the address, subtract from the length".

Doing it by hand means the cost is visible — one buffer, one copy per piece — where Lua's .. hides three allocations in eleven characters. It also means the buffer's size is your problem, and 32 ALLOT here is a promise nobody checks.

A real program would define SPLIT once and use it everywhere, which is what a Forth library is. This is the clearest case on the page of "minimal" meaning two different things: Lua ships a whole pattern engine in a language famous for being small, and Forth ships nothing and expects you to write the twelve lines.

Reading THEN as "and then carry on" makes the shape work. Unlike Lua, only zero is false here: there is no nil, and 0 being false means a legitimate zero measurement takes the else branch.

The limit is pushed first and the starting index second, which is the reverse of how the range reads aloud. Between that and the inclusive/exclusive difference, this is the row most likely to produce an off-by-one for a Lua programmer.

?DO is the version that tests first, and it is what you want whenever the count comes from a variable. This is the single most dangerous default in the language for someone arriving from a language with real iterators.

The value being tested stays on the stack the whole time, so the loop ends with it still there and DROP has to clear it — the bookkeeping a Lua local does for free. Forgetting that DROP is how a Forth word silently returns one cell too many.

The DROP before LEAVE is needed because the reading is still on the stack and nothing else will take it. Lua's break needs no such care, because the value belonged to a local that is simply going out of scope.

The row deliberately does not run 30 CHECKED, because it would end the program and nothing after it would print. In Lua the same call under pcall returns false and the message, and the program carries on.

That is not only a limitation of this implementation: returning a flag is the ordinary Forth style even where CATCH exists, because the decision to give up belongs to the application rather than to the word. A library that aborts has taken that choice away from every caller.

The two outcomes leave different numbers of cells, so a caller that forgets to test is unbalanced rather than merely wrong — the stack will be one cell off for the rest of the program. UNLOOP before EXIT is mandatory: the loop's index and limit live on the return stack.

A token being an ordinary cell means it can be stored in an array, passed through several words, or arrived at by arithmetic — and also that executing a number that was never a token does something undefined. Lua's functions are real values with a type you can check.

🚨 That means there is exactly one counter. Two independent counters need two variables, or an array of them and a word that takes an index — which is what a Forth programmer writes instead, and it is the biggest thing a Lua programmer gives up on this page.

This Forth has no CASE, so a token table is the idiom once there are more than two or three branches. Lua's table would report nil for a missing index and error on the call; here, index 3 reads the cell after the table and executes it.

IS installs an execution token into the deferred word, and every caller compiled against it follows the new one. This is how a Forth driver is retargeted without recompiling anything — and it is opt-in, which is the opposite of Lua, where every global call pays that indirection.

🚨 There is no way to write coroutine.yield in standard Forth — a generator has to be turned inside out into a word plus explicit state, as here. Multitasking Forths do exist and give each task its own pair of stacks, but that is a system feature, not something an example can reach for.

🚨 Anything pushed with >R must be removed before the word returns, or the word returns to the wrong place. Inside a DO loop the loop's index and limit are on that same stack, which is why R@ there reads a loop counter rather than what you stored.

Lua is famously about 250KB with its standard library; a Forth kernel is measured in kilobytes and often in single digits. WORDS will list everything the system knows, which is worth typing once at a prompt: that list is the language, and a word you define joins it on the same terms.

Having no namespaces is a real cost on a large program, and Forth systems answer it with vocabularies or with naming conventions. What it buys is that extending the language and using it are the same act — which is the property both of these languages get embedded for.

This is where the two languages genuinely part company. Lua's syntax is fixed and its one extensibility trick is the call-with-table sugar shown above; a Forth program can add control structures to its own compiler using the same words it uses for everything else. The two columns compute different numbers because there is no Lua construct to put opposite an immediate word.

Both columns print the same two numbers, and the indices that produced them are 1, 2 on one side and 0, 1 on the other — which is the whole row. It is the mechanical difference most likely to produce a wrong answer rather than an error, because 0 READING and 3 READING are equally valid addresses.

AND is bitwise, not logical, so 1 2 AND is 0 — false — even though both numbers are true flags. A canonical Forth true is -1, all bits set, precisely so that bitwise AND and OR behave as logical ones.

Most desktop Forths fold case, so an example typed in lowercase works in gforth and fails here. Defining : Greet does not define GREET, which is the same rule Lua follows and a different result, because Lua has no folding Forths to be copied from.

A new Lua local behaves the same way, for the same reason — the earlier function captured the earlier binding. Where they part is globals: replacing a Lua global changes every caller at once, while no Forth redefinition ever does.

Both languages let the call happen; only one of them lets you find out. The habit this produces is checking the stack with .S after any word you are unsure of, because a wrong answer is the only symptom you will get.