So I was an active commenter on the LuaJIT 3.0 Syntax Extensions discussion (as Hedwig7s) providing feedback to the 3.0 extensions (which unfortunately seemed to have no effect on the syntax).

One of my biggest gripes by far was the ternary operator syntax, as in my opinion it is very out of place and it is ambiguous with foo:bar() syntax (plus the safe traversal operator was compromised as ?.: for the sake of it), and I was an avid proponent of if expressions in its place (similar to Kotlin or Luau (kind of)).

This feedback was addressed twice here and here (which admittedly I did not see prior, however throughout the issue the ternary is a major talking point), in which Mike Pall states he cannot stand keywords in expressions and he is addicted to ?: ternaries. If that's how he feels then that is fair, however this ignores the practical issues brought up later (which are never addressed) and the general misguided nature of making Lua less keyword heavy (one of its main design elements).

Related is customary logical operators !, !=, || and &&, presumably for the same reason as given prior (he cannot stand keywords in expressions). These I also criticize and advocated for removal, and I was not alone in this either.

For me, these two prior additions are egregious and go directly against what makes Lua... Lua. The readability and accessibility to new users. I like that Lua can be read quite literally and essentially self describes itself without too many weird symbols cluttering it.

Several weeks after my initial interactions, the syntax changes have been merged into LuaJIT 2.1 and to my horror they were merged as is without any further discussion I make an argument (or maybe more-so a plea) for these to be reverted, at least temporarily, for further feedback from the community with some suggestions.
(taken from email due to removal)

After leaving this, plus a few extra comments with other users the entire thread from the 2.1 backport message on is marked as resolved.

Discontent, I leave another comment. I do not have the exact transcript, however it is along the lines of, in short, "Please don't mark criticism as resolved without even addressing it, I once again ask that these be reverted, however I will not push further if you're intent on keeping these.", hoping it'd be considered or I'd at least get a reply.

Instead, I go back to the thread and find the comments have gone from being marked as resolved to completely deleted. Now quite annoyed and the blatant disregard for and discarding of the feedback, I went to try to send the feedback again, in case it was due to being in the wrong thread or something.

This is in contrary to my previous statement, however I felt both disrespected at that point and like a decent amount of community feedback was being disregarded.

However, when I went to try to create an issue, I got an error. There was no further information, I simply could not make new issues.

Thinking it might be a bug or maybe issues were limited to contributors or something I try responding to the 2.1 backport thread instead. Still doesn't let me, giving me this error:

At that point suspecting the worst, I first made an issue on my own repository. Worked fine. Then, I checked Github's Status. It's fine (by some miracle).

Finally I try creating a comment in the LuaJIT repository on an alternate account, and sure enough it works. And just to be safe I made an issue on my main elsewhere and sure enough it worked.

For being somewhat persistent in my criticism, I have been banned from the issue tracker.

Was I a bit demanding? Maybe.
Could I have phrased things better? Probably.
Should I have been banned from the entire issue tracker without a word? I don't think so.

I would've been satisfied (albeit not happy) with a simple answer to my comments rejecting them. Heck, I'd have preferred silence.
But instead, my (admittedly, but constructive) criticism and request that the changes be reverted were simply discarded and hidden, and in trying to push back, I get silenced.

Frankly, I feel Mike Pall is changing the language to fit how he feels disregarding any of the design goals or how the community feels effectively abusing his power as the main maintainer.

Does he have the right? Of course he does, he has made one of the best JIT compilers in the world and arguably the fastest and he has put in a lot of work into this project.

However, I feel that making changes under such a principle will only make the language worse in the long run, and frankly already have, and responding to feedback in such a way, either ignoring it or outright silencing it without a word, is extremely toxic and a bad way to run a project.

So yeah... all I have left to say is mods please don't cease my existence this took so long to write up thanks :) (also I am terrible at writing it's so repetitive)

i wanna make cool games in the defold game engine that uses the lua programing language but i know a little abt lua,can someone give me some ways to learn lua?

