frontpage.
newsnewestaskshowjobs

Made with ♥ by @iamnishanth

Open Source @Github

fp.

OpenCiv3: Open-source, cross-platform reimagining of Civilization III

https://openciv3.org/
576•klaussilveira•10h ago•167 comments

The Waymo World Model

https://waymo.com/blog/2026/02/the-waymo-world-model-a-new-frontier-for-autonomous-driving-simula...
889•xnx•16h ago•540 comments

How we made geo joins 400× faster with H3 indexes

https://floedb.ai/blog/how-we-made-geo-joins-400-faster-with-h3-indexes
91•matheusalmeida•1d ago•20 comments

What Is Ruliology?

https://writings.stephenwolfram.com/2026/01/what-is-ruliology/
18•helloplanets•4d ago•9 comments

Unseen Footage of Atari Battlezone Arcade Cabinet Production

https://arcadeblogger.com/2026/02/02/unseen-footage-of-atari-battlezone-cabinet-production/
21•videotopia•4d ago•0 comments

Show HN: Look Ma, No Linux: Shell, App Installer, Vi, Cc on ESP32-S3 / BreezyBox

https://github.com/valdanylchuk/breezydemo
197•isitcontent•11h ago•24 comments

Monty: A minimal, secure Python interpreter written in Rust for use by AI

https://github.com/pydantic/monty
199•dmpetrov•11h ago•91 comments

Show HN: I spent 4 years building a UI design tool with only the features I use

https://vecti.com
307•vecti•13h ago•136 comments

Microsoft open-sources LiteBox, a security-focused library OS

https://github.com/microsoft/litebox
352•aktau•17h ago•175 comments

Sheldon Brown's Bicycle Technical Info

https://www.sheldonbrown.com/
350•ostacke•17h ago•91 comments

Hackers (1995) Animated Experience

https://hackers-1995.vercel.app/
452•todsacerdoti•18h ago•228 comments

Delimited Continuations vs. Lwt for Threads

https://mirageos.org/blog/delimcc-vs-lwt
20•romes•4d ago•2 comments

Dark Alley Mathematics

https://blog.szczepan.org/blog/three-points/
79•quibono•4d ago•18 comments

PC Floppy Copy Protection: Vault Prolok

https://martypc.blogspot.com/2024/09/pc-floppy-copy-protection-vault-prolok.html
52•kmm•4d ago•3 comments

Show HN: If you lose your memory, how to regain access to your computer?

https://eljojo.github.io/rememory/
253•eljojo•13h ago•153 comments

An Update on Heroku

https://www.heroku.com/blog/an-update-on-heroku/
388•lstoll•17h ago•263 comments

Was Benoit Mandelbrot a hedgehog or a fox?

https://arxiv.org/abs/2602.01122
5•bikenaga•3d ago•1 comments

How to effectively write quality code with AI

https://heidenstedt.org/posts/2026/how-to-effectively-write-quality-code-with-ai/
230•i5heu•13h ago•175 comments

Zlob.h 100% POSIX and glibc compatible globbing lib that is faste and better

https://github.com/dmtrKovalenko/zlob
12•neogoose•3h ago•7 comments

Show HN: R3forth, a ColorForth-inspired language with a tiny VM

https://github.com/phreda4/r3
68•phreda4•10h ago•12 comments

Female Asian Elephant Calf Born at the Smithsonian National Zoo

https://www.si.edu/newsdesk/releases/female-asian-elephant-calf-born-smithsonians-national-zoo-an...
24•gmays•6h ago•6 comments

Why I Joined OpenAI

https://www.brendangregg.com/blog/2026-02-07/why-i-joined-openai.html
116•SerCe•7h ago•94 comments

I spent 5 years in DevOps – Solutions engineering gave me what I was missing

https://infisical.com/blog/devops-to-solutions-engineering
135•vmatsiiako•16h ago•59 comments

Understanding Neural Network, Visually

https://visualrambling.space/neural-network/
268•surprisetalk•3d ago•36 comments

Introducing the Developer Knowledge API and MCP Server

https://developers.googleblog.com/introducing-the-developer-knowledge-api-and-mcp-server/
42•gfortaine•8h ago•13 comments

Learning from context is harder than we thought

