Skip to content

Releases

Release v0.3.0

Choose a tag to compare

@homer6 homer6 released this 16 Nov 06:42
66b5bb9

Released: 2026-11-15 · Branch: dev, promoted to main · Previous: v0.2.0 (2026-10-17) · Tracking: #543

liquid is a version control system, build system, package manager, artifact service and runtime in one program: a C++26 library, libliquid, and a liquid command-line binary that is a thin client of it.

This is the first release published as open source. liquid is now under the MIT licence, and contributions come in under the Contributor License Agreement. The release also brings a month of security fixes from the pre-launch security review and the hardening and fuzzing work. Several of those fixes change behaviour; they are listed under Breaking changes and must be read before upgrading. Everything liquid implements, by area, is on the v0.1.0 page, and the implementation status is current.

Measured Value
Merged pull requests since v0.2.0 58 (below), plus this release's
Files changed under src/ and include/ 509 (15,100 lines added, 2,415 removed)
Commands in the generated CLI reference 80
Tests, macOS arm64 (Release), dev at 2eb76f34 994 run, 984 passed, 10 failed; every failure is filed
Tests, Linux amd64 (Release, cluster BuildKit), dev at 2eb76f34 1,069 run, 1,058 passed, 11 failed, 68 skipped; every failure is filed

Contents

