Loment 0.1.4.5 QuickFix

Loment 0.1.4.5 QuickFix

A patch on top of 0.1.4.5. The toolchain
binaries in this package are byte for byte the same as that release's; what changed is the
Windows installer.

What was wrong

Double-clicking setup.exe looked like it did nothing. Measured, it was doing everything: the
package unpacked, install.cmd ran, the toolchain was installed, and the version file was written.
What it never did was show anything — and the console it leaves behind is not visible in that
launch, so "installed correctly" and "nothing happened at all" were the same thing on screen. It also
left cmd processes sitting at pause afterwards.

That is worse than a cosmetic problem: the previous release's headline installer bug was a package
that silently installed nothing, so the reasonable reading of "no window appeared" was that this one
was broken too.

What this release changes

The installer has a face. A window that, on a plain double-click:

1. fades in a rounded Loment mark and Welcome to Loment;
2. asks where to install, with the switches it used to bury in README.md as checkboxes
   (PATH, .lomt/.lom file association, the agent guide);
3. shows the install as it runs — the actual install.ps1 output, streamed line by line;
4. ends on a receipt: a green check, Loment 0.1.4.5 QuickFix is installed., and the window
   stays open until you close it.

It does not reimplement any of the install: it drives install.ps1 and shows what install.ps1
says. One implementation of the install, two faces.

The command line is untouched. install.cmd with any argument (-Prefix, -NoPath,
-DryRun, -Uninstall, and everything CI uses) takes the console path it always had, with the same
output and the same exit codes. Only a bare double-click — no arguments — opens the window.

A second, quieter fix. The installers now resolve loment and lompi after installing and
name anything earlier on PATH that is not this install. They only ever append to PATH
(deliberately — an installer should not reorder a machine it does not own), so a copy installed
earlier by hand wins silently, and lompi version then reports the older build with nothing
anywhere explaining why.

Install

Asset
loment-0.1.4.5-quickfix-windows-x64-setup.exe	Windows x86-64. Double-click; a window walks you through it.
loment-0.1.4.5-quickfix-windows-x64.zip	Windows x86-64. Unzip and run install.cmd (same window), or call install.ps1 yourself.
loment-0.1.4.5-quickfix-linux-x64.tar.gz	Linux x86-64. Unchanged from 0.1.4.5 — the Linux route always printed what it was doing.
loment-skill.zip	The agent guide (SKILL.md) on its own.
SHA256SUMS	Checksums. The installers verify the payload against this before copying anything.

Installing and running needs no Python, no clang and no WSL.

Which release to install

• 0.1.4.5's installer is unchanged and stays published as it is. Its setup.exe does install —
  it just does it invisibly. If you already installed from it, you have this toolchain; nothing needs
  re-installing.
