Repository navigation
Release v0.1.0
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
- Library and binary
- The store
- Repositories: drips, changes and history
- Identity, signing and encryption
- Capture, secret scanning and attestations
- Sync, review, drive and Git
- Working trees: mounts and materialisation
- Transparency, TUF and admission
- Search
- The build engine
- Remote execution and distribution
- The incremental engine
- Formats, projection, resolution and configuration
- Deployment
- Every command
- Guides and documentation
1. Library and binary
- libliquid (
liquid::liquid): static by default, shared withBUILD_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
liquidbinary: 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,gcandrepackmean what they mean in Git. The path-move command was
movebefore this release;moveis 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 forwrap,verifyandreplay.
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_fileand
get_to_filefor 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 --explainsays 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::transfercopies 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;
cutnames 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 --documentprints 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
can still read. - Encryption of structured values: path rules encrypt selected JSON and
.envleaf values
and leave the structure visible, with explicit plaintext reads and a key-only historical diff
(leaf-encryption.md). - Lake sealed secrets: the sealed-secret envelope and its commands
(sealed-secrets.md). - Threshold release approval: signed release policies evaluated against a threshold of
approvers.
5. Capture, secret scanning and attestations
(capture.md, secret-scanning.md,
attestations.md)
- Change capture from the file system, with subscriptions, pause and resume.
- Flow control: persisted write budgets per actor, directory document and repository. An
over-budget write is rejected before a transaction opens, and the same limits apply to pushes. - Secret scanning, blocking by default, with repository exceptions and signed scan
attestations. - Verified redaction of a secret from repository history.
- An attestation registry of 17 profiles:
org_membership/1,delegation/1,
authorship/1,review_approval/1,slsa_provenance/1,sbom/1,delta/1,
hot_update/1,model_provenance/1,abi_compatibility/1,scan_result/1,
reproducibility/1,image_provenance/1,projection/1,platform_signature/1,
release_policy/1andrelease_approval/1, with profile-keyed verification, freshness
and selective disclosure.
6. Sync, review, drive and Git
- Push and pull with signed metadata exchange and missing-object negotiation
(sync.md). - A sync server (
liquid serve sync) with per-reference authorization, and mixed or atomic
push outcomes. - Review: a client for Lake's change review, with a polling event stream and an installable
test double (forge-client.md). - Drive: a folder kept in sync, with named conflict values, resume of an interrupted
transfer, path history and restore; per-path online-only, available-offline and excluded
state; pin and unpin; hydration policy; and file-manager badges for GNOME Files and Dolphin
(drive.md). - Clone, including adoption of the identity on first pull.
- Git import and export:
liquid import gitpreserves reachable local Git history and maps
identities;liquid export gitwrites a standalone Git repository and reports what could not
be carried over (git-interop.md).
7. Working trees: mounts and materialisation
- Full materialisation writes a plain directory.
- Lazy mounts hydrate a file's chunks when it is read, through libfuse3 on Linux and
optional macFUSE on macOS (vfs.md). - Conformance: nine common cases pass against liquid's own core backend. The libfuse
baseline on Linux is still owed
(#299).
8. Transparency, TUF and admission
- Transparency-log client: verifies signed checkpoints with a witness quorum, every entry
and parent hash tile, exact inclusion, consistency, and scans by identity, before a caller
trusts a log response (transparency.md). - Trusted timestamps: RFC 3161 checkpoint timestamps and RFC 4998 renewal chains, checked
against explicitly pinned trust anchors at each token's own generation time. - TUF client: verifies root rotation, timestamp, snapshot, targets and the complete target
bytes before a registry or drive client accepts them.liquid registry trustpins or shows
the root (tuf.md). - Kubernetes admission (
liquid serve admission): a fail-closed webhook with named policy
sets that reload atomically, structured decisions, evidence lookup, transparency
verification pinned by policy, and a bound on checkpoint age. Metrics, REST, OpenAPI and MCP
expose the same record (admission.md,
../api/admission.md).
9. Search
Repository-local search over the working tree or a named reference
(search.md).
- Three executors: BM25F ranking, verified positional trigrams for substrings and regular
expressions, and a parallel mapped scan. - Measured cost planning picks one, and
liquid search --explainreports the inputs, the
estimate, the actual cost and the alternatives it rejected. - A content-addressed index published atomically after each drip. Identical blobs are
indexed once. - Inside archives: entries of supported containers are searchable at
!/paths.
10. The build engine
liquid wrapruns an unchanged CMake, Autotools, Make or compilation-database project in
one observed mount and turns each output-producing tool process into a cached action. Inputs
are observed, not declared.- Sandboxed execution in Linux namespaces or a macOS sandbox, with a fixed environment
(../build/sandboxed-executor.md). - A persistent disk cache of signed results, looked up by candidate key and validated
against the current input tree. A miss reports the first differing input. - Verification:
liquid verifyre-executes cached actions in fresh sandboxes, compares the
exit status and every output digest, signs a reproducibility attestation, and permanently
quarantines a result that diverges.wrapsamples one action in twenty by default. - Content-addressed outputs: an upstream tree that is byte-identical after normalisation
stops the downstream cascade. Directory modes,arheaders and Python bytecode are
normalised before storage. - Named inputs:
wrap --input <name>=<result|tree>mounts upstream bytes read-only under
deps/<name>/. - Relocatable installs:
wrap --install-prefixstages an install tree with relative ELF or
Mach-O lookup paths, and publication refuses embedded sandbox or install prefixes
(relocation.md). - Provenance: signed SLSA provenance for every result, and
--dsseprojects it as an
in-toto Statement (provenance.md). - SBOMs: SPDX 2.3 or CycloneDX 1.5 derived from the build graph for every output, with
separately marked inference for foreign binaries (sbom.md). - ABI: stored ABI descriptors and signed compatibility comparisons for every built shared
library (abi.md). - Explanations:
liquid whyexplains a miss by digest, arguments, environment, toolchain,
sandbox, line range and drip.cache statsandwrap --explainreport hit rates and bytes
avoided. - Observability: each result records queued, sandbox, exec, hash and store phases; every
wrap keeps a dependency trace and prints wall time, critical path and achieved parallelism;
liquid build trace --chromeexports it andliquid why-slow <target>names the critical
path. - Build-input policy: rules can require attestations from approved builders for source and
toolchain inputs before anything executes;liquid policy checkevaluates a target without
building (policy.md). - Configure facts: Autotools cache variables and common CMake check results are facts keyed
by compiler, sysroot and target;wrap --targetrefuses to execute an uncached probe for a
foreign target. - Retention: typed rules keep matching references and cost-weighted results; a size cap
evicts the results with the lowest execution cost per byte, andliquid retain explainnames
the rule responsible. - liquid builds liquid: the static library and CLI build under
liquid wraptwice, the
second run with a 100% disk hit rate, and both outputs compare byte for byte with the CMake
bootstrap (self-host.md).
11. Remote execution and distribution
(distribution.md, reapi.md,
workers.md)
- Remote execution: a transport-independent executor that ships source and toolchain trees
from the store and chooses local, remote or racing execution from recorded timing, absent
bytes, queue depth and cache locality. Short actions are batched; a race cancels its loser. - REAPI: a dependency-free protobuf codec for REAPI v2.3, a client for CAS, ByteStream,
ActionCache and Execution, a validated remote cache tier forwrapandbuild --profile,
andliquid serve reapi, which exposes liquid's CAS and ActionCache. Stock Bazel reads and
writes it (reapi-codec.md). - Scheduler and workers: liquid's own scheduler and signed worker fleet, with one bounded
requeue after a worker is lost, placement by size class, and health, metrics, REST, OpenAPI
and MCP surfaces. - Node store: a per-node runtime chunk store with metadata-only image receipt,
reference-counted read-only mounts, reuse counters, eviction to a byte budget, and its own
control surface (node-store.md). - Build without bytes: remote results keep their locations without fetching outputs, and
reads fetch verified chunks only on demand.liquid statusreports the bytes still remote. - Replay:
liquid replayreconstructs a recorded action and compares exit status, output
streams and declared outputs byte for byte. - Delta delivery:
liquid deltacreates, applies and fetches a signed patch between two
artifacts, verifying source, patch and target digests.
12. The incremental engine
- A persisted, demand-driven query graph: red-green validation, early cut-off on unchanged
fingerprints, durability, cooperative cancellation, and continuous clean validation that
recomputes one query in twenty and evicts a value that diverges. - Language frontends: a versioned C ABI loads replaceable language modules. The bundled
tree-sitter fallback fetches 49 grammars at exact commits under SHA-256 checks
(frontends.md,grammars.md). - Per-definition C++ builds: the Clang module emits one action per definition, so an edit
to a function body re-executes only that definition. - Structural diff: reports moves, semantic edits, formatting and comments, and labels its
fallback to text or binary (structural-diff.md). - Support tiers:
liquid tiersprints the declared support for each language, format and
platform (support-tiers.md). - Symbols: content-addressed symbol records per translation unit, with a labelled
tree-sitter fallback (symbols.md). - Hot update: evidence-based classification into tiers 0 to 4, signed patch and restart
records, and a cooperative C runtime for macOS arm64 and Linux x86_64
(hot-update.md). - Build streams, tests and plans: build handles stream events through the library and the
daemon; CMake test registrations become cached actions thatliquid testruns; and
liquid build --planprints the complete action plan
(../cli/build-events.md,../cli/test.md). - Structural edits for C and C++: rename, extract, move and concrete-tree edits, previewed
as minimal text changes, applied as one drip per file and undone as one operation
(edit.md). - The checkout daemon, on macOS and Linux: one process per checkout that owns capture, maps
each drip to the graph inputs it changed, feeds build, search, collaborator and Lake targets
in order with durable cursors, reports lag, and exits when idle. - Database branches for agents: one isolated PostgreSQL branch per session from a template
copy, guarded promotion that refuses a changed base, and discard
(data-branching.md).
13. Formats, projection, resolution and configuration
- Structural merge of concurrently changed source: disjoint definition edits combine, and
suspicious proposals stay conflict values (structural-merge.md). - Format registry: codecs for ZIP, tar, HDF5, Parquet, SQLite, linked binaries, PDF,
notebooks, office documents, packages, wheels, JARs, safetensors and (without executing it)
pickle. They drive diffs inside containers and search inside archives
(formats.md). - Projection: one checked install tree projects to deterministic
.deb,.rpm,.apk,
Homebrew bottles, Arch recipes, OCI image layouts, digest-pinned Helm charts, AppImages,
Flatpak build directories and Snaps, each with signed projection, provenance and SBOM
statements (projection.md). - Source projection: a change or result projects to an unsigned Debian
.dscwith
deterministic source archives. - Platform packages and signing: reproducible unsigned macOS packages, disk images, MSIX and
winget manifests, with signing records that bind the unsigned and shipped digests. - Install intent: canonical records generate Debian, RPM and Alpine lifecycle scripts, and
install, list and rollback use atomic generations with interruption recovery. - Image-based OS projection: OSTree commits and bootc OCI layouts.
- Dependency resolution: liquid's own CDCL solver over Spack-style specs, with virtual
providers, compilers as dependencies, target-family fallback, reuse preferred over freshness,
and minimal attributed conflict explanations (resolution.md). - The
.liquidconfiguration language: typed, declarative records for packages, sources,
targets, install intents and exclusive-checkout rules, with includes, exact diagnostics,
canonical formatting and generators that run with signed provenance
(configuration-language.md). - Spack import: a pinned Spack export becomes
.liquiddocuments and package records, with
a report of what was translated and what was lost. A committed 500-package fixture checks
resolution (import-spack.md).
14. Deployment
A client for the operator's control plane: digest-pinned OCI images, named environments, status
readback and rollback (deploy.md).
15. Every command
All 80 commands of the generated reference (docs/reference/cli/),
with the reference's own one-line summary.
Where Git has a command for the same thing, liquid uses Git's name. liquid --help lists
the commands in the groups below, Git's own first. A Git command that liquid deliberately does
not have says what to use instead: liquid commit answers with liquid cut, and add, grep,
reflog, submodule, mergetool, restore and branch have hints too. The rule and the
reason for every difference are in docs/cli/git-commands.md.
Repositories and history
| Command | What it does |
|---|---|
init |
create a repository and import its regular files |
clone |
clone and materialize a repository |
status |
show repository status |
cut |
cut the working change |
log |
show changes and drips, or verify timestamps and the transparency log |
refs |
list repository references |
diff |
compare changes, containers, and source syntax |
history |
show or restore path history |
blame |
show the session and change that last wrote each line |
tree |
print the recorded root tree digest |
write |
write a file from a stated base |
mv |
record a path move |
rm |
record a path removal |
anchor |
map a text position between changes |
ops |
list recorded operations |
undo |
undo the newest, named, or session operations |
edit |
preview or apply a structural edit |
symbols |
show compiler or syntactic symbols for a source path |
search |
search paths and contents |
Composition, conflicts, locks and sessions
| Command | What it does |
|---|---|
nest |
nest another repository |
split |
split a subtree into a repository |
combine |
combine another repository |
conflicts |
list unresolved conflicts |
conflict |
inspect or resolve an unresolved conflict |
resolve |
concretise packages or resolve a conflict |
lock |
exclusively lock a configured path |
unlock |
release an exclusive lock |
session |
manage a private speculative replica |
data |
manage session database branches |
Capture, working trees and the store
| Command | What it does |
|---|---|
daemon |
start or stop the checkout daemon |
watch |
capture changes until Ctrl-C |
pause |
pause working-tree capture |
resume |
resume working-tree capture |
mount |
mount a lazy working tree |
materialise |
write a full working tree |
compact |
checkpoint a repository epoch |
gc |
checkpoint and collect a repository |
repack |
rebase stored chunk deltas |
retain |
explain retention for an object |
Sync, review, drive and interchange
| Command | What it does |
|---|---|
push |
push repository changes and objects |
pull |
pull repository changes and objects |
review |
review a lake change in place |
drive |
synchronize a drive folder |
import |
import a local tree, Git repository, or Spack package universe |
export |
export as a Git repository |
serve |
serve repository sync, REAPI, or image admission |
Identity, keys, signing and trust
| Command | What it does |
|---|---|
identity |
show or rotate the device identity |
keys |
inspect and manage data-key custody |
secret |
fetch, seal, or unseal a Lake environment secret |
sign |
sign a digest or projected platform installer |
release |
manage threshold release approval |
attest |
show, verify, or mint an image attestation |
registry |
manage artifact-registry trust |
policy |
check or explain build-input policy |
Building
| Command | What it does |
|---|---|
wrap |
run an existing build as cached actions |
build |
plan, start, profile, or trace a configured repository build |
test |
run discovered tests as cached actions |
verify |
re-execute and compare cached actions or the query graph |
replay |
reproduce and compare a recorded action |
why |
explain the latest cache lookup |
why-slow |
show the critical path to a build target |
cache |
show build-cache statistics |
facts |
inspect or export configure facts |
provenance |
print and verify build provenance |
sbom |
print a derived or explicitly inferred SBOM |
abi |
show or compare library ABIs |
inspect |
explain a recognised artifact |
hot-update |
classify, apply, or inspect runtime updates |
scheduler |
run the remote-execution scheduler and CAS |
worker |
run a remote-execution worker |
node-store |
run or control the runtime node chunk store |
Packaging, installing and deploying
| Command | What it does |
|---|---|
config |
check, lower, or format .liquid configuration |
project |
project content into packages, commits, images, or charts |
delta |
create, apply, or fetch an artifact delta |
install |
install or list atomic generations |
rollback |
select the previous installed generation |
deploy |
create, inspect, or roll back an environment deployment |
About the tool
| Command | What it does |
|---|---|
version |
print the version |
tiers |
print declared language, format, and platform support |
docs |
generate the CLI reference |
16. Guides and documentation
Five executable guides, whose shell blocks run as tests (docs/guides/):
- Your first repository: automatic drips, named changes, diff, search, and push to a local
sync peer. - Wrap an existing build: real CMake and Autotools projects, cache reuse, miss explanation
and provenance. - Keys and encryption: public identity export, encrypted paths, key providers and rotation.
- Resolve packages from declarations: a two-package dependency graph and canonical records.
- Package ordinary repository files: a change packaged as Debian and OCI artifacts, with
deterministic Debian bytes.
Also in the tree: the generated CLI reference, 25 feature specifications
(docs/features/), 27 research topics
(docs/research/), the library notes
(docs/library/), and the vendored TAAP/1 draft
(docs/standards/).
What v0.1.0 does not include
The known limits, from docs/library/status.md:
- Lazy mounts,
wrap,verifyandreplayneed libfuse3 on Linux and macFUSE on macOS.
Without macFUSE those commands report their documented unsupported or skipped result. - Windows returns a documented unsupported result for the daemon, and for
wrap,verify
andreplay. - Phase exits not yet demonstrated: the Phase 2 exit
(#299) and the Phase 4 exit
(#300). No machine reachable from the
development Mac has a FUSE mount; the
lane audit records what was checked. - The action-result memory cache tier is separate work.
- Measured transfer timing remains Phase 3 work.
- The containerd proxy snapshotter remains in k0s.
- The executable-aware delta algorithm id is reserved and unused.
- Encrypted objects are not transferred by
repository::transfer. - The data-branch reflink fast path needs local cluster control metadata.
- Apple notarisation has no recorded credentialed proof, and booting a projected image is
outside the projection implementation. - Tier B source projection is Debian-only.
- Filesystem projection without FUSE on Linux, macOS and Windows
(#302,
#303,
#304). - The hosted service and the IDE are their own projects (Lake and liquify), not part of
this release. - A licence. None has been chosen
(liquid-bridge#2).
Known issues
- #349 — creating the local identity
races: concurrent first uses can leave it unreadable (cannot unwrap local identity). - #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. - #310 — the public constructors of
forge_clientandsync_endpointthrow across the library boundary. - #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 carriesRetry-After. - #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:maintakes 1,773 s against a 900 s ceiling. - The suite on Linux: #356 (the full
suite fails about 300 tests under a parallel run on the Linux lane) and
#348 (326 of 693 fail in a container on
environment, not code). - Intermittent tests: #354 and
#336 (admission server),
#353 (daemon under load),
#264 (node store) and
#225 (drip overflow on Linux).
Verification
Full suite, run serially (ctest --test-dir build, no -j) on the release branch. macOS
arm64, Homebrew Clang 22.1.8, without macFUSE, 367 seconds, after the last code change on the
branch (the grouped help and mv):
745 tests · 733 passed · 0 failed · 12 skipped
The 12 skipped tests need something this host lacks: a FUSE mount (lazy mount, wrapped
build and libfuse conformance cases), a configured REAPI or NativeLink peer, a node content
store, native packaging peers, or a restart hook. So this run does not exercise wrap,
verify, replay or lazy mounts end to end; see
#291.
A first run on this branch failed one test, and the cause is fixed in this release.
Version.StringMatchesStruct showed that the version lives in a third place,
current_version() in include/liquid/version.hpp, which still said 0.0.1. The header now
says 0.1.0, and the test compares the string with the struct instead of repeating a literal.
Every run since, including the one above, is the whole suite after that fix.
The build has no compiler warnings. ./build/liquid version prints liquid 0.1.0.
Checks on this page and the tree: the command tables match
docs/reference/cli/cli.json (80 commands, none missing, none extra); the link check over
docs/, README.md and CLAUDE.md reports 0 broken links.
Not done for this release: the suite on Linux (the cluster BuildKit lane; see
#356 and
#348), the shared-library build
(#319), and Windows.
Building it
git clone --recurse-submodules git@github.com:oramasearch/liquid.git
cd liquid
cmake -S . -B build -G Ninja
cmake --build build
ctest --test-dir buildPrerequisites, options and the install layout are in
docs/build/local.md. Consuming the library from another CMake project is
in docs/library/libliquid.md.