Making Lua Compatible With What?

Penned, furiously, on 2026-08-04

Recently, PUC-Rio put out a haphazard Lua release, Mike Pall is creating MikeScript, and now I guess the developer of Teal is upset Lua... (sounds of paper flipping) ...isn't innovating or something? As someone that honest to god enjoys working with and using Lua, this has been a frustrating couple of months. I have no idea what has been in the air (tho, we have a guess), but it currently feels like Lua's design is being driven by people that utterly hate the language for what it is.

Lua 5.5

I already ranted about Lua 5.5 wasting the global keyword. So, I'll skip to LuaJIT 3.0's extension.

MikeScript

Lua is designed to be an embeddable scripting language. And, it has succeeded greatly in that regard. Probably to the annoyance of literally everyone include the people making the language. It's common for Lua to become frozen in time. Usually Lua 5.1. LuaJIT made this a fact of life since Mike Pall effectively hard-forked Lua at 5.1. He apparently had strong disagreements about PUC Rio's design choices.

Mike Pall's skills at implementing a language runtime is unquestionable. LuaJIT's implementation is second to few, and for a while had zero competition. Eventually, he retired. He left a power vacuum nobody could fill. Eventually, other projects started to appear and make solid ground. And, then he came back! And, I was excited. But God, I wish he stayed retired.

He is now making changes to Lua's syntax that make me question his skills as a language designer. Apparently the motivation is some bullshit about "value in conformity and compatibility". These changes are planned for LuaJIT 3.0, but have apparently been forced into LuaJIT 2.1.

I think the finest example that Mike Pall is good at implementing runtimes and not designing languages is he fails to understand why languages like JavaScript, C++, Java, Rust, etc. have two syntices for creating functions. It wasn't for some convenience. It wasn't to save a little bit of typing around function end. JavaScript's arrow functions have different behaviors around this. C++ and Rust are both low-level languages that have to deal with memory ownership. Java's lambda syntax replaced the extremely verbose anonymous class syntax for single method interfaces. Lua doesn't deal with any of this. It's function definition syntax desugars into anonymous functions. The only thing a second function definition adds to Lua is incoherent coding styles.

He's also painfully C brained adding a ? b : c ternary syntax. It's only appeal over the if-expressions is probably backwards compatibility and code golfing. It also clashes with Lua's keyword-oriented design. It does at least behave notably different from a and b or c in the event b is nil. So, a half-point there.

Thankfully, or possibly unfortunately, these will be backwards compatible extensions to LuaJIT. So I can ignore them. Especially the "Customary Operators ! && || !=" section (why!?). Many of these changes are superficial extensions to Lua's syntax. The handful of quality of life changes I'd welcome are marred by that missions statement: "there's value in conformity and compatibility".

Compatibility with what, Mike?

Serious? Compatability with what? It's certainly not existing Lua users. As mentioned by the Teal developer, Lua is "infamously" trapped in Lua 5.1. Largely thanks to Mike Pall. Any longtime Lua user is already attuned to reading Lua 5.1. It has been possibly the most dominant version of Lua for nearly 20 years. Additionally, the definitive reference for Lua is "Programming In Lua". The only free and online-accessible version is for Lua 5.0. Not even 5.1, but a version of Lua that is 3 years older. Furthermore, these additions would only introduce inconsistency within Lua's coding style. And, Lua already has an inconsistent style.

It's not PUC Rio, that's for sure. The ability to track PUC Rio sailed a long time ago. Breaking the 5.1 ABI compatibility would mean nobody would use LuaJIT 3.0. Additionally, LuaJIT at this point is a cherry picked amalgam of 5.1, 5.2, 5.3, and 5.4 with Mike Pall's own features on top. If people embrace MikeScript, Lua only becomes less compatible with itself not more.

Also, Roblox has already forked off into Luau. They even got their own Node.js going for it called Lute.

So, again, what compatibility Mike.

Actually, I will mention Lua 5.5

Lua 5.5 introduced the global keyword. The people that lauded this feature the most were ostensibly non-Lua users. If you actually read the manual on this or even try using it, the feature injects perplexing semantics into Lua. It doesn't even solve global by default, I would argue that its even worse now. The only thing this does is make people go "oh, yeah, Lua finally added a way to declare globals". Which is... technically true, I guess? But it just add so. many. fucking. problems.

But, people that don't like Lua were happy. So... success?

Teal will never be TypeScript, because Lua will never be JavaScript

The central complaint of "The Lua community needs to learn to move on" is one of a developer unhappy that Lua is a language you vendor then never update again. It's clear he wants Lua to innovate, iterate, and evolve rapidly like other languages. There is no technical motivations here. It's a developer that wants to unify a Lua so that he alone can evolve it again. He has this grand idea that a typed, unified Lua will aspire to the heights of Real Languages (tm). A project that he can shepherd, if only those bastards using Lua would just modernize.

But Lua won't aspire to those heights.