https://hy.tencent.com/research/100025?langVersion=en
168•limoce•3d ago•87 comments

I now assume that all ads on Apple news are scams

https://kirkville.com/i-now-assume-that-all-ads-on-apple-news-are-scams/
1039•cdrnsf•20h ago•431 comments

FORTH? Really!?

https://rescrv.net/w/2026/02/06/associative
60•rescrv•18h ago•22 comments

Show HN: ARM64 Android Dev Kit

https://github.com/denuoweb/ARM64-ADK
14•denuoweb•1d ago•2 comments

Show HN: Smooth CLI – Token-efficient browser for AI agents

https://docs.smooth.sh/cli/overview
88•antves•1d ago•63 comments
Open in hackernews

Why Go Rocks for Building a Lua Interpreter

https://www.zombiezen.com/blog/2025/06/why-go-rocks-for-building-lua-interpreter/
90•Bogdanp•7mo ago

Comments

ufo•7mo ago
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.
Lyngbakr•7mo ago
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.
Scaevolus•7mo ago
It's for zb, a Bazel-inspired build system that uses Lua instead of Starlark (stripped down python).
mdaniel•7mo ago
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

shhsshs•7mo ago
From the article:

    My Lua data types have a notable difference from C Lua: an ability to be “frozen”.
wavemode•7mo ago
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.
zombiezen•7mo ago
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.)

jekwoooooe•7mo ago
Go rocks for pretty much everything
osigurdson•7mo ago
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.
jekwoooooe•7mo ago
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

osigurdson•7mo ago
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.
pjmlp•7mo ago
Except for having a modern type system.
jekwoooooe•7mo ago
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
pjmlp•7mo ago
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.

mdaniel•7mo ago
> 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

kristianp•7mo ago
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).
williamdclt•7mo ago
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

lopatin•7mo ago
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.
3836293648•7mo ago
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
azemetre•7mo ago
Didn't MSFT also fire the lead engineer for this project shortly after?
pjmlp•7mo ago
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.

osigurdson•7mo ago
Sorry, who got fired?
Rexxar•7mo ago
He means probably Ron Buckton: https://xcancel.com/rbuckton/status/1922364558426911039
foldr•7mo ago
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.
azemetre•7mo ago
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.
foldr•7mo ago
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).

azemetre•7mo ago
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.

foldr•7mo ago
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.

osigurdson•7mo ago
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

shadowgovt•7mo ago
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).

9rx•7mo ago
> 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.

williamdclt•7mo ago
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
9rx•7mo ago
> 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?

osigurdson•7mo ago
Usually when something "rocks" it is better than other things in some way. I guess it can mean anything though.
9rx•7mo ago
"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?

osigurdson•7mo ago
>> "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.

9rx•7mo ago
> 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".

osigurdson•7mo ago
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.

9rx•7mo ago
> Use the term as you see fit.

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

zombiezen•7mo ago
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. :)
Jyaif•7mo ago
I mainly write code in languages without GCs so this article was very interesting to me, and the title was very fitting.
wavemode•7mo ago
I'm surprised there was no mention of implementing Lua's coroutines via Go's goroutines.
shadowgovt•7mo ago
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.
andrewmcwatters•7mo ago
Not that it's terribly important, but in the Lua circles, the reference implementation is usually referred to as PUC-Rio Lua.
osigurdson•7mo ago
It was mostly funded by Petrobras in Brazil.
zombiezen•7mo ago
Thanks for letting me know! I've updated the blog post to reflect that terminology.
andrewmcwatters•7mo ago
Oh, you’re welcome! I didn’t think the author would read this comment. Cool software!
anaempromptu•7mo ago
tfw you learn lua so you can build robots on minecraft
jhbadger•7mo ago
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.
photochemsyn•7mo ago
Is it just me or is Go/Rust proseltyzing on HN kind of getting ridiculous?
skybrian•7mo ago
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.

pjmlp•7mo ago
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.

skybrian•7mo ago
It’s different because Go is garbage collected. See my other reply.
pjmlp•7mo ago
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.

skybrian•7mo ago
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.

pjmlp•7mo ago
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.

foldr•7mo ago
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.
skybrian•7mo ago
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.

shadowgovt•7mo ago
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."