The same tools and workflows your users see, driven end to end: prepared, inspected, finished.
AGENT-NATIVE LANGUAGE AND RUNTIME
Turn your software into an agent-native environment.
An agent-native application is one an agent can inhabit — discover it, work it, and extend it from the inside. The engineer who spends a week preparing a model, the technician who builds every case by hand: with Luna, that expertise lives inside your product — because the application itself is the agent.
WHAT LUNA IS
Any application can embed a scripting language. Scripts run when called, errors surface at run time, and whatever they touch is simply changed. Luna is built for something else: an expert working inside the application — and extending it when the work needs more. Its first act is asking: the application describes itself, and a fresh agent can be dropped in and learn it in minutes.
A compiler lives in the product. Everything an agent writes is fully checked before it can run — types, calls, effects, even termination — then shaped into retained bytecode. A mistake refuses with a readable sentence instead of failing in front of a user. Nothing unchecked ever executes.
The runtime is the sandbox. The agent does not run loose in your process — it lives inside Luna's runtime, and everything it does happens there. Experiments clean up after themselves; live motion leaves no trace; what someone deliberately keeps lands as one numbered act in a record the whole team — human and agent — shares, can read, walk backward, and replay.
Types, calls, effects and termination are proven before execution, then carried into the bytecode.
02 / EXPERIMENTS ARE CONTAINEDA tool's working state is put back when it endsA tool's temporary changes are undone when it closes.
03 / ONE ACCOUNTABLE RECORDEvery kept change is a numbered actPeople and agents share one record you can walk back and replay.
04 / FASTThe fastest embeddable languageReal algorithms, four languages, every answer identical to the last bit: Luna lands far ahead of Lua and Python, measured against hand-written C++ on every run.
05 / SCIENTIFIC COMPUTINGBuilt for numbers and meshesN-dimensional arrays, jagged blocks, and parallel primitives that produce data — and the answer never depends on the thread count.
06 / EMBEDDABLESmall enough to ship insideOne 11.6 MB client carries the compiler, runtime, host and console, with no external dependencies.
07 / SELF-DESCRIBINGThe language explains itselfA fresh agent asks, and the application answers from the same contracts the compiler checks.
08 / PRIVATE BY DESIGNYour implementation stays yoursShip a module as a compiled image with the source left out; callers still see every signature and document.
A program compiles once into retained bytecode with exact types: numbers live unboxed in native slots, a loop runs as the counted branch a hand would write, and nothing is checked again while it runs.
The shapes are native — dense N-dimensional arrays and jagged blocks over contiguous typed buffers — and parallel: true is one word that changes time and nothing else. That is what fast experiments are made of: scientific and engineering computation, sketched in the running product, answered at near-native speed.
The same algorithm in four languages, every answer bit-identical. Time as a multiple of hand-written C++, which is 1×; lower is better. An input of 100,352 faces on an Apple M4 Max; Lua is standard PUC-Lua, not LuaJIT. The other algorithms and their methods are on the language page.
One binary is the whole system — the compiler, the runtime, the executor, the terminal where people and agents meet, and the MCP door agents connect through. There is no AI model inside: Luna is the environment agents inhabit; the model stays outside. Each figure below is a measurement, stated with what it measures.
A native domain enters Luna through one typed contract: the type's identity, its layout and lifecycle laws, and each operation's signature with its native implementation, installed in a single transaction. What comes out are full Luna citizens: signatures an agent can discover, documentation, and tools built over them, while the implementation stays private behind the contract.
See how the host chooses what the language reachesPrivate implementation.
THE PACKAGED EXPERT
Expert work lives inside applications: days of preparation, judgment, and repetition by the people who know the tool best. That expert can now ship with the product — and it is not bound by the UI. It works at program speed — trying things in its own workspace, with every attempt checked, contained, and recorded.
The same tools and workflows your users see, driven end to end: prepared, inspected, finished.
A workflow, a tool, a checked function — written like an expert engineer would, published into the running product for end users.
The application becomes the interaction surface between your end users and their expert. They cooperate in the product, not beside it.
An agent given buttons stalls where no button fits, and hands the job back.
The resident writes the missing step and finishes — and the step stays.
It reads the signatures, documentation, and authored source of the application it lives in.
It drives the same tools and workflows people use, in its own workspace.
When a step is missing, it writes it — and the resident compiler checks it, shapes the bytecode, and only then runs it.
Finished work lands as numbered acts in the one record people and agents share.
Useful in this session, immediately. What the agent builds is usable immediately — by it, by the application, and by people. Putting it in front of end users is a separate, deliberate step.
The agent can try things freely. While a tool is open, its changes are temporary — close it, and everything it touched goes back to how it was. Moving, adjusting, experimenting: none of it leaves a trace by itself.
Keeping a result is a deliberate step. When someone — a person or the agent — decides their work is done, it is saved as one clean entry in a shared history. Anyone can see what changed, and step back to any earlier point.
See how the runtime holds live work and recorded changestemporary changes — no history
save #41 lands
THE APPLICATION IS THE WORKSPACE
Both paths use the same language and runtime. You choose exactly which of your application's capabilities the language can reach; your implementation stays private. The agent develops new programs, and your application can call them.
Keep your interface and native implementation. Expose the capabilities an agent can build with, then call the functions it publishes.
The compiler and runtime can run headlessly. Your application supplies the interface.
Author tools, panels, interactions, and workflows in the same language the agent uses to extend them.
A new capability can become part of the running interface through the same authored functions.
Checked programs · live environment · record
GO ONE LEVEL DEEPER
Script-like to write. Checked once and retained as bytecode. Exact types, native arrays, async, and checked parallel work.
02 / THE RUNTIMEOne place where people and agents work: safe experiments, live updates, and a history you can read.
LUNA
Embed Luna in the application you run today, or build an application whose tools and workflows are Luna programs. Give people and agents a shared place to make it better.
BUILT WITH LUNA