Why Go Rocks for Building a Lua Interpreter | Hacker News Reader

Why Go Rocks for Building a Lua Interpreter

zombiezen.com

90 pointsBogdanp59 comments

Well done, writing interpreters is fun!

I’m not really sold on why Go would be a particularly good fit for the task, compared to other languages. Seems to be mostly “interfaces are useful for interpreters, and GC means I don’t have to care about memory management” - both of which are true but hardly specific to Go. There’s some form of interface in almost every mainstream language, I think the implementation would be pretty much the same in any GCd language

I never thought that Go would be a technology of choise for PL stuff. I always considered it more of a Java-lite for Web systems and also for CLI stuff, but here we are! TypeScript rewrote their compiler to Go. Being a compiler, they had no use of piggy backing on the GC, looks like they just liked the language.

Typescript chose Go specicfically because they didn't rewrite it. Go has close enough semantics to TypeScript that they could write a Go backend for tsc and do a machine port to Go and continue working from that

Didn't MSFT also fire the lead engineer for this project shortly after?

They did.

Also the way the port was sold is a bit misleading, because as described on BUILD 2025 session, they had anyway to redo the whole datastructures due to the more basic Go's type system.

Meanwhile Azure is rewriting C++ into Rust with AI tooling, see Microsoft talks at Rust Nation UK 2025.

Sorry, who got fired?

He means probably Ron Buckton: https://xcancel.com/rbuckton/status/1922364558426911039

Looks like he was laid off, not fired. But so what? Layoffs have their own weird logic. It doesn’t tell us anything about how the project is perceived internally to Microsoft.

No, but it does tell us that MSFT leadership are quite inept if they are firing a clearly qualified engineer capable of doing hard work under the guise of cost savings.

Isn't general MSFT bashing a bit off topic in this thread?

Also, it's discourteous to the individual in question to keep incorrectly stating that they were fired. The distinction between being fired and being laid off is an important one (especially if the person in question is applying for jobs).

Fired and layoffs are a distinction that no worker cares about, I'm sure he'd rather be working than getting laid off for "performance reasons."

If you were ever given the option to collect unemployment insurance, this includes taking a severance package where you stipulate to not pursue unemployment insurance, then you were fired.

It's also important to always note that these companies do not care about their workers, they will extract you dry and throw you out.

It’s an important distinction because being fired suggests a fault on the part of the employee. Despite what you appear to suggest, there is no public information suggesting that this person was laid off for performance related reasons.

Again, what you think about Microsoft, or big tech companies in general, is completely irrelevant here. You’re spreading false information about someone. It would cost you nothing simply to stop doing it.

Yeah. They said that there were lots of nested structures with cycles and so on so it would be hard to do with Rust. Link below.

https://youtu.be/10qowKUW82U?t=762

I used Go awhile ago for a Blockly interpreter. It's remarkably friendly; if memory serves, the ability to attach metadata to structs was pretty useful.

One hack I'm not super proud of is I implemented return and break with panic / recover. Were I to do it all over, I'd probably use continuations to model that instead.