• 0.1.4's setup.exe is still not being rebuilt
  (#117) — that asset genuinely installs nothing.
  Use the zip, or take this release.

Everything else

There are no other changes. What 0.1.4.5 contains — the four-rung GC ladder and the generational
collector, networking on both targets, lompi 0.2.0 Alpha — and what it does not contain, along
with the known open bugs, are listed in the
0.1.4.5 release notes; that document
still stands as written.

Loment 0.1.4.5

Loment 0.1.4.5

Three things were announced in
v0.1.4.5-pre while they were still
being built; they are in this release, along with the fixes that accumulated since 0.1.4.

This is not an exhaustive changelog — the issue and pull-request numbers below are the index.

Install

Asset
loment-0.1.4.5-linux-x64.tar.gz	Linux x86-64. Unpack anywhere; bin/loment is the launcher.
loment-0.1.4.5-windows-x64.zip	Windows x86-64. Unzip and run install.cmd.
loment-0.1.4.5-windows-x64-setup.exe	Windows x86-64, self-extracting. Double-click.
loment-skill.zip	The agent guide (SKILL.md) on its own, for people who want only that.
SHA256SUMS	Checksums. The installers verify the payload against this before copying anything.

Installing and running needs no Python, no clang and no WSL — the package is native binaries plus
the standard library. loment run hello.lomt and you are done.

---

New

LomentGC — reclamation as a ladder

Reclamation in Loment is not one algorithm over one heap. Every alloc site is assigned, at compile
time, to one rung of a ladder, and how much of this program's memory the collector is responsible
for is a number carried in the artifact:

Rung	What it does
L0	static promotion — a provably non-escaping allocation never reaches the heap at all
L1	last-use — the allocator front is returned right after the final use
L2	block epochs — a loop body, or either arm of an if, that allocates and drops returns its whole region at once
L3	mark-sweep with precise roots, triggered by bytes allocated

All four rungs are implemented twice — the reference compiler (tools/lomentc.py) and the
self-hosted one (loment/selfhost/) — and the two must agree byte for byte (#109, #110, #143, #157).
The tiers choose gc_manual / choose gc_auto / choose gc_auto_alpha select how far down the
ladder a unit is allowed to go. Potato v10 carries gc_ladder = {l0, l1, l2, l3, total_sites},
and two independent validators check the arithmetic (l0 + l1 + l2 + l3 == total_sites) without
reading a single line of source (#172).

The gc_auto_alpha policy is no longer one fixed threshold: it follows the live set (#200) and
collects generationally — a 1024-entry card table, a write barrier at every store8 site, and
minor / major levels (#230). The difference that matters between the tiers is not throughput but
the ceiling: on loment/examples/gc_heap/ — the repository's first program that really builds on
the heap (#264) — the same linked-list walk runs to completion under gc_auto and gc_auto_alpha
and exhausts the arena under gc_manual. Numbers in docs/210 §7.

Networking, on both targets

The same .lomt source opens a socket on Linux and on Windows, from the same output bytes. On
ELF the calls are the Linux syscalls directly; on PE the runtime dispatches 29 syscall numbers —
eight for files and processes, and the whole network surface through ws2_32: the sockets plus
poll, select, sendmsg / recvmsg, socketpair and epoll_* (#191 and the batches in
docs/217). As of this release no networking syscall is left
unimplemented on either target. syscall7 fills all six argument registers, so address-carrying
UDP — sendto / recvfrom, where the sixth argument is the socklen_t — is writable in the
language (#199). tools/loment_pe_test.py walks the whole surface by having a program connect to
itself.

lompi, the package manager

lompi moves to 0.2.0 Alpha and fetches by itself: lompi fetch reads the registry over a
raw socket instead of printing a git clone for you to run (#267). What it cannot do is HTTPS or
hostnames — there is no TLS and no resolver in the toolchain, so http:// with an IPv4 literal is
the whole fetchable surface (docs/236). Along the way the store
argument became optional, instance identity stopped re-reading the store, and --opt reached the
packaging path (#183, #188).

Two smaller features

• register <name> { ... } — declare a loment subcommand from source instead of hand-placing
  a loment-<name> executable on PATH (#208).
• The escape hatch, end to end — loment build --opt, a pre-optimized kernel object, and
  lompi obj, for the cases where the native toolchain's lack of an optimizer is the thing in your
  way (docs/212, #179, #195).

---

Fix

• The Windows installer works. (#117) — 0.1.4's
  self-extracting setup.exe unpacked and exited having installed nothing: it launched install.cmd
  by bare file name, and where NoDefaultCurrentDirectoryInExePath is set, cmd cannot resolve
  that. The launch command now carries the unpack directory. The 0.1.4 asset itself is not being
  rebuilt — that would change the bytes under a version number already in the wild — so 0.1.4 users
  should stay on the zip until they move here.
• The installers now name a shadowing lompi / loment. They only ever append to PATH
  (deliberately: an installer should not reorder a machine it does not own), so a copy installed
  earlier by hand wins silently — you type lompi version and get the older build with nothing
  explaining why. Both scripts now resolve the names after installing and print the path that is
  actually in front, without removing it.
• lomelf can link an L0-promoted product. An alloca used as a plain SSA value was not
  recognised, so a unit whose alloc sites were all promoted to the stack could not be linked at all
  (#239, #257). The same fix moved the write barrier
  to follow "does this unit need a heap", which had been emitting a reference to an arena that
  L0-promotion had removed.
• Two IR bugs that made array-subscript artifacts invalid LLVM (#177), and a release-manifest
  ordering bug that made every pull request look conflicted (#138).
• Entry points are correctly aligned: stackrealign is now emitted on _start, whose stack is 8
  bytes off the SysV convention (#206). Binary operators are typed by the expected type rather than
  by their operands (#204), and loment fmt refuses a file written in a non-native surface grammar
  instead of destroying it (#115, #203).
• The surface-grammar translators, in batches. About thirty issues fixed in the C, Python and
  other choose write grammar paths — silent drops, silently-wrong values, and files that failed to
  compile with a generic error instead of saying what was unsupported: the issues are #74,
  #115–#137 and #145–#155, and one language server crash (#142); the batches that fixed them are
  #171, #180 and #201. (docs/211 is how they were found: a
  pure-Loment project written in each surface grammar.)
• Two flaky criteria were made deterministic (#190, #261); flaky checks turn unrelated pull
  requests red and cost every contributor time.

---

What else

Not in this release.

• choose hosted — the dimension for artifacts that link real libc and shared libraries — is
  refused by a release build, by name (docs/222 sec 4.5,
  docs/219 sec 8c, #207, #258). The capability is in the development
  channel; calling libc from a 0.1.4.5 build is not offered.
• The vm dimension is in main and is refused by a release build the same way — it is a
  gate, not a feature, and an extension module's bytecode does not exist yet.
• The development side is not self-hosted. The toolchain compiles and runs with no Python at run
  time, but the reference implementation (tools/lomentc.py and friends) and the Python test suites
  are still in the repository (docs/189). "The repository contains
  only Loment" is not yet true.
• There is no networking library and no admission gate. std has no net module — you write the
  syscalls yourself — and a unit that declares excluded "network: ..." is not stopped from calling
  socket, because the capability check compares domain names and never looks at behaviour
  (docs/218).

Known bugs, still open. The ones most likely to be met, with their issue numbers:

• #164 — free checks neither ownership nor
  double-free, so freeing twice puts one region both at the frontier and on the free list, and two
  live allocations alias. Also #165: the Rust
  backend lowers free to a no-op.
• #265 — a function with 11 or more parameters makes
  the self-hosted compiler die with SIGILL, silently, where the reference implementation accepts it.
• #163 — lompi truncates any source file larger
  than 256 KiB, and the content-hash identity covers only the truncated part.
• #226 — a flat expression of ~250 terms makes
  check die with a RecursionError instead of a diagnostic.
• #149 — check does not check the bodies of
  modules brought in by use, so a library can ship with a body type error and every consumer checks
  clean. #139: two files that declare the same
  module name pass check and then produce IR with two define i32 @f.
• #262 — both language servers ignore the
  choose write grammar declaration, so a valid file in a non-native gr...

Loment 0.1.4.5 — coming

Loment 0.1.4.5 — coming

This is an announcement. There is nothing to download.

The tag carries no archives and no installers — it exists so that what 0.1.4.5 will
contain is stated in public while it is still being built. If you want a toolchain today,
install 0.1.4.

Each section says which half it is: in main today or planned.

Three things are coming in 0.1.4.5.

1. LomentGC — the four-tier reclamation ladder

In main today.

Reclamation in Loment is not one algorithm over one heap. Every alloc site is assigned, at
compile time, to one rung of a ladder, and how much of this program's memory the collector is
responsible for is a number carried in the artifact:

Rung	What it does
L0	static promotion — a provably non-escaping allocation never reaches the heap at all
L1	last-use — the allocator front is returned right after the final use
L2	block epochs — a loop body that allocates and drops returns its whole region at once
L3	mark-sweep with precise roots, triggered by bytes allocated

The ladder is implemented twice — the reference compiler (tools/lomentc.py) and the
self-hosted one (loment/selfhost/) — and the two must agree byte for byte. The three tiers
choose gc_manual / choose gc_auto / choose gc_auto_alpha select how far down the ladder a
unit is allowed to go. Potato v10 carries gc_ladder = {l0, l1, l2, l3, total_sites},
and two independent validators check the arithmetic (l0 + l1 + l2 + l3 == total_sites)
without reading a single line of source.

Still being built. The adaptive collector for gc_auto_alpha is in review
(#200); today the L3 residual of that tier is
not collected. The GC v2 design (gc_strict, reclamation-by-recomputation, Potato v11) is a
design document, not an implementation — none of its criteria have been run yet.

The design record is docs/210; the ledger of what is claimed
and what is still open is docs/202.

2. Networking, on both targets

In main today.

The same .lomt source can open a socket on Linux and on Windows, from the same output
bytes. On ELF the calls are the Linux syscalls directly; on PE the runtime dispatches 21
numbers through ws2_32. syscall7 fills all six argument registers, so address-carrying
UDP — sendto / recvfrom, where the sixth argument is the socklen_t — is expressible in
the language. tools/loment_pe_test.py walks the whole surface by having a program connect to
itself: socket / setsockopt / bind / listen / getsockname / connect / accept /
read / write / poll / accept4 / IPv6.

Two boundaries, stated plainly, because they are the parts that are not there:

• There is no networking library. std has no net module; you write the syscalls
  yourself. Nothing wraps them yet.
• There is no admission gate. A unit that declares
  excluded "network: 本单元不申请任何 net 能力" (as loment/examples/demo.lomt does) is not
  stopped from calling socket — the capability check compares domain names and never looks
  at behaviour. docs/218 is a research draft arguing the
  project should have no permission list at all rather than a gate; its criteria have not
  been run.

The measurements are in docs/217,
docs/220 and docs/221.

3. lompi 0.2.0 Alpha

Planned.

The package manager moves from 0.1.5 to 0.2.0 Alpha. That announcement lives on the
package manager's own repository, FujoJTOP/lompi.

---

Loment is a systems programming language that compiles to native x86-64 — Linux ELF,
Windows PE, or a freestanding object for bare metal — with no runtime and no libc. The
toolchain is self-hosted at run time: compiling and running needs no Python, no clang and no
WSL. The language surface is frozen (docs/158 says what changing
it costs); the implementation is not, and this announcement is what "not frozen" looks like.

Watch the 0.1.4.5 milestone for the real thing.

Loment 0.1.4

Loment 0.1.4

📢 Notice — Loment 0.1.4 Windows installer

We have identified the following: on some Windows systems, double-clicking loment-0.1.4-windows-x64-setup.exe produces no response whatsoever — no installer window, no error message; the process exits silently with code 0.

The cause has been located. The self-extracting package invokes the installer script by a filename without a path (cmd.exe /c install.cmd), while the script resides in the extraction directory. On systems where the Windows hardening setting NoDefaultCurrentDirectoryInExePath is enabled, cmd no longer searches the current directory and therefore cannot find the script. Note that the same file behaves differently across machines: systems without that setting install normally.

All Windows users are advised to install from the zip archive: unpack loment-0.1.4-windows-x64.zip and run install.cmd in the unpacked directory. Both routes install identical contents.

The fix is complete and will ship with the next release (#114). The published 0.1.4 installer will not be rebuilt — rebuilding would change the bytes published under an existing version number. See #117 for details.

A systems programming language that compiles to native x86-64 — Linux ELF, Windows PE, or a
freestanding object for bare metal — with no runtime and no libc. The toolchain is
self-hosted at run time: compiling and running needs no Python, no clang, no WSL.

Install

Platform	File	How
Linux / WSL	loment-0.1.4-linux-x64.tar.gz	unpack → sh install.sh
Windows	loment-0.1.4-windows-x64.zip	unpack → run install.cmd (or powershell -File install.ps1)
Windows	loment-0.1.4-windows-x64-setup.exe	⚠️ do not use — see the note above
any agent	loment-skill.zip	the language guide on its own, for agents

SHA256SUMS covers the three archives and the skill zip; the installers check it first. Both
install routes put down the same thing: the bootstrap artifacts, the launcher, and the seed.
The Windows installer is unsigned, so SmartScreen will warn once.

Built from main at 0826ac5 (2026-09-23) — share/loment/version inside the package
says so, and that is what the tag v0.1.4 points at.

Verified before publishing: SHA256SUMS checks out for all four files; the Windows zip
installs and the installed toolchain compiles and runs a program natively on Windows
(no clang, no WSL, no Python); the Linux tarball installs in a POSIX shell and its toolchain
does the same in WSL.

What is in it

• The language: Rust-flavoured surface syntax, capability domains
  (capability / guard / excluded / revocable), a frozen surface for this line
  (docs/158).
• Six more surface syntaxes on top of the base one — C, C++, Java, C#, Go, Python: the
  same program, written in any of them.
• A toolchain written in Loment: loment / loment-cli / lompi, plus driver, lsp,
  fmt, doc, lomelf and the native ELF/PE backends. loment run builds a PE program on
  Windows and runs it natively, no clang in the path.
• A standard library in the package: std (127 modules) + host (7), 137 files.
• Potato formal objects (the cross-line contract) exported by the compiler.
• A generated manual, a
  language guide,
  an editor extension, and
  examples.

What is not in it (read this before relying on it)

0.1.4 is a real release, and it is not a claim that everything on the roadmap closed.
The audited checklist is
docs/202;
this is where it stands:

• Not fully self-hosted yet. The toolchain runs without Python, but the repo still carries
  non-Loment development-time code — the Python criteria are being ported to Loment one at
  a time (docs/189).
  Two classes are deliberately exempt (vendored cross-line counterparts; hand-written
  verification shells that wait on a deliverable), and editors/ stays JS/TS because VS Code
  extensions can only be JS/TS (docs/202 §2.3).
• A hosted layer is not there yet. A choose no_std project that pulls in a hosted library
  is not rejected today — that check is the next piece of work (docs/202 §2.4).
• GC is one-tier. free is accepted but is a placeholder (the bump heap does not reclaim);
  choose gc_auto / gc_manual are not in the language yet (docs/175 §3.4).
• The gate is "no new reds", not "all green". The committed baseline still has reds; four of
  them need a private sibling repository a public runner cannot read, so "everything green"
  is not literally attainable today (CONTRIBUTING.md).
• Self-consistency is not correctness. A large part of the evidence is "the reference
  implementation and the self-hosted one agree byte for byte" — two implementations by the same
  author agreeing does not prove the semantics are right. That ceiling is stated in
  docs/203 §7.3,
  which is also where the independent review of the audit package lives (24 claims: 22 accepted,
  1 rejected, 1 unverifiable on the reviewer's machine).
• Known open items are listed honestly, not hidden: see
  docs/158 §4 (12 of
  them, including two that are "consistently wrong on both sides" and therefore invisible to a
  byte-comparison).

Pointers

• What 0.1.4 means and where it is going: docs/175
• The audited release checklist, item by item: docs/202
• Independent review of the audit package: docs/203
• Freeze surface and its cost: docs/158
• Contributing, including how to read a red gate: CONTRIBUTING.md

Loment 0.1.4 Pre

A pre-release of main at 0.1.4 — now installable. Tagged so that "the repo has
versions" is visible; 0.1.4 final is not finished yet (see What it is not below).

Install

Platform	File	How
Linux / WSL	loment-0.1.4-linux-x64.tar.gz	unpack → sh install.sh
Windows	loment-0.1.4-windows-x64.zip	unpack → powershell -File install.ps1
Windows	loment-0.1.4-windows-x64-setup.exe	double-click (self-extracting)
any agent	loment-skill.zip	the language guide on its own, for agents

SHA256SUMS covers the three archives and the skill zip; the install scripts check it first.
Both install routes put down the same thing: the bootstrap artifacts, the launcher, and the
seed — the package contains no Python. To build from a checkout instead, see
QUICKSTART.md.

The Windows installer is unsigned, so SmartScreen will warn once.

Which commit these are built from: main at 557fd26 (2026-09-22) — that is the commit
the archives were built from, and share/loment/version inside them says so. The tag
v0.1.4-pre itself points at an earlier commit, so GitHub's auto-generated Source code
archives follow the tag and are the earlier tree — if you want the source that matches these
binaries, check out 557fd26.

Verified after upload: SHA256SUMS checks out for all four files; the Windows zip
installs (install.ps1 -Prefix … -NoPath -NoFileType -NoSkill) and the installed toolchain
compiles and runs a program natively on Windows (no clang, no WSL, no Python); the Linux
tarball installs in a POSIX shell and its toolchain does the same in WSL.

What is here

• A systems programming language that compiles to native x86-64 — Linux ELF, Windows PE,
  or a freestanding object for bare metal — with no runtime and no libc.
• A toolchain written in Loment: compiling and running needs no Python (the bootstrap
  starts from a genesis ELF committed to the repo).
• Six more surface syntaxes on top of the base one: C, C++, Java, C#, Go, Python —
  the same program, written in any of them.
• Potato formal objects (the cross-line contract) exported by the compiler, plus a
  capability domain model (capability / guard / excluded / revocable).
• The static gate runs on GitHub Actions for every pull request and push to main
  (ci.py --static-only). It is a real gate: a measured baseline of reds is committed, and
  a pull request fails if it introduces a new one.
• A generated manual,
  a language guide,
  an editor extension,
  and examples.

What it is not

• Not 0.1.4 final. The language surface is frozen for this line
  (docs/158),
  but the tree is still moving every day.
• Not fully self-hosted yet. The toolchain runs without Python, but the repo still
  carries non-Loment development-time code (the criteria are being ported to Loment —
  docs/189).
• Not all checks are green. The gate's baseline still contains reds — four of them need
  a private sibling repository (FujoJTOP/LinuxFUAI) that a public runner cannot read.
  "Everything green" is therefore not literally attainable today; the gate's rule is
  "no new reds".
• 0.1.4's own prerequisites are not all closed — the audited checklist is
  docs/202.

Pointers

• Version source of truth: tools/loment_release.py (RELEASE)
• Direction / what 0.1.4 means: docs/175
• Release prerequisites, item by item: docs/202
• Freeze surface: docs/158
• Contributing (including how to read a red gate): CONTRIBUTING.md