Every link on this page is pinned to the release shown below. The install scripts find the current release and compare the downloaded binary with the SHA-256 checksum file published beside it.
Release v1.20.0
All platforms
| Platform | Binary | Checksum |
|---|---|---|
| Linux · x86_64 | lispex-linux-x86_64 | .sha256 |
| Linux · aarch64 | lispex-linux-aarch64 | .sha256 |
| macOS · Apple silicon | lispex-macos-aarch64 | .sha256 |
| macOS · Intel | lispex-macos-x86_64 | .sha256 |
| Windows · x86_64 | lispex-windows-x86_64.exe | .sha256 |
| Release manifest | manifest.json | file names, sizes, addresses, and SHA-256 checksums |
The ready-made refund example
Carry one refund decision to an application boundary
The v1.17.0 example gathers the reviewed rule, its exact Lispex Image, signed Vouch evidence, the recipient policy, one current request, negative policy cases, and a final would_act record. Follow the complete local workflow, then connect that record to the application action you own.
| Release | Example archive | Checksum |
|---|---|---|
v1.17.0 | lispex-v1.17.0-practical-decision-workspace.zip | .sha256 |
Optional extra engines for macOS ARM64
The Native routes fetch command installs these products. You explicitly select each additional Lispex engine. The fixed links expose the two companion archives and the catalog embedded in Native for audit and documented offline installation.
| Item | Archive | Checksum |
|---|---|---|
| Topaz virtual machine companion | lispex-topaz-vm-aarch64-apple-darwin.zip | .sha256 |
| Topaz companion that compiles ahead of time | lispex-topaz-aot-compiler-aarch64-apple-darwin.zip | .sha256 |
| Built-in catalog of extra engines | route-catalog.json | .sha256 |
The resource-controlled rule engine, exact bytes
Applications can pin the exact bytes of the engine embedded in Native. It runs one rule under the declared resource profile. Its manifest fixes capabilities, metering, value exchange, receipt fields, memory limits, and checksum. Recorded request and result bytes let every consumer compare the exact observation.
| Item | File | Checksum |
|---|---|---|
| Resource-controlled rule engine Wasm | lispex-embed-evaluator.wasm | .sha256 |
| Rule engine manifest | lispex-embed-evaluator-manifest.json | .sha256 |
| Recorded request and result bytes | lispex-embed-evaluator-golden-vectors.json | .sha256 |
| Rule engine redistribution package | lispex-embed-evaluator-redistribution.zip | .sha256 |
The whole-language rule engine, exact bytes
A separate component covers the complete lispex-profile-1.5 and carries its own capability, metering, component, and artifact identities. It reuses the established value exchange, run transcript, and portable record format. Native selects it through explicit embed full commands and creates a fresh instance for every operation.
| Item | File | Checksum |
|---|---|---|
| Whole-language rule engine Wasm | lispex-full-embed-evaluator.wasm | .sha256 |
| Whole-language rule engine manifest | lispex-full-embed-evaluator-manifest.json | .sha256 |
| Recorded vectors for the whole-language engine | lispex-full-embed-evaluator-provider-vectors.json | .sha256 |
| Redistribution package for the whole-language engine | lispex-full-embed-evaluator-redistribution.zip | .sha256 |
One-line install
# macOS / Linux
curl -fsSL https://www.lispex.com/install.sh | sh
# Windows (PowerShell)
irm https://www.lispex.com/install.ps1 | iex
# npm (Node 18+)
npm install -g lispexCheck the installed command
A successful install prints the exact product version. You can repeat the check at any time.
lispex --version
# Expected: lispex v1.20.0If the command is not found
- macOS and Linux install to ~/.lispex/bin by default. Add that directory to PATH, then restart the shell.
- Windows installs to %LOCALAPPDATA%\Lispex\bin by default. Add that directory to the user PATH, then open a new PowerShell window.
- If you chose npm, confirm that Node 18 or newer is active and that the global npm binary directory is on PATH.
Which one should I use?
- Choose the native binary for the widest set of tools. It includes the source interpreter, a resource-controlled rule engine, the Rust virtual machine for verified bytecode, intermediate-form commands, exact Lispex Images, and the complete Lispex Vouch workflow. Native owns evidence issuance, current re-execution of the pinned request, and the local gate. It can also derive a compiled artifact from the same exact source and record Rust VM agreement.
- Choose npm when Node is already available. It runs source, provides the same exact Lispex Image commands through Rust compiled to WebAssembly, authenticates Vouch evidence with the same checker as Native, and replays decision corpora offline. Native owns intermediate forms, verified bytecode and virtual machines, evidence issuance, current re-execution, and the local gate.
- Use the Playground to run source and to create, open, page through, recover, download, and explicitly run exact images directly in your browser. Native provides intermediate forms, bytecode and virtual machines, while Native and npm provide the Vouch artifact and policy tools.
Optional Topaz engines
Compare verified bytecode or build a product with no source inside
On macOS ARM64, Native can fetch the exact Topaz 5.11 virtual machine and ahead-of-time compiler. The VM compares verified bytecode with Rust, and the compiler builds a source-free product with the Rust tools you provide. Rust remains the default until you select an installed route. Vouch uses its source-bound compiled artifact and Rust VM agreement.
Lispex Images
Carry exact source as an image that always comes back the same
Native and npm share the same image commands, and public WebAssembly and the Playground run the same Rust codec locally. Each restores source byte for byte after the format, integrity, parity, and regeneration checks. Native connects the recovered source to the full Vouch workflow, and npm connects it to identity, policy, and authenticated verification.
Lispex Vouch
Use Native when a decision must reach a local gate
Native binds authenticated evidence to the exact source and input supplied outside the bundle, runs the rule again on your machine, and records the matching local decision. On request it also derives a compiled artifact from that source and records verified Rust VM agreement. The local gate consumes current request-bound evidence, and the host application consumes the gate result.