Luau's Performance

Posted2 months agoActive2 months ago

todsacerdoti

90 points

16 comments

luau.orgTechstory

calmpositive

Debate

40/100

LuauPerformance OptimizationProgramming Languages

Key topics

Luau

Performance Optimization

Programming Languages

The post discusses Luau's performance capabilities, sparking a discussion among developers about its optimization techniques and potential future improvements. The conversation highlights Luau's strengths and areas for further development.

Snapshot generated from the HN discussion

Discussion Activity

Moderate engagement

First comment

Peak period

42-48h

Avg / period

Comment distribution16 data points

Loading chart...

Based on 16 loaded comments

Key moments

01Story posted
Oct 23, 2025 at 10:55 AM EDT
2 months ago
Step 01
02First comment
Oct 25, 2025 at 5:04 AM EDT
2d after posting
Step 02
03Peak activity
8 comments in 42-48h
Hottest window of the conversation
Step 03
04Latest activity
Oct 26, 2025 at 8:06 PM EDT
2 months ago
Step 04

Generating AI Summary...

Analyzing up to 500 comments to identify key contributors and discussion patterns

Discussion (16 comments)

Showing 16 comments

Rochus

2 months ago

2 replies

Here are some measurement results based on the Are-we-fast-yet benchmark suite: https://github.com/rochus-keller/Are-we-fast-yet/blob/main/L...

Luau in interpreter mode is pretty much as fast as LuaJIT 2.1 in interpreter mode.

Luau with (partial) native compilation is factor 1.6 slower than LuaJIT 2.1 in JIT mode. I used Luau with the -g0 -O2 --codegen options (didn't add --!native to the code though), which according to my understanding automatically selects the "profitable" functions for native compilation.

eterm

2 months ago

1 reply

The thing that sticks out at me most on that table is "Mandelbrot" being such an outlier, has the LuaJIT implementation been checked over?

Looking at the code, it looks like the Mandelbrot algorithm has a version-switcher, so does that mean LuaJIT is going down the < 5.3 path?

( Sorry, this isn't my area of expertise, I'm just trying to make sense of the table! )

Rochus

2 months ago

> has the LuaJIT implementation been checked over

Just re-checked that I inserted the Luau Mandelbrot results in the correct cell.

> does that mean LuaJIT is going down the < 5.3 path?

Yes.

ModernMech

2 months ago

2 replies

Thank you, I kept waiting for a chart or some numbers that never came. Per usual, we are talking about orders of magnitude difference compared to actually high performing code. Another word for that is "slow". Just worlds apart in expectations.

Of course the lesson is when it comes to performance, it's extremely hard to make up with tuning what you lose in language design. You can optimize the work all you want but nothing beats designing it so that you don't have to do a good chunk of it in the first place.

pushcx

2 months ago

1 reply

Asking as a newbie in this area, could you share any pointers to language design for performance?

I'm aware of the early difference between compiled and interpreted languages. Luau has to be interpreted to meet its security goals, and I'm asking with similar goals in mind, so I guess I'm starting from that significant limitation.

__s

2 months ago

Lua gets sone perf with simple types that can represent lots of types without pointers easily. Truthiness is also fast since only nil/false singletons are falsy. Whereas Python has ´__bool__´. But look at metatable stuff for how much lua has to check

All of these introduce guards in with JIT or inline cache, preferable to have no guard at all

This isn't unique to dynamic languages, see C++ map having a layer of indirection forced to support pointer lifetimes of access living past inserts. Whereas Rust doesn't allow borrowing past that, & Go doesn't allow taking address of map value

Other examples: C optimizations having to worry about pointer aliasing. Or Go interfaces having to box everything. It used to have small value types be able to avoid boxing for interface value, but dropped when switching to precise GC

Rochus

2 months ago

I was actually surprised to see nearly a factor ten between C99 and LuaJIT. In previous measurements (on x86, see e.g. https://github.com/rochus-keller/Are-we-fast-yet/blob/main/L...) there was rather a factor five. So either GCC 12.2 produces much faster code than GCC 4.8, or LuaJIT 2.1 got much slower, or the C99 version of Are-we-fast-yet is much better supported by the CPU cache of the T480 than my previous EliteBook 2530. I don't think that the x86 vs x86_64 makes such a difference (at least I didn't observe this in many other experiments).

le-mark

2 months ago

2 replies

I’ve always been curious how Roblox games are deployed and managed. Is each instance of a game executed in a docker container, and the luau code isolated that way or is there some multi-tenant solution?

chc4

2 months ago

2 replies

They run the game servers in Docker. Doing multi-tenant is a weaker security boundary and makes it easier to steal places from other users, which Roblox takes pretty seriously when places represent all the time invested by game studios and millions of dollars in revenue.

le-mark

2 months ago

1 reply

How is this cost effective though? There are a lot of low quality games, not by a big studio. These also get a dedicated docker container?

sureglymop

2 months ago

What do you mean? A docker container is just a process. Are you suggesting they run different game servers in the same process?

logical_person

2 months ago

running multiple game servers in docker is a multi-tenant environment, because docker is not a serious security boundary unless you're applying significant kernel hardening to your kconfig to the tune of grsecurity patches or similar

chadcmulligan

2 months ago

I haven't used Roblox but Lua has the ability to create sandboxes to run user code. You expose only the functionality you allow to the user code, usually block I/O, and any unsafe functions. https://luau.org/sandbox

bjoli

2 months ago

It is obviously a choice why isn't done, but with static modules you can know whether * is overloaded. That will improve procuedure calls by a lot, almist always. sure, with polymorphic finctions you can get a bit of the way using inline caches, but in my experience knowing the callee is always going to be a speedup.

ramanvarma

2 months ago

i'm impressed how much the runtime is optimized across so many layers - pretty rare to see an interpreted language push this far without a JIT. Do you see this approach eventually rivaling JIT performance for real world workloads, esp where predictability matters?

bstsb

2 months ago

i use luau a lot as part as my Roblox development work, it's pretty fast for its main use case.

there are people a lot more knowledgeable about this topic so i won't pretend to know this is possible, but could a versioning flag similar to the !native flag be added? it would allow both for backwards compatibility and better optimizations, although i know it might add complexity where it's not needed

View full discussion on Hacker News

ID: 45682560Type: storyLast synced: 11/20/2025, 12:29:33 PM

Want the full context?

Jump to the original sources

Read the primary article or dive into the live Hacker News thread when you're ready.

Open link View on HN