Loment is a systems programming language. It compiles to native x86-64 executables —
Linux ELF, Windows PE, or a freestanding object for bare metal — with no runtime and no
libc. The toolchain is itself written in Loment and needs no Python to run. Its own syntax
is Rust-flavored, and the same program can be written in six more: C, C++, Java, C#, Go or
Python.
Download 0.1.4 ·
Quick start ·
Project site ·
Manual ·
Language guide ·
Examples ·
Contributing ·
Issues ·
Discord
The release has a Linux tar.gz, a Windows zip and a Windows installer — installing and
running needs no Python, no clang and no WSL. loment run hello.lomt and you are done.
0.1.4. It ships as a package — the
Loment 0.1.4 release carries a Linux
tar.gz, a Windows zip, a Windows setup.exe installer and the agent-guide zip. You can also
build the toolchain from a checkout (QUICKSTART.md). What 0.1.4 does not
include yet is listed honestly in docs/202.
The toolchain is self-hosted at run time: it compiles and runs with no Python and no
libc. The development side is not, and 0.1.4 shipped before that gap closed:
tools/ still holds the reference implementation (tools/lomentc.py and friends) and the
Python test suites (docs/189). The work is done one criterion
at a time — each Python criterion gains a Loment twin, and the two must agree byte for byte
before the Python side can be retired. Until that finishes, both copies are in the repository
on purpose, and "the repository contains only Loment" is not yet true.
What 0.1.4 does and does not include is listed item by item, and was audited, in
docs/202 — including the three items still open
(a hosted layer, two GC tiers, full self-hosting).
The language surface is frozen — docs/158 says what changing it
costs — and the implementation is not.
module hello
fn _start() {
let s: str = "hello from Loment\n";
syscall4(1, 1, str_ptr(s) as u64, str_len(s) as u64);
syscall4(60, 0, 0, 0);
}$ loment run hello.lomt
hello from Loment
_start is the entry point, because there is no runtime to call one for you, and output goes
through the write system call, because there is no printf. QUICKSTART.md
takes it from here — sources, toolchain, and the first four rows below.
Most languages answer "what can this program do?". Loment is arranged around a narrower
question — who can run what, in what scope, and can that be settled without reading the
source? Three things carry it:
The rest of the language exists to keep that question answerable. The core stays small; what
grows is the layer around it (docs/175).
That last row, in full — the report you actually read when a line does not compile. The
compiler emitted a code and a position; everything below message: came from lomenterr:
Loment is developed with AI coding agents in the loop, and says so: CLAUDE.md and
AGENTS.md at the root are the working conventions, and the language guide sits where agents
are configured to look for it — the same file ships in the package as loment skill --print.
What that buys is less the tooling than the discipline around it: a change here is checked by
a program rather than by a reviewer's memory. Two implementations of the language surface must
agree byte for byte, every claim in docs/ is tied to a criterion, and those criteria are
what keep the claims on this page honest.
Getting help and contributing
Ask in an issue or on
Discord — questions are as welcome as bug reports. Loment is
developed in this repository; the working conventions, including how a change is checked
before it lands, are in AGENTS.md.
MIT. See LICENSE.