And you know, there was a time, when I was a teenager, where I wanted Lua to be able to be a Full Language. I wanted Luvit (remember that one?) to succeed, I wanted Lua to have a large standard library, I wanted Lua to have all the things that Ruby, and Python, and JavaScript had. I was envious of all those Real Languages (tm). I wanted to have a career writing Lua.

But I realize now, that isn't what Lua is. That I picked the wrong language for those desires. (And now I don't even want to work in the field.) Lua was always meant to be fractured. Libraries for Lua were always meant to be situated into a specific version and specific embeddings of Lua into a specific application. To chase "Lua as an extensible language (that is, an interpreter + libraries)" is to chase a mirage of a language that doesn't exist. That I would argue cannot exist without making multiple hard and breaking changes to Lua.

But neither Mike, nor Hisham, nor PUC Rio are willing to do this. Especially not now. Not in this climate.

The mAIsma over programming languages

Both Mike Pall and Hisham strike me as people attempting to "keep Lua alive in the common dark ages". Outside of well-established programming languages is a constant background anxiety that, one day, there'll "be no reason to use their language". That one day "there won't be any programming languages". That I guess programming will be telling AIs to shart out millions of lines of Rust forever. That if Lua users don't modernize, they'll be left behind in the permanent underclass.

The timing of MikeScript strikes me as a part of this. Attempting to make Lua more attractive and more "normal". More compatibility with non-Lua users. To make it appeal to people that will. not. every. like. Lua.

As long as table start at 1, as long as Lua tables combine arrays and hashmaps, as long as Lua doesn't have a class keyword, as long as you need to use io.execute to make a directory (this one I'm more than happy to see fixed btw), as long as it uses keywords in place of {}, these people you are trying to make Lua compatible with will NEVER like the fucking language.

Seriously. Get it into your head. They will never like Lua. Developers that didn't like Lua before, will never like Lua after you put some lipstick on it for them. Lua will and always has been a pig to anyone that prefers a C-like language with semantics that are vaguely shaped like C. Any object systems that isn't shaped like Java will be disregard and treated as flawed. Even people embedding Lua into their own systems will say stupid shit like "Lua does not offer built-in support for object-oriented programming of any kind" as if they never read the fucking PIL.

Lua will always be just a means to an ends for most people. You picked the wrong language for building a legacy in.

The mainstream world of programming is poisoned. It has always been poisoned. In fact, I think it's poisonous to the very idea of writing code. The mainstream will never choose Lua. It doesn't make them feel like they are solving Hard Problems. It doesn't give them a big toy to play with. The language was always meant to be something you embed into an application and mold into the exact tool you need. It doesn't have enough static analysis for it to be a good "substrate" for generating millions of lines of slop like Rust is.

Can I aside for a moment? I'm going to aside for a moment. Can we pour one out for all the poor folks that are probably tired of seeing static analysis only getting popular after the software community needs a new grift to keep the graving train going? Usually after the last gimmick they tried eventually reach its limit. It's gotta be real tiresome. Especially, with the wambo combo of cryptocurrencies, then NFTs, then AI generated tat. Sure was good times when it was just "oh, no, our slapped together Python program is too hard and boring to maintain and our VC needs to hype itself up".

To attempt to make Lua appeal to non-Lua users is to only make a language that is more fractured. Every feature you add to Lua will bring up more flaws, more incompatibilities, more need (or more aptly desire) for new changes, new concepts, new features. New everything. And for what?

Who Gives a Shit What Developers Think?

I feel like I'm going insane. I see so many people latching on to this idea that the mainstream developer culture matters. That being relevant to the now matters. That being adopted by businesses, start ups, and large scale projects matters. That any of the bullshit this industry and fake-ass community has excreted about how to write software matters.

Look at what it all amounted to.

Attempting to make Lua fit into this disgusting new age of programming speaks to profound naivety and ignorance. The kinds of people that think things can go back to normal. The kinds of people that act as if that fucking normal we had didn't lead to the world we are in. That we aren't boiling oceans to keep growing software projects beyond human limits.

I don't think it matters. In fact, I think it's good that Lua is a finished language. That Lua 5.1 is this immovable artifact burdening people trying to build a legacy before it's "too late". I think it'd be good for the language to be left frozen in time forever. I think this is a good thing.

When compared to the state of the world, we need tools and communities that reject this fucking bullshit of endlessly grinding out new features, new releases, new updates, bigger projects. The problem of software is too much code to manage and understand. So, nothing. NOTHING. That enables more code can possibly solve is problem.

If you want to chase this high, make a new language, from the ground up. Abandoned Lua. Design something new and scalable. With all the features and ergonomics of the big boys. Put the goddamn work into succeeding Lua instead of leeching off a language you people all seem to fucking hate.

Leave Lua behind. Go chase your legacy. Go chase you hype. Your vision of Big Lua. But, learn to move on from Lua before you do it. Cause it seems like you hardly fucking liked it.