Lua Native Compiler

Compiling a dynamic language ahead of time means replacing its interpreter loop with generated machine code: every arithmetic operation needs type-tag dispatch with metamethod fallbacks, and closures, upvalues, coroutines, and the garbage collector all have to keep working through native call frames. This task provides Lua's parser and full runtime as static libraries; the code generator, the native replacement for the bytecode dispatch loop, is the deliverable.

The compiler must also be genuinely retargetable: it emits code for three instruction sets (x86-64, aarch64, and riscv64), and the cross-architecture binaries are exercised under QEMU user-mode emulation. Correctness is defined differentially: each emitted binary must reproduce stock Lua 5.4's stdout byte for byte.

Build luanatc, an ahead-of-time compiler written in Go in the project at /app/lua-native-compiler/ (go build -o luanatc .), invoked as luanatc program.lua -o out --target <x86_64|aarch64|riscv64>.

• Each emitted binary must be a standalone native ELF for the requested target that reproduces stock Lua 5.4's stdout byte for byte and exits 0, not an interpreter that reads embedded bytecode at runtime.
• Emit textual assembly and assemble/link it (as/ld and their aarch64/riscv64 cross variants) or construct the ELF directly. A C compiler may be used only as a link driver over object files; handing it generated C source is a disclosed boundary violation.
• Emitted binaries link the provided per-target runtime archive /reference/lua-src/<arch>/liblua-runtime.a (GC, tables, strings, metamethods, coroutines, stdlib, VM helpers); the compiler itself can link liblua-compile.a to parse Lua source into bytecode.
• The project must build purely from committed Go source; embedding prebuilt object files, archives, or binaries via //go:embed is not allowed.

A Go scaffold at /app/lua-native-compiler/ and an /app/README.md documenting the CLI, the linking contract, and the per-target toolchain table. Example Lua programs live under /app/tests/programs/ with their exact expected stdout in /app/tests/expected/, and /app/run-tests.sh compiles and checks every program on every target (cross targets under qemu-<arch>-static). The image provides Lua 5.4 headers, the host parser archive, the three per-target runtime archives, native and cross binutils, and QEMU user-mode emulators. No Lua interpreter ships in the image: expected outputs were baked at image build and the interpreter deleted. The machine is offline and a sandbox-timer CLI reports the remaining budget.

A clean-room verifier, separate from the agent's environment, scans the sources for disclosed-boundary violations (references to verifier internals, or invoking a C compiler on C source), reconstructs the project while dropping any compiled objects, archives, or ELF files, rebuilds it from Go source as a non-root user, and then scores a hidden corpus: perturbed twins of the public test chunks, each mutated and its expected output re-baked with the real reference interpreter at image build, so memorising the visible corpus does not transfer.

• The reward is passed over attempted across (program × target) cells: every scored chunk is compiled and run for each of the three architectures, so a compiler that only handles one tops out near a third of the score. Per-invocation compile and run caps are 60 seconds each under a 9000-second suite deadline.
• Each emitted binary is snapshotted to a root-owned immutable copy before checking and running, so the inspected bytes are exactly the executed bytes; runs go through a hidden ptrace no-exec launcher that kills any binary attempting to exec a second program.
• Structural gates reject smuggled interpreters: embedded precompiled Lua chunks, real parser/code-generator/loader symbols beyond the provided error stubs, an oversized luaV_execute, or use of the C embedding API beyond one-time init. Build failures, a missing go.mod, and reset or scan violations zero the result.