Open source

  • MIT licence (LICENSE, COPYRIGHT: OramaSearch, Inc.), an SPDX-License-Identifier line in every source file (tools/spdx-headers.py), THIRD_PARTY_LICENSES and NOTICE for every component, and a reproducible SBOM in SPDX 2.3 and CycloneDX (tools/sbom.py) (#524).
  • CONTRIBUTING.md, the CLA, CODE_OF_CONDUCT.md (#524) and SECURITY.md: private reports to security@orama.com (#506).
  • The tree is public material only: quoted decisions, private links, local paths and the build host audit are rewritten, and the Metis page is removed (#523). Submodules are fetched over HTTPS from public repositories (#539).

Security fixes

From the pre-launch security review, each with tests:

  • Untrusted input is bounded. Format parsers charge one budget per unpack:
    • Parquet and PDF allocations (#469, #472);
    • RPM strings and cpio alignment (#478, #487);
    • Mach-O, PE and ELF names (#481, #482, #484);
    • safetensors (#483);
    • HDF5 link names and filter pipelines (#485, #488);
    • nested deb, apk and document members share the outermost budget (#480);
    • JWT scanning runs in linear time (#489);
    • Git object inflation and delta reconstruction (#493);
    • CBOR, config, git and HTTP/1 parsing (#499), with libFuzzer harnesses for every parser of untrusted bytes (#499, #519).
  • Writes stay where they belong:
    • install staging and tree materialisation stay inside their roots (#450);
    • action outputs never follow links (#470);
    • Drive never uploads symlink targets (#455) and refuses xattr writes on protected mounts (#495);
    • the REAPI ActionCache validates digests and never follows links (#467).
  • Servers and peers authenticate:
    • the scheduler and workers authenticate each other (#466);
    • serve reapi and serve sync require TLS plus a token or mTLS off loopback (#518);
    • the scheduler listener is authenticated and delegated sessions are verified (#521);
    • sync sends only offered objects (#496);
    • every identity decision requires a verified chain (#507); unverified authors are shown as such (#511, #513);
    • local trust anchors, sealed identity keys, refusal of compromised keys, hot-update signers and release-policy trust (#518), and a checked passphrase file for headless Linux (#522).
  • Resource limits:
    • HTTP/2 advertised limits and flood closing, including rapid reset (#454);
    • chunk uploads charged to a 64 MiB decoded budget (#471);
    • bounded and expiring REAPI uploads (#494);
    • bounded REAPI request reads (#509).
  • Smaller fixes:
    • a private per-user daemon socket directory (#453);
    • BLAKE3 for wrap conditions, plans and process keys (#456, #509);
    • sandbox profile quoting, the owner-only LIQUID_TOKEN_FILE and the daemon environment scrub, and an attestation clock floor (#502);
    • pinned dependencies, a daemon request timeout, and ref and tree name checks (#503);
    • honest guarantees in the docs and a masked boot id (#504);
    • archive-timestamp renewal only while its predecessor is trusted (#505);
    • pinned Dockerfile bases and installers (#510);
    • hardened compile flags by default, LIQUID_HARDEN (#499).

Other fixes

  • Crash durability: a barrier after the last state removal, and the backend ordering contract (#373, #378).
  • The local identity is created atomically under a lock (#379), and FIDO2 assertions are verified over the bytes CTAP2 signs (#370).
  • https from a Mac uses the system trust store (#382, corosio 8783392).
  • Sync retries 503 and 429 with Retry-After (#372).
  • The Linux container suite skips with a reason where FUSE or namespaces are missing, and /usr//bin/tool is no longer a canonical install path (#377).
  • Writers of one store are serialized across processes (#532), and a handle releases its leases (#533).
  • cut -m is accepted, a message starting with - is refused, and daemon stop is added (#529).
  • Builds again after two merges met (#541).

Breaking changes

  • Servers:
    • non-loopback serve reapi, serve sync and scheduler refuse to start without TLS plus a token or mTLS (#518, #521);
    • the scheduler and workers need --trust-worker and --trust-scheduler, and the worker wire protocol changed (#466).
  • Trust:
    • log verify, log consistency, log scan, verify --log, release verify and hot-update fail closed without $LIQUID_HOME/trust/* (#518);
    • every signature by a compromised key is refused;
    • history with no verified chain prints "signed by an unverified key" (#507);
    • delegation/1 requires not_after and repository, LIQUID_SESSION v1 is refused, and liquid session start requires --as (#521).
  • Identities: a new Linux identity needs a passphrase. Headless hosts use the passphrase file (#518, #522).
  • Inputs now refused:
    • a declared output that is a symlink, FIFO, socket, device or dangling link fails its action (#470);
    • trees with .git spellings, \ or NUL in names decode as corrupt, and case-colliding names fail to materialise on APFS (#450);
    • Drive skips every symlink (#455);
    • REAPI unary requests over 5 MiB are refused (#509);
    • REAPI uploads have default limits of 1 GiB each, 2 GiB in flight and 128 uploads (#494);
    • old FNV wrap cache rows become misses, and LIQUID_WRAP_HOOK and LIQUID_READ_GUARD must be owner-only files (#456).
  • API:
    • log_client needs log_trust, and verify_release, verify_patch, apply and status changed signatures (#518);
    • the ABI inspection struct gains truncated (#481).
  • Behaviour: pushes without a pusher share one unauthenticated flow bucket (#511, #518).

What it does not include

Deferred PRs, not in this release:

  • the structural parser budget (#491) and the source traversal limit (#490), which refused legitimate large inputs;
  • non-root service images (#492);
  • PID-namespace isolation for wrapped processes (#497);
  • the loopback-and-argv batch (#500) and credentials over plain http (#501), being reworked;
  • named lakes (#531);
  • delegated structural edits (#542).

Not shipped from this repository: images. The deploy images still sit on Ubuntu (#537).

Known issues

Security and licensing first:

  1. The vendored AppImage runtime statically links libfuse (LGPL-2.1), and the VFS links the system libfuse3. Both are to be replaced by our own FUSE library (#536); until then the runtime ships with its source offer in THIRD_PARTY_LICENSES.
  2. The deploy images bundle GPL userland (Ubuntu base) and are not published (#537).
  3. Release-suite failures, each filed and not fixed in this release:
    • the FIDO2 vector tests fail with "unknown signer" (#544);
    • cli-public-includes and cli-offline: a CLI file includes a private header (#545);
    • cmake-script-policies (#546);
    • RepositoryLeases.AThousandOpensLeaveNoMoreLeasesThanLiveHolders times out (#547);
    • three ReapiRequestLimits tests on Linux (#548);
    • Build.output_symlink_fails_before_its_host_target_is_read_or_rewritten on Linux (#549);
    • cli-cut-daemon and a daemon watermark test on Linux (#550);
    • four macOS-only failures: RepositoryFlow, RuntimeSockets, BuildSbom and a DMG projection test (#551).
  4. Windows code is not built or run in this release's proof, including the owner-only DACL and the token file guards (#502, #518).

Verification

  • Full suite at dev 2eb76f34 (every PR except #518, #521 and #522):
    • macOS arm64, Release, Homebrew LLVM: 994 tests, 984 passed, 10 failed;
    • Linux amd64, Release, clang-19 on the cluster BuildKit: 1,069 tests, 1,058 passed, 11 failed, 68 skipped. The liquid-tests gtest run hit its 1,500 s cap.
    • Every failure is filed: #544 to #551 above.
  • #518, #521 and #522 at the top of their stack: a full build, and 365 targeted tests (identity, sync, REAPI, session, delegation, scheduler, worker, hot-update, release, log, custody, trust, daemon): 360 passed, 2 skipped, and 3 failed, all of them also failing on dev alone (#544, #545).
  • **...
Read more

Release v0.2.0

Choose a tag to compare

@homer6 homer6 released this 17 Oct 23:59
1bf3d41

Released: 2026-10-17 · Branch: dev, promoted to main · Previous:
v0.1.0 (2026-10-12).

liquid is a version control system, build system, package manager, artifact service and
runtime in one program: a C++26 library, libliquid, and a liquid command-line binary that
is a thin client of it.

The library and the binary are the v0.1.0 source. Between v0.1.0 and this release, one
pull request merged, and it changed only CLAUDE.md. This release adds a test that holds the
version in its three places, moves the release procedure to dev → main, and records where
liquid runs and what is known to be broken as of 2026-10-17. Lake v0.2.0 shipped the same day
on liquid v0.1.0.

Five days after v0.1.0, this is not a release after a long gap, so the page lists what changed
and does not repeat the inventory. Everything liquid implements, by area, and all 80 commands
are on the v0.1.0 page
, and they are unchanged: the CLI reference generated from
the v0.2.0 binary is identical to docs/reference/cli/ (80 commands).

Measured Value
Merged pull requests since v0.1.0 1 (#359, CLAUDE.md only) plus this release's
Files changed under src/ and include/ 2: the version in src/version.cpp and include/liquid/version.hpp
Commands in the generated CLI reference 80, unchanged
Tests, macOS 747 run, 735 passed, 0 failed, 12 skipped
Tests, Linux 801 run, 730 passed, 41 failed, 30 skipped; every failure is filed (see Verification)

Contents

What changed since v0.1.0

  • The version is 0.2.0, in all three places it lives: current_version() in
    include/liquid/version.hpp, version_string() in src/version.cpp, and
    project(liquid VERSION ...) in CMakeLists.txt. liquid --version and liquid version print
    liquid 0.2.0. The library's VERSION/SOVERSION (the ABI version) do not move: there is no
    ABI change.
  • A test holds each place. Version.StringMatchesStruct already compared the string with the
    struct. The new Version.MatchesProjectVersion compares the code with project(VERSION), which
    the build passes in as LIQUID_PROJECT_VERSION, and the new ctest release-notes-page fails
    when docs/releases/v<project version>.md is missing.
  • Releases are cut from dev and promoted to main
    (#359, and this release's changes to
    CLAUDE.md Cutting a release and docs/releases/README.md). Feature branches
    and pull requests target dev; the release pull request (dev into main) is the only one that
    targets main, and its merge commit carries the tag.
  • Status lines in README.md, CLAUDE.md and docs/README.md name v0.2.0.

Where it has run

  • Lake v0.2.0 (release,
    2026-10-17) is built against liquid v0.1.0, commit f669726, which is liquid-bridge's pin of
    modules/liquid and the source every Lake image on the development clusters is compiled
    from. Its library source is identical to this release; only the version string differs. Lake's
    end-to-end suite on lake-testing drives the liquid binary (init, cut, push).
  • Lake v0.1.0 was built against liquid 88c5ef4, as the v0.1.0 page records.
  • liquify links libliquid from its own pin of liquid; this release does not move it.

What v0.2.0 does not include

Everything v0.1.0 does not include is still not
included. In short:

  • FUSE-backed commands: lazy mounts, wrap, verify and replay need libfuse3 on Linux and
    macFUSE on macOS, and liquid's own filesystem projection without FUSE is not written yet
    (#302,
    #303,
    #304).
  • Windows returns a documented unsupported result for the daemon, wrap, verify and
    replay.
  • The Phase 2 and Phase 4 exits are not demonstrated
    (#299,
    #300).
  • Long-lived hardware-backed keys (PIV, FIDO2, TPM sealing, threshold signing)
    (#81).
  • A memory-resident search index for liquid search: each query opens the on-disk index
    (#360).
  • The hosted service and the IDE are their own projects (Lake and liquify).
  • A licence. None has been chosen
    (liquid-bridge#2); the repository is
    private.

Known issues

Security-relevant first.

  • liquid-bridge#11 — no security
    review and no vulnerability disclosure policy yet. Both are required before liquid goes public.
  • liquid-bridge#1 — TAAP/1 subjects
    are key-derived, so nothing can be attested about a content-addressed object (a document, drip,
    change or artifact) until the object-subject form is specified.
  • #349 — creating the local identity
    races: concurrent first uses can leave it unreadable (cannot unwrap local identity).
  • #310 — the public constructors of
    forge_client and sync_endpoint throw across the library boundary.

Behaviour.

  • #361 — liquid deploy names the
    repository only by its liquid id. A Lake repository pushed from a clone of another shares that
    id, so Lake cannot tell which repository a deployment belongs to and does not show it
    (lake#805). Deployments of repositories with an
    unshared id are shown.
  • lake#776 — Lake's import_repository
    refuses an archive its export_repository just made (invalid sync item reference); the sync
    item format is liquid's.
  • #346 — SIGBUS inside liquid's runtime
    under heavy parallel test load.
  • #325 — block_on's runner threads use
    the platform default stack, which is 512 KiB on macOS.
  • #319 — the shared-library build fails
    to link the CLI on macOS, with undefined Boost symbols.
  • #341 — a one-file commit issues 57
    store barriers, which bounds a remote store by round trips.
  • #340 — the sync client does not retry
    a 503 that carries Retry-After.
  • Store ordering: #342 (no permanent root
    for objects no repository references), #343
    (a missing barrier after the last state removal of a repository operation) and
    #344 (the store_backend ordering contract
    between barriers is not stated).
  • #291 — the wrap, cache and provenance
    promises cannot be proven on the development Mac, because macFUSE is absent.
  • #281 — the real-world import gate is
    stale: main takes 1,773 s against a 900 s ceiling.

The suite.

  • Linux: 41 of 801 tests fail on the cluster BuildKit lane; counts and causes are under
    Verification.
    • #362 — tests that need a FUSE mount fail
      instead of skipping when /dev/fuse is absent (34), and
      BuildPlan.daemon_preserves_the_repository_plan_and_event_sequence crashes on the mount
      failure.
    • #363 — cli-offline and cli-log-url fail
      under the offline runner in a container.
    • #364 — cli-help-docs fails on CMake 3.x.
    • #365 — two HotUpdateDemo tests fail on
      Linux.
    • #356 —
      Projection.generated_values_cannot_change_shell_structure fails on Linux.
    • #348 — classifying the Linux failures and
      making the suite runnable in a container.
  • Intermittent tests: #354 and
    #336 (admission server),
    #353 (daemon under load),
    #264 (node store) and
    #225 (drip overflow on Linux).

Verification

macOS: full suite, run serially (ctest --test-dir build --output-on-failure, no -j) on the
release branch. macOS arm64, Homebrew Clang 22.1.8, Release, without macFUSE, 477 seconds:

747 tests ·...
Read more

Release v0.1.0

Choose a tag to compare

@homer6 homer6 released this 12 Oct 22:32
f669726

Released: 2026-10-12 · Branch: main · Previous: none. This is the first tagged release.

liquid is a version control system, build system, package manager, artifact service and
runtime in one program. It is a C++26 library, libliquid, and a liquid command-line
binary that is a thin client of it. You import a folder, every write is captured as a signed
drip, and a group of drips gets a reviewable name as a change. The same tool caches
build results, explains cache misses, signs provenance, and packages the outputs.

Because this is the first release, this page lists everything in it: every implemented
feature by area, and every one of the 80 commands. The feature list follows
docs/library/status.md, the authoritative implementation record, and
each paragraph names the page that holds the design and verification detail. The command list
was checked against the generated CLI reference, so none is missing.

This tag is the source that Lake v0.1.0 is built from: the development deployment's image
was compiled against liquid 88c5ef4, the commit this release is cut from apart from the
version string and the release documents.

Measured Value
Commits, pull requests 248 commits across 167 pull requests, from 2026-09-01
Commands in the generated CLI reference 80
Tree-sitter grammars bundled 49
Feature specifications, research topics 25 and 27
Tests 745 run, 733 passed, 12 skipped (see Verification)

Implemented is not the same as specified. docs/features/ holds 25
specifications of what liquid is meant to do, including the hosted service and the IDE. This
page lists only what the library and binary implement today. What is still owed is under
What v0.1.0 does not include.

Contents

  1. Library and binary
  2. The store
  3. Repositories: drips, changes and history
  4. Identity, signing and encryption
  5. Capture, secret scanning and attestations
  6. Sync, review, drive and Git
  7. Working trees: mounts and materialisation
  8. Transparency, TUF and admission
  9. Search
  10. The build engine
  11. Remote execution and distribution
  12. The incremental engine
  13. Formats, projection, resolution and configuration
  14. Deployment
  15. Every command
  16. Guides and documentation

1. Library and binary

  • libliquid (liquid::liquid): static by default, shared with BUILD_SHARED_LIBS. Other
    programs consume it through its exported CMake target; find_package(liquid CONFIG REQUIRED)
    works from an installed and relocated prefix, with the complete static dependency closure
    (libliquid.md).
  • The liquid binary: a thin client of the library. It validates every option from one
    typed command table, and the Markdown, JSON and man-page reference are generated from that
    table.
  • Git's command names: init, clone, status, log, diff, blame, mv, rm,
    push, pull, gc and repack mean what they mean in Git. The path-move command was
    move before this release; move is still accepted.
  • Coroutine API: the public waiting operations are lazy Boost.Capy tasks backed by a private
    Corosio runtime (runtime.md).
  • Public API: errors, digests (BLAKE3, SHA-256 and keyed BLAKE3 identifiers), the identity
    document codec, the signature decoder and release approval
    (api-map.md, hash-agility.md).
  • Platforms: macOS and Linux. Windows builds, and returns a documented unsupported result
    for the daemon and for wrap, verify and replay.

2. The store

One content-addressed chunk store holds source, binaries, packages, images, search indexes and
encrypted data (store.md, gc.md,
simulation.md).

  • Persistence backends: an injected, coroutine-native backend interface with disk and
    in-memory implementations. Disk is the default.
  • Reads and writes: open, put, get, range read, contains, and bounded-memory put_file and
    get_to_file for files of any size.
  • Garbage collection: leased roots, epoch collection and pack compaction. A collection
    publishes its object map before it commits tombstones, so a crash between them never leaves an
    object naming a tombstoned chunk. liquid gc --explain says why a chunk is live.
  • Near-duplicate compression: digest-addressed chunk deltas with resemblance-selected bases;
    repacking rebases delta chains and collection keeps their transitive bases.
  • Crash simulator: a deterministic, seeded simulator that runs the same invariants against
    the disk and memory backends.
  • Shared stores: several repositories in one caller-owned store, with repository-scoped
    checkpoints, journals and retention leases. A shared-store repository's own state is backend
    keys, so a backend with no local root holds the whole repository.
  • Write-through and eviction: a store owner can await a whole-content write-through callback
    before the first local pack write, and evict local copies that are registered remotely.
  • Process ownership and hand-off: one handle owns a disk root across processes, and a
    successor waits for a draining or killed predecessor to release it.
  • Injected owners and fencing: on a backend without a local root, ownership comes from an
    injected owner whose grant carries a fence sent with every mutation, so the remote refuses a
    stale holder.
  • Whole-repository transfer: repository::transfer copies one repository between two open
    shared stores, resumably, with a verify mode that reports every difference.
  • Append-only writes: no store write rewrites bytes already written, which object storage
    that only appends or replaces whole objects requires.

3. Repositories: drips, changes and history

(object-model.md, multiplayer.md)

  • Create a repository from a folder, and read and write its working tree.
  • Drips and changes: every captured write is a signed drip; cut names the working change.
  • History: references, snapshots, the state of a document at any point, the change log, path
    history and restore, and per-line attribution to the session and change that last wrote it.
  • Diff: between trees and changes, with text anchors that survive edits.
  • Moves and removals recorded as such.
  • Composition: nest another repository, split a subtree into a standalone repository that
    owns its chunks and keeps its original signed history, and combine two repositories
    (split.md).
  • Conflicts as values: a conflict is a recorded value that can be listed, inspected and
    resolved, not a broken working tree (conflicts.md).
  • Undo: of the newest operation, a named one, or a whole session's.
  • Exclusive checkout locks: configured path patterns need a lock to write. A lock record
    carries holder, time and reason, and offline reconciliation produces conflict values
    (locks.md).
  • Agent sessions: private speculative replicas; semantic leases on a file, symbol or range;
    transient presence; delegation attribution.
  • Writes from a stated base: a write names what it was based on, and a stale base is
    refused, re-validated when the edits are disjoint, or recorded as a forced re-plan.
  • Compaction epochs that checkpoint a repository.
  • Streaming: one-drip streaming file writes and tree imports, in bounded memory.
  • Paged enumeration of results, attestations, traces and SBOMs.

4. Identity, signing and encryption

(identity.md, encryption.md,
release-approval.md)

  • TAAP/1 identities for people, devices and agents, with signed drips and changes.
  • Identity backends: software keys, FIDO2 and PIV hardware tokens, with rotation across
    backends and chain verification.
  • Public identity export: liquid identity show --document prints only the signed public
    document; private keys stay local.
  • Encrypted objects by trust domain, with key custody by passphrase, raw key file,
    age/X25519 recipient, cloud KMS, Lake transit, Shamir shares, or a TPM sealed to PCR values.
  • Data-key rotation and revocation, versioned, with reports of which revisions a repository
    ...
Read more