r/lua

Lua's superpower is staying small. Fennel, MoonScript and YueScript are wonderful answers to "what if Lua were a different language?" — and I've learned a lot from all three. So now I'd like to ask another question. Suppose we keep Lua (mostly) as is, then **what's the minimum change to Lua that buys the most? **

My current answer is `luk`, a 120 line transpiler that plugs into `require` to load Lua code that :

- adds list and dictionary comprehensions
- a uses Python-style indentation for blocks (so no nee for `do`, `then`, `end`
- replaces `function` with `fn`,
- replaces `^` for return, `
- expands `x := y` o `local x = y`

For example:

Luk code (on left) transpiles to Lua (on right)

Explicit `then/do/else/end` still works, so any Lua is (almost) valid luk and the two styles mix freely. The whole transpiler is one ~120-line module — no parser, no AST, no dependencies. The generated Lua keeps the source's line numbers exactly (errors point at the real `.luk` line), and a `require()` hook lets `.luk` and `.lua` modules interoperate with no build step.

luarocks install luk # cli + a small stdlib battery included

**An invitation, and a constraint:**

- What did I miss? What tiny change to Lua would pull the most weight for you?

PRs welcome, under one hard rule:

- the transpiler may never exceed 250 lines. If your feature can't pay for itself inside that budget, it doesn't go in. (That rule is the my whole design philosophy.)

- quick tour: https://timm.fyi/luk.html
- longer tour: https://github.com/aiez/luk/blob/main/README.md
- code: https://github.com/aiez/
- luarocks: https://luarocks.org/modules/timm/luk

Example

local function b()
    return
        (math.random(0, 1) == 0),
        0
    ;
end

local function a()
    local return_early, value =
        b()

    if (return_early) then
        return (value);
    end

    --[[ Continue function a ]]
    return (1);
end

print(a())

but I want to do it more like, having function b directly tell function a to return early rather than function a having to check itself

I want more like this where I used "return return" as sudo code for throwing the return up 1 level

local function b()
    if (math.random(0, 1) == 0) then
        return return (0);
    end
end

local function a()
    b()

    --[[ Continue function a ]]
    return (1);
end

print(a())

I was writing a simple script in lua and ran into this dilemma: whether to use return with nil or without the nil. Using nil seems more correct, but it’s more verbose. What return style should I use?

local function foo()
  return
end

local function bar()
  return nil
end

hi guys so i heard hyprland is switching to lua ... i dont have enough experience can someone pls help me out or something to change it .

Lua is truly a fantastic language with many advantages.

It's easy to use and understand, and much faster than Python. I believe it could be a better alternative to Python, as both are interpreted languages.

So why not migrate Python libraries to Lua?

I understand that Lua's best use is integrating with other systems due to its small size and good compatibility with C.

I think the only real advantage Python offers is its integrated environment. If Lua had this feature, there would be no need for Python.

I know this might sound a bit optimistic, but I'd like to know if there are any other limitations preventing this?

Thank you in advance.

Edit: I want to thank everyone who commented on this post, I learned a lot from all of you and made me look at the topic from a new perspective.

well as the title says i need active collab cuz there is NO way im coding this all by myself as a 12 yr old

luaur is a pure-Rust port of Luau (Roblox's typed Lua) - lexer, parser, bytecode compiler, register VM, type checker, and the CLIs. It builds for wasm32-unknown-unknown with no C toolchain, so you can run and type-check Luau right in the browser: https://pjankiewicz.github.io/luaur/

About 2 weeks ago on a whim I decided to do this. Why? I wanted to use Luau but in a way that's first-class in the Rust ecosystem and targets wasm32-unknown-unknown. Lua is a great embeddable language and it serves me well as a scripting language for AI agents - and being able to type-check a script before I execute it is another reason it's a good fit.

That's the why. Here comes how.

Since the LLM boom started I fantasised about porting large projects to Rust with a systematic approach. The cleanest one is graph-based: build a graph of the source project, sort it topologically to fix the translation order, and keep expanding the context with the items you've already translated. Then you can translate the whole thing in one clean sequence. That's a well-known "skeleton" strategy - that was assumption one.

Assumption two: do the porting with small, cheap models guided by the graph harness. With the right context I believed even small models produce passable output - we've leaned so hard into multi-turn frontier agents that it's easy to forget how much a small model can do when the context is right.

With both assumptions in place, building the tool and filling the skeleton took about 2 weeks of not-very-intense work - mostly monitoring and nudging Claude and Codex (I used them interchangeably) to stay on target. Sometimes the agents forgot they were supposed to do batch parallel translation with the cheap models. Claude or Codex would say "the cheap models are clearly too weak, let me translate this myself." My nudge was always the same: use the translation tool, fix the systematic context errors. In 9 out of 10 cases the problem was the context - the hallucinations and bugs were missing-context errors, not model quality.

After a few days a stable loop emerged:

• pick a module
• translate it in a batch
• fix it in a batch (rotate the models)
• let the agent fix the rest until the project is green
• repeat

The last stretch was purely agentic: setting up the crates, fixing tests, getting it working across platforms.

Now - does auto-translated code actually work? That's the part I cared about proving, so the oracle is Luau's own tests, not mine:

• 5,347 of Luau's own unit tests, ported to Rust, pass.
• 293/293 upstream conformance scripts run byte-identically on the Rust VM.
• a byte-exact bytecode differential: bytecode compiled by C++ Luau runs on the Rust VM with identical results.
• the safe API layer (luaur-rt, mlua-style) passes 225/235 of mlua's own test suite byte-for-byte; the other 10 are documented Lua-vs-Luau differences.

Repo: https://github.com/pjankiewicz/luaur

Hi guys, in this week's live developer chat we are kicking off the Leadwerks Summer Games Tournament. Participants have 30 days to create a simple playable game (with Lua or C++) and upload it to our website. Instead of a competition, this is a co-opetition. Everyone who participates gets a prize in the mail. 😃

We also played through the free game Exit: Underground and took a sneak peak at some of the plans for development in Leadwerks 5.2, including fast software raytracing and moving our VR backend to OpenXR.

If you are interested in participating in the tournament, you can pick up the Lua-enabled Leadwerks Game Engine 5 with a discount during the Steam summer sale.