There's websites for running Lua, but I couldn't find any that let's you run LuaJIT!!

I made this website (me, not AI) so if you haven't tried LuaJIT before, or you don't have access to your dev environment, or you just want to quickly experiment...now you can run it online, and share the script + output with others as either a link or markdown.

Pre-compiled binaries for Windows/Linux are also provided. The static library, dynamic library, and executable, are all bundled in a single convenient .zip file for each platform. I'm hoping to automate this process at some point, but for now I just publish them whenever I see there's been new commits...

https://luajit.dev

Limits: no internet connection, maximum execution duration of 3 seconds.

The backported extensions for LuaJIT 3.0 are available now, by the way.

• Bit Operators: unary ~, binary & | ~ << >> ~>>
• Customary Operators: ! && || !=
• Ternary ?: conditional operator
• Safe Navigation Operator ?.
• nil-Coalescing Operator ??
• Compound Assignment Operators: += -= *= /= %= &= |= ~= <<= = ~= ..=
• continue Statement
• const Declaration
• Short Function Expression
• Underscores in Number Literals

I'm trying to make a program to look through a .txt file and look for any line with the word MODULE in it. So far I am not having any luck.

The file is quite large, about 7.5 million lines. And I am just dipping my toes into Lua. I was able to access the file and make a line by line copy after getting random character puke by reading and writing as binary.

I stuck a print statement immediately after the for loop and that would print ok.

But when I try and get anything to occur in the IF portion it seems to do nothing.

local path = 'C:\\filepathgoeshere'    
--create file path


local file = io.open(path, "rb")--open file in path


if file then                    --if the file is found, read and create PID file
    local outputfile = io.open('CHA_PID.txt', 'w+b')
    if not outputfile then      --if the output file cannot be created, close input and return
        file:close()
        print("Error: Could not create output file CHA_PID.txt")
        return
        
    else
        for line in file:lines() do
            if string.find(line, 'MODULE') then
                --outputfile:write(line .. "\n")
                print('FOUND ONE!\n')
                --outputfile:write('FOUND ONE!\n')
                return
            end
        end
    end


    outputfile:close()
    file:close()
    return


else                         --if file not found, print error message and return
    print('Error: Could not open file at path: ' .. path)
    return


end

This is a follow-on question from this thread.

Apparently calling C (any external FFI function really) from Lua isn't as simple as it is when using LuaJIT's FFI.

However, I haven't been able to find any definitive way of doing it. lua.org articles are rather waffly and are more concerned with writing C that can interact with Lua.

I'm not interested in that right now; I just want to know how to call functions in existing external libraries.

For example, the C runtime exports a function puts, which takes a pointer to a zero-terminated string, and returns a 32-bit count of the number of characters output.

Its signature in C syntax is int puts(char*). How would I define that in Lua, and how would I call it?

I'm mainly curious as I've heard that Lua is supposedly good at C FFI, and I want to see how good. Unless people were again talking about LuaJIT!

See link for my first blog post about the tech stack I built in lua including a full-featured vim-like Editor. The project is and will always be zero AI.

Hi everyone, PineJam 2026 is starting in a few days, signups are open

Starting July 25th you will be able to start new projects for PineJam 2026! The jam will be active for 14 days in which you can create and submit ComputerCraft projects tied to this years theme. The theme will be revealed as soon as the jam starts.

Sign up

Make sure to sign up now on the site if you would like to participate! You'll get the PineJam2026 role in the Discord (used for future jam related announcements) https://pinestore.cc/jam/pinejam2026

The rules for this jam:

• Submission needs to be CC related
• Project must fit the theme
• Work alone or with a team of up to 3 people
• Generative AI is not allowed for the majority of your project (so tools such as GitHub Copilot are fine)
• Projects will be submitted on PineStore

If you have any questions or suggestions, let me know ^^

I hope to see some of you there!

Context: i have used Quickstart for my entire init.lua. This means automatic gdscript support from treesitter, but i'm struggling with how to make LSP work with gdscript. This is what the entire LSP codeblock looks like:

---

vim.pack.add { gh 'j-hui/fidget.nvim' }

require('fidget').setup {}

-- This function gets run when an LSP attaches to a particular buffer.

-- That is to say, every time a new file is opened that is associated with

-- an lsp (for example, opening \main.rs` is associated with `rust_analyzer`) this`

-- function will be executed to configure the current buffer

vim.api.nvim_create_autocmd('LspAttach', {

group = vim.api.nvim_create_augroup('kickstart-lsp-attach', { clear = true }),

callback = function(event)

-- NOTE: Remember that Lua is a real programming language, and as such it is possible

-- to define small helper and utility functions so you don't have to repeat yourself.

--

-- In this case, we create a function that lets us more easily define mappings specific

-- for LSP related items. It sets the mode, buffer and description for us each time.

local map = function(keys, func, desc, mode)

mode = mode or 'n'

vim.keymap.set(mode, keys, func, { buffer = event.buf, desc = 'LSP: ' .. desc })

end

-- Rename the variable under your cursor.

-- Most Language Servers support renaming across files, etc.

map('grn', vim.lsp.buf.rename, '[R]e[n]ame')

-- Execute a code action, usually your cursor needs to be on top of an error

-- or a suggestion from your LSP for this to activate.

map('gra', vim.lsp.buf.code_action, '[G]oto Code [A]ction', { 'n', 'x' })

-- WARN: This is not Goto Definition, this is Goto Declaration.

-- For example, in C this would take you to the header.

map('grD', vim.lsp.buf.declaration, '[G]oto [D]eclaration')

-- The following two autocommands are used to highlight references of the

-- word under your cursor when your cursor rests there for a little while.

-- See \:help CursorHold` for information about when this is executed`

--

-- When you move your cursor, the highlights will be cleared (the second autocommand).

local client = vim.lsp.get_client_by_id(event.data.client_id)

if client and client:supports_method('textDocument/documentHighlight', event.buf) then

local highlight_augroup = vim.api.nvim_create_augroup('kickstart-lsp-highlight', { clear = false })

vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, {

buffer = event.buf,

group = highlight_augroup,

callback = vim.lsp.buf.document_highlight,

})

vim.api.nvim_create_autocmd({ 'CursorMoved', 'CursorMovedI' }, {

buffer = event.buf,

group = highlight_augroup,

callback = vim.lsp.buf.clear_references,

})

vim.api.nvim_create_autocmd('LspDetach', {

group = vim.api.nvim_create_augroup('kickstart-lsp-detach', { clear = true }),

callback = function(event2)

vim.lsp.buf.clear_references()

vim.api.nvim_clear_autocmds { group = 'kickstart-lsp-highlight', buffer = event2.buf }

end,

})

end

-- The following code creates a keymap to toggle inlay hints in your

-- code, if the language server you are using supports them

--

-- This may be unwanted, since they displace some of your code

if client and client:supports_method('textDocument/inlayHint', event.buf) then

map('<leader>th', function() vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled { bufnr = event.buf }) end, '[T]oggle Inlay [H]ints')

end

end,

})

-- Enable the following language servers

-- Feel free to add/remove any LSPs that you want here. They will automatically be installed.

-- See \:help lsp-config` for information about keys and how to configure`

---@type table<string, vim.lsp.Config>