(Side-note on Lua specifically: among the reasons I like Lua is that it's very simple and its reference interpreter implementation is some very understandable code. I did some truly horrible things to it back in the day for a game engine, and it was very amenable to getting beat up like that).

> I’m not really sold on why Go would be a particularly good fit for the task, compared to other languages.

Can't every language rock for building a Lua interpreter? It isn't a competition.

I think that’s re-interpretation, making the subject of the article about “why go rocks” shows the author thinks Go has something over other languages. Otherwise it’s like saying “why orange cats are fluffy” then saying stuff that applies to all cats without orangeness specificity

> shows the author thinks Go has something over other languages.

How so? It is clearly just a story of someone's experience, not a technical evaluation of various languages. The only other language (aside from Lua) mentioned is C, and the C implementation was considered so good that it was to be the direct model for the implementation in the story, so we can assume that writing a Lua interpreter in C also rocks.

> Otherwise it’s like saying “why orange cats are fluffy”

Sure. That seems like a reasonably fair title for a story about your fluffy orange cat, even if other cats (and other animals, not to mention other things that aren't animals) are also fluffy. You could call it "Fluffy" instead, I suppose, but then someone would complain about the lack of details. You can never please everyone.

But, regardless of how you want to interpret the title, it remains that there isn't a competition. There never has been, never will be. A poorly written title wouldn't magically create a competition. Where does the bizarre idea that there is one stemming from?

Usually when something "rocks" it is better than other things in some way. I guess it can mean anything though.

"Rocks" is most commonly used in the context of (rock) music. A statement like "<insert band> rocks!" usually indicates that someone enjoys said band. But what makes you think it also means that they see other bands as now being inferior in some way?

As far as I can tell, most people who find a band that "rocks" also enjoy other bands as well, often even more, and are not looking for some kind of a battle of the bands to find the one true band that they will only ever listen to again. It is quite possible, and typical, for (rock) music fans to enjoy many bands.

You are right that words mean only what the speaker/author intends for them to mean, but in common usage there is nothing to suggest that "rocks" implies something is better than something else. It only suggests something in the vein of "I enjoy this". Besides, we know what the author meant as he has told us.

Even we were to agree that the title is poorly written, we know from other context that there isn't a programming language competition. This single title wouldn't suddenly make us think that there is one. So where has the idea that there is one coming from?

>> "Rocks" is most commonly used in the context of (rock) music

False.

>> we know from other context that there isn't a programming language competition.

I would have expected at least one comparison to another programming language. Like "COBOL" was a real pain for this, but "Go rocks".

>> ... other stuff ...

Yeah, I don't really care one way or the other. If people want say that everything in space and time are completely undifferentiated and therefore "rock" equally, I don't really care. Rock on.

> I don't really care one way or the other.

Nobody does. Why would they? It isn't like there is a competition or something.

> If people want say that everything in space and time are completely undifferentiated and therefore "rock" equally, I don't really care.

Many things having the potential to "rock" does not imply that everything "rocks" equally, or at all. I strongly suspect his attempt to write a Lua interpreter in Brainfuck would not "rock".

Let's see if we can break HN nesting algo with this thread.

>> Many things having the potential to "rock" does not imply that everything "rocks" equally, or at all

That isn't what I am suggesting. I am saying that I do not care if people use the word "rocks" to describe an impossibly spherical marble rolling on an impossibly flat surface - equal across all space and time. Or, to describe, something that is uniquely better than all others. Use the term as you see fit. Use it to describe the value 4.532341 +/- 0.00001345 if you like.

> Use the term as you see fit.

Obviously. But you already suggested that in your first comment. For someone who claims to not care...

As the author of the article, I'll say that my intent was to share the good time I had writing a Lua interpreter in Go. Other folks in the thread are right: more than one thing in this world can rock. :)

I mainly write code in languages without GCs so this article was very interesting to me, and the title was very fitting.

I know the author starts the post by saying he won't explain the reasons why he had to write a new Lua interpreter from scratch, but I'm still curious about that. Does anyone know? I dug through some of the links in the post and couldn't find the answer.

This is exactly the part I got hung up on, too.

    The exact reasons aren’t important for this blog post, but neither the reference implementation [...] nor the other open source Go Lua intepreters I could find were a good fit for my needs.

I'm intrigued because presumably the shortcomings of the other implementations are important to how they chose to implement Lua here.

It's for zb, a Bazel-inspired build system that uses Lua instead of Starlark (stripped down python).

Zb: An Early-Stage Build System - https://news.ycombinator.com/item?id=41595310 - Sep, 2024 (125 comments)

and the beta announcement was also recently submitted, but without commentary https://news.ycombinator.com/item?id=44290692

From the article:

    My Lua data types have a notable difference from C Lua: an ability to be “frozen”.

Given this is going to be used as a scripting language for a build system, it's possible they are trying to implement a restricted subset of Lua rather than than the full language.

Yup, as others have mentioned, it's for zb. I originally outlined some background on design goals for this blog post, but the outline for that section was as big as the outline for the rest of the post, so I cut it. I'll probably write that one up as another blog post in the near future. :)

(Also, my pronouns are she/her.)

Performance is scarcely mentioned. It probably doesn’t matter that much for a build system. But for projects where it does matter, you won’t get performance in the same ballpark as a Lua interpreter written in C if you use Go.

In particular, because Go is memory-safe, you don’t have the control over memory layout you need to do tricks like NaN-boxing. Anything that requires a union with a pointer (which will be every value in a dynamically typed language) must be represented as a value of interface type, and interface values are quite fat - 16 bytes on a 64-bit machine.

Interpreters are atypical programs to optimize. Few other programs use unions so much in their inner loop.

Or do it like C in the age of K&R C, and compilers ramping up for C89 compliance, with a little bit of Assembly.

Most stuff people use in C for writing interpreters with optimal performance, isn't ISO C, rather C compiler specific extensions, or inline Assembly.

All things being equal, same rules apply.

It’s different because Go is garbage collected. See my other reply.

No it is not, that is the anti-GC folks agenda since Xerox PARC days, placing all GC languages into one big basket, not learning what actually makes one specially tick, the language features available for low level coding in each programming language and such.

Just sticking to the old ways is why we don't get progress in some industry corners.

I’m not anti-GC. There’s nothing wrong with using a garbage collected language. However, if you use a built-in garbage collector, you do need to play by its rules, or it’s not going to work. These rules are language-specific and limit what you can do efficiently when writing an interpreter, versus writing your own GC that’s purpose-built.

For example, Go’s garbage collector isn’t going to do as well at JavaScript as V8’s garbage collector, because the only unions it understands are Go interfaces. Also, the garbage collectors for other languages mostly don’t support some features of the Go language, such as taking pointers into the middle of objects.

You can still write an interpreter in any language, but there will be an efficiency cost when the languages are too different.

I would say it is a matter of implementation, taking the best advantage of unsafe, Assembly, value types and generics.

Not everything has to try to replicate C in language XYZ.

But I do agree, among all languages I would rather reach out for D, C#, any of the MLs or Haskell, Lisp or Scheme variants, instead of Go.

Also if ultimate performance is the goal, then nothing beats handwriten Assembly, so that places both C and GC languages out of the game, as Android has been doing since Android 7, in case there is no PGO data available for the JIT.

You can do raw memory access via the ‘unsafe’ package, so I don’t think it would be impossible to do NaN boxing in Go. It would be somewhat less convenient than in C.

Unlike C, Go is garbage collected. Hiding pointers from the garbage collector so it can’t trace them without breaking something seems tricky. There would need to be pointers to that memory somewhere else to prevent it from being collected.

And then since you’ve disabled the system GC, you need to write your own GC that understands NaN boxing to find out when memory can really be freed.

I see it as so awkward that it’s not worth doing.

There are some advantages to constraining our runaway pointers to the part of the language written under the `unsafe` package, as opposed to doing the whole thing in C where we get the advantages of no language preconceptions of garbage collection getting in the way but the disadvantages of forever having to wonder whether we have vulnerabilities in the bog-standard steps like "reading from the input file."

Not that it's terribly important, but in the Lua circles, the reference implementation is usually referred to as PUC-Rio Lua.

It was mostly funded by Petrobras in Brazil.

Thanks for letting me know! I've updated the blog post to reflect that terminology.

Oh, you’re welcome! I didn’t think the author would read this comment. Cool software!

I'm surprised there was no mention of implementing Lua's coroutines via Go's goroutines.

That feels not quite correct. Lua coroutines aren't separate threads and trying to farm them out to goroutines (which are separate threads) risks violating expectations you can assume with non-concurrent execution. With coroutines, you can fairly believe that your state isn't going to change when you're running until you yield.

tfw you learn lua so you can build robots on minecraft

Lua has a long history with gaming since the late 1990s. The LucasArts adventure game "Grim Fandango" (1998) used Lua internally, and more recently it seems to have become the standard language for "fantasy console" game development such as in PICO-8 and TIC-80.

Is it just me or is Go/Rust proseltyzing on HN kind of getting ridiculous?

Go rocks for pretty much everything

Go routines are very nice. Way better than async await nonsense in other languages. if err != nil {return .., err} gets pretty tedious however. Everything tends to be very mutable / nullable as well which could be better. Also not really any faster than Java/C# - just another GCed language.

Go can be way faster than those. Garbage collection is not an issue at all if you write efficient code

And the error handling is way better than catching stuff because it’s so explicit

Agree that values are better than exceptions for error handling. It seems that it could be better though. I don't think Go is faster than C# or Java for the most part.

Except for having a modern type system.

What’s missing? It has generics and robust typing. Man this website must be full of old geezers with all the go hate I see

Maybe some Pascal like enumerations, something like this from 1976:

    type
      weekdays = (Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday);

      DailyActivity = array weekdays of string;

Instead of the ridiculous iota/const workaround.

You mention generics, but actually they still are quite constrained on capabilities.

Robust typing misses out on the famous gotcha with nil interfaces.

The error boilerplate, but granted that isn't a typesystem issue, rather grammar and semantics.

Package names tied to SCM domains, with a workaround using HTML Meta redirections when they change, and behind our back file rewrites remapping imports.

> and behind our back file rewrites remapping imports.

I've been bitten/misled by that so many times. How hard is it to just $(find -exec sed) to patch up the imports if you fork a project, versus later finding out oh, so that's why line 50 of some random dep doesn't at all do what it says in the repo

If I was Go Dictator For Life I'd make the compiler issue a warning for any replace statement in go.mod

It does make you wonder about their thought process, not using 'real' enums for go. I think the language designers were of a minimalist mindset, but Pascal wouldn't be described as bloated by anyone with a computer larger than an original Apple II (it required an add-on card to run UCSD Pascal).

Reply on news.ycombinator.com