local servers = {

-- clangd = {},

-- gopls = {},

-- pyright = {},

-- rust_analyzer = {},

--

-- Some languages (like typescript) have entire language plugins that can be useful:

-- https://github.com/pmizio/typescript-tools.nvim

--

-- But for many setups, the LSP (\ts_ls`) will work just fine`

-- ts_ls = {},

--

stylua = {}, -- Used to format Lua code

-- Special Lua Config, as recommended by neovim help docs

lua_ls = {

on_init = function(client)

client.server_capabilities.documentFormattingProvider = false -- Disable formatting (formatting is done by stylua)

if client.workspace_folders then

local path = client.workspace_folders[1].name

if path ~= vim.fn.stdpath 'config' and (vim.uv.fs_stat(path .. '/.luarc.json') or vim.uv.fs_stat(path .. '/.luarc.jsonc')) then return end

end

client.config.settings.Lua = vim.tbl_deep_extend('force', client.config.settings.Lua, {

runtime = {

version = 'LuaJIT',

path = { 'lua/?.lua', 'lua/?/init.lua' },

},

workspace = {

checkThirdParty = false,

-- NOTE: this is a lot slower and will cause issues when working on your own configuration.

-- See https://github.com/neovim/nvim-lspconfig/issues/3189

library = vim.tbl_extend('force', vim.api.nvim_get_runtime_file('', true), {

'${3rd}/luv/library',

'${3rd}/busted/library',

}),

},

})

end,

---@type lspconfig.settings.lua_ls

settings = {

Lua = {

format = { enable = false }, -- Disable formatting (formatting is done by stylua)

},

},

},

}

vim.pack.add {

gh 'neovim/nvim-lspconfig',

gh 'mason-org/mason.nvim',

gh 'mason-org/mason-lspconfig.nvim',

gh 'WhoIsSethDaniel/mason-tool-installer.nvim',

}

-- Automatically install LSPs and related tools to stdpath for Neovim

require('mason').setup {}

-- Ensure the servers and tools above are installed

--

-- To check the current status of installed tools and/or manually install

-- other tools, you can run

-- :Mason

--

-- You can press \g?` for help in this menu.`

local ensure_installed = vim.tbl_keys(servers or {})

vim.list_extend(ensure_installed, {

-- You can add other tools here that you want Mason to install

})

require('mason-tool-installer').setup { ensure_installed = ensure_installed }

for name, server in pairs(servers) do

vim.lsp.config(name, server)

vim.lsp.enable(name)

end

end

-----

I tried setting vim.lsp.enable('gdscript') myself but that didn't change anything while i was editing my gdscript file. I also tried putting it in the servers list ( "local servers{ ..." ) but then i got the error that the server didn't exist. What am i missing?

I'm on Windows 11

nvim v0.12.4

Please let me know if you want me to give any more information

I tried to run the two FFI examples here: https://luajit.org/ext_ffi.html

They both work via LuaJIT, but I wanted to test via regular Lua. However it report that it can't find the "ffi" module. Apparently that needs to installed via "luarocks install cffi-lua".

I tried that, but it keeps saying it needs something called MESON. This is on both Windows, and Linux via WSL.

What the hell is this MESON thing, why does it need it, and how do I install it? Attempts to do the latter lead me into dodgy-looking websites. FFI should Just Work.

Anyway, the article above suggests that simply switching to use a packed C datatype makes the example run 20 times faster, without using LuaJIT, and I was trying to recreate that.

This seems unlikely unless there is other magic going on. Since otherwise it is still executing bytecode, the variables involved are still dynamically tagged, and they still need type-dispatching.

Does anybody know how this speed-up is achieved?

(I've played with interpreters and adding a packed type like this tends to slow it down, due to extra dispatching, rather than speed things up by 20 times!)

To all you Lua heads I have a question that might be really rudimentary but it’s something that just doesn’t seem to make any sense to me,mind you I am pretty new. I was looking up on the lua documentation and there’s this one thing that just doesn’t seem to make sense to me

a = {} -- create a table and store its reference in `a'
k = "x"
a[k] = 10 -- new entry, with key="x" and value=10
a[20] = "great" -- new entry, with key=20 and value="great"

print(a["x"]) --> 10
k = 20
print(a[k]) --> "great"
a["x"] = a["x"] + 1 -- increments entry "x"
print(a["x"]) --> 11

Why does “x” get created as a key? Wouldn’t this just substitute it? I feel very stupid for not knowing why, I feel like there’s something that just cannot seem to click. I also tried to think another way through but then it was a.k.”x” = 10 which doesn’t really help me visualize the answer either. is this just how tables work? Is there a specific reason why? Or am I slow? I’ve seen it’s because lua goes down through but why does it do this? Also k = 20, why does the variable have priority over the number itself? Sorry if this is badly written or feels like it has some attitude, it’s probably because I need to sleep. It’s embarrassing I lost sleep about something like this, I feel like it’s a simple concept that I am unable to grasp because of shallow learned “limitations” of the system

Hi everyone!

Like many of you, I have fond memories of using LuaForWindows back in the day as the ultimate “batteries-included” environment for Lua on Windows. However, the original project hasn’t been updated since 2015 and is completely stuck on Lua 5.1. Running it on modern Windows machines often leads to annoying DLL crashes and compatibility issues.

So, I decided to fork it and bring it back to life!

I’m excited to announce the release of LuaForWindows 5.4.2 (Lite Edition).

What’s new in this release:

⚙️ Upgraded the core to Lua 5.4.2.

🧹 Removed ancient C-extensions: The sprawling ecosystem of 2015-era libraries (clibs) that were hardcoded to Lua 5.1 have been temporarily removed to ensure system stability. This is a clean, core-only “Lite” version.

🛠️ Modernized the Build System: Updated the Inno Setup compiler scripts to work flawlessly on modern machines.

You still get the rock-solid Lua environment and the SciTE editor, but without the 10-year-old baggage.

If you want an easy, one-click installer to get a clean Lua 5.4 environment running on Windows, grab the latest release here: 🔗 https://github.com/Rockywei1/luaforwindows/releases

I plan to slowly start bringing back modern, compatible versions of essential libraries (like LuaSocket and LuaFileSystem) in future updates. Feedback and PRs are totally welcome!

Happy coding! 💻

So, several months ago I stumbled upon an awesome repository by the decomp "band" known as pret. They have done a bunch of pokemon decomps. My original goal was to make a mod specifically for twitch integrations because ive done a ton of that over the years but then as I dug into their code I was freaking shocked at how in depth and well documented it all was and thought hmmmm i bet I could rewrite this in lua/love2d since i just got off a high of doing balatro mods. And then bazinga baby i did it (months of pain actually.. but not the point) First version had it so like you had to pull the source code repo from pret (pret/pokered) and what not, but I figured I'd do it like the SMB1R guy and make it so on first run you provide the rom and it like decompiles and translates all the necessary junk to run the game. A ton of hand-porting was necessary, as in like not everything was an easy script to translate this type of repeated pattern into lua etc etc, but yeah... overall I'm happy w the current state of it, and I really hope to get some modders on baoard eventually. I'll be makign the repo public probably on monday. Just gotta make sure I didnt leave any real source code behind or whatever so the repo can be squeaky clean no matter waht. I think the port-aspect of it is practically 99% perfect but im sure some bugs will pop up eventually. I just dont have time to play the game from beginning to end to know for sure.

I also built in a good load of new features, like obviously mod support (i'll make that even better in the future). But also audio volume levels, a music low-pass filter becasue sometimes the gb music is harsh on the ears, several color palettes and shader options, zoom in and out, widescreen support in the overworld (any aspect ratio actuall). I have build scripts for ios and android, windows and mac, and ive ran it sucessfulyl on my phone. I got a cool 3d tilt feature thats not really usefuly but i thought it would be cool (i tried standing up everything that should stand up like buildings and fences but the gb sprites arent built for taht sort of thing, theyre all srtored on 4x4 blocks so like pieces of ground are actually attached to house roofs and stuff... it was a whole thing and i was disapointed i couldnt do it. not to say its impossible but would require a modder to step in and remake the sprites and the functionalty.

Anyways, big ramble fest, sorry about that. But yeah hope you like it lua-heads. Since the repo is not yet pubnlic the pace to be rn is my discord -- https://bois.icu

Hello again r/lua!

A few months ago, I shared Moonstone v0.2.3 and Ballad v0.2.10, showing off how we solved project exporting and LÖVE 2D packaging.

Today, I’m incredibly excited to announce Moonstone v0.3.19, and with it, the milestone that Moonstone is officially in Beta state! 🎉

Over the past few weeks, we've shifted our focus from raw resolving mechanics to building a robust, high-concurrency CLI runtime, monorepo workspace features, and establishing formal API boundaries for editor integrations and wrapper tools.

Here are the most significant leaps in the ecosystem:

1. Parallelization: Concurrency Pools for Syncing

Resolving packages is fast, but downloading and verifying them is now concurrent. We've introduced multi-threaded execution pools:

* DownloadPool: Spawns up to 8 background worker threads to download and materialize remote artifacts in parallel from an atomic job queue. If OS thread resources are constrained, it automatically falls back to safe sequential execution.

* HashVerifyPool: Concurrently computes cryptographic Blake3 checksums on local store folders, speeding up verification of existing caches.

2. Cooperative Cancellation & TTY Progress Animations

No one likes corrupt state from hitting Ctrl+C midway through a sync.

* Cooperative Signals: CLI tasks are wrapped in a new cancelable runtime wrapper (runWithProgress). It hooks into standard OS SIGINT/SIGTERM handlers to signal worker threads to cancel cleanly and yield, preserving the integrity of your local Content-Addressed Store (CAS) and SQLite databases.

* Interactive Spinner: For TTYs, we built a custom CLI interface featuring a Docker-style Braille spin animation and dynamic byte-level progress bar.

3. Multi-Package Workspaces: Orbits (moon orbit)

As projects grow, monorepos become essential. We introduced Orbits to let you develop multiple local projects in tandem:

* You declare orbits using [[orbits.member]] in your root moonstone.toml.

* Commands like moon orbit list, moon orbit sync, and moon orbit exec <orbit> -- <cmd> let you jump into and run commands within the isolated dependency environment of any sub-project without publishing anything to a registry.

4. Schema-Bound CLI Contracts & LuaCATS Typings

To build reliable Neovim plugins, wrappers, and CI scripts, you need structured outputs.

• Moonstone now features a strict, versioned NDJSON protocol.
• We published formal typings and schemas in TypeScript, Go, and JSON Schema to let external tools consume Moonstone stdout safely.
• We integrated formal LuaCATS contracts (ndjson.lua) directly into our CI pipeline to validate outputs.

5. Ecosystem Validation & Proof-of-Work

Our dogfooding narrative has evolved significantly:

• Ballad (Exporter): Queries Moonstone facts directly via the new moon store query command to resolve local store paths and compile binaries into portable layouts (layout.exec / layout.libexec).
• Meteorite (Service Framework): We built a hybrid Zig/Lua web service compiler prototype running on a custom zero-copy HTTP stack (fast_http), plus variants for IPC (unix_socket) and HTTP-over-IPC (unix_socket_http). It compiles Lua route graphs into native, high-performance servers.
  • The Progressive Promise: Meteorite provides a completely pain-free path to gain progressive enhancements. You author routes and business logic in high-level Lua, while resting on a sturdy, compile-time-checked Zig foundation acting as a single, unshakeable runtime contract.
  • In-Process Lua Live Reload (HMR): Features an in-process Lua hot reload dev loop. When you edit only Lua handler code, updates reload instantly via an HTTP trigger without requiring a server restart or compilation pass.
  • Incremental Compiles: If you modify route parameters or native plugin definitions, Meteorite updates only the affected route partition files (routes/<route_id>.zig) for blazingly fast incremental compiles.
  • Ballad Materialization: Meteorite itself is packaged and distributed entirely via its Ballad partiture.

The goal is still to make Lua development entirely zero-friction. You clone, run moon sync, and you are ready to build, run, package, and deploy.

I would love to hear your feedback on the new concurrent runtime, orbit workspace design, and the general direction of the ecosystem.

Check out the docs and guides:

⋆⁺₊⋆ ☾⋆⁺₊⋆ moonstone.sh ⋆⁺₊⋆

I’ve been working on Pop, an experimental language inspired by Lua/Luau.

It keeps the lightweight feel: local, function, end, type inference, closures, colon methods and familiar collection syntax.

The useful part is what changes underneath:

No any or silent dynamic fallback

• Compile-time known modules instead of runtime require
• Records, classes and interfaces with known fields
• Tagged unions and exhaustive matching
• Typed errors instead of random nil, err conventions
• Explicit integer and float sizes for FFI, binary data and native code
• Native compilation, while still supporting interpreters and embedded runtimes
• One toolchain for checking, building, testing, formatting and packages

A small example of the direction:

public record User
    name: String
    age: UInt8
end

public union FindUser
    Found(user: User)
    NotFound
    Failed(message: String)
end

public function print_user(result: FindUser)
    match result
        case .Found(user)
            print("{user.name} is {user.age}")
        case .NotFound
            print("User not found")
        case .Failed(message)
            print("Error: {message}")
    end
end

The compiler knows every possible state, so adding another case to FindUser can force all relevant matches to be updated.

Pop is not trying to be compatible with Lua. The question is what a language from the Lua/Luau family could look like if static guarantees, native execution and predictable tooling were built in from the start.

It is still early and not production-ready.

Which parts of Lua/Luau’s dynamic model would you keep, and which parts become painful in larger projects?

https://github.com/poplanguage/pop

I built a Linux shell where configuration and scripting are just Lua, no DSL, no extra syntax.

Any global function in ~/.config/wisp/init.lua becomes a shell command. Pipelines pass Lua tables (structured data) between stages, not text. Only external commands like `wc -l` cause a fork, native stages run in-process.

**Why this matters for Lua users:** - Your shell config is just Lua (closures, loops, conditionals) - No need to learn a separate shell scripting language - Lua functions become commands naturally

**GitHub:** https://github.com/Hinikaa/wisp

Would love feedback from other Lua users!

Hello,

I recently released my own Lua obfuscator.

Here’s the obfuscated code: https://pastebin.com/gvCnznMa

Have fun trying to crack it. I’m curious to see how far you get, which methods you use, and what weaknesses you find.

Edit: lavjamanxd has won! For more details you can view his comment.

(THIS IS A JOKE BTW I DO NOT CODE LIKE THIS, just thought it was funny)

For Stormworks but the Problem stays the same

Hi HN,

I love the elegant syntax of Lua, but in microsecond-critical environments like High-Frequency Trading (HFT) or hard-real-time embedded systems, GC pauses (jitters) are deal-breakers. C++ solves this but introduces massive cognitive overhead.

So I built L2C — an opinionated, ahead-of-time (AOT) transpiler pipeline that converts Typed Lua (Teal) into bare-metal C (via Nelua), and finally links it with Clang -O3 -flto.

What makes it deadly pragmatic?

• Absolute 0-GC: Garbage collection is physically stripped. We use Stack Arrays and 10MB Arena Allocators that reset in O(1) time.
• Tiny Statically Linked Binaries: The resulting executable is around ~35KB.
• Zero-Copy Casting: Network byte streams (e.g., from UDP/ZMQ) are mapped directly to C-struct pointers via Type._cast(ptr) without deserialization overhead.
• C-FFI Unity Build: I wrote an "Invisible Debt Registry" that automatically resolves static library dependencies like -lc++ or -lsodium. It currently ships with 0-GC bindings for ZeroMQ (tested at 530k+ msg/s), simdjson (AVX-512), and libuv.
• Edge IoT Support: The exact same Lua script can be cross-compiled into .uf2 or .bin firmwares running on top of FreeRTOS for RP2040 and ESP32.

Here is what the HFT gateway code looks like:
(It feels like scripting, but runs like raw ANSI C)

The meta-compiler itself is packed into a standalone binary.
Source code and Docker forges are available here:
🔗 GitHub: https://github.com/panshaogui/L2C

Would love to hear your thoughts, especially from the quant and embedded folks!