Configuration that ships as a single binary.
config weave reads a typed WCL playbook and either applies it to converge a machine — or checks that the machine already matches. No agent, no interpreter, no dependencies. Copy one binary onto a Linux or Windows host alongside a playbook folder and run it.
$ config-weave apply ./sample baseline gathered 1 fact set(s) apply 'Sample Baseline' v1.0.0 — play 'baseline' ● make-a configured ● secondary/make-b configured summary: 2 configured · 0 already configured · 0 error (0.1s) exit 0
$ config-weave check ./sample baseline gathered 1 fact set(s) check 'Sample Baseline' v1.0.0 — play 'baseline' ✓ make-a already configured ✓ secondary/make-b already configured summary: 2 already configured · 0 not configured · 0 error (0.0s) exit 0
Describe the state. apply it, or check it.
A playbook is a typed WCL document — facts to gather, variables, and ordered steps that declare desired state. The same playbook drives both convergence and verification.
playbook "Sample Baseline" { description = "Create marker files in order" gather "os" { from = "core.os_info" } vars { work_root = "/tmp/config-weave-sample" is_linux = os.family == "linux" } play "baseline" { step "make-a" { resource = "core.file_present" condition = is_linux properties { path = $"${work_root}/a.txt" content = "alpha" } } } }
Declare the facts to gather, variables, and the steps that make up desired state in a playbook.wcl. Each step names a resource like core.file_present; its properties are validated against the resource's declared params.
Runs each step idempotently, in dependency order. requires sequences steps; condition skips ones that don't apply to this host. Only steps that are out of state change.
Re-runs the same playbook read-only and reports each step's status without touching the machine — a dry audit. After a successful apply, a re-check returns already configured, even in a fresh process.
More gatherers and resources — by dropping in a folder.
config weave loads every package under a playbook's pkgs/ folder. Each package is a folder with a package.wcl that registers what it provides — gatherers and resources, namespaced by package: core.file_present, core.os_info. Add a folder and its scripts are available to every play. No registry, no recompile — packages are discovered on the next run.
Drop a folder in pkgs/. No registry, no recompile — config weave discovers it on the next run.
package "core" { description = "Core sample package" gatherer "os_info" { script = "gatherers/os_info.wscript" } resource "file_present" { script = "resources/file_present.wscript" concurrency = "parallel" param "path" { type = "string" required = true } param "content" { type = "string" default = "" } } }
A manifest registers gatherers and resources, each backed by a wscript. Playbooks reference them as core.file_present.
config-weave init writes a starter playbook plus an example package — a gatherer, a resource, their wscripts, and a convergence test — ready to edit.
One file. No runtime.
config weave compiles to a single statically-linked executable. There's nothing to install on the target — no Python, no Ruby, no agent, no shared libraries. Copy the binary to the box, run it, done. The same playbook runs on Linux and Windows.
$ file config-weave config-weave: ELF 64-bit LSB executable, statically linked $ ldd config-weave not a dynamic executable $ ./config-weave check ./sample baseline summary: 2 already configured · 0 not configured · 0 error exit 0
Built for people who run other people's machines.
Describe desired state in a typed config language — facts, vars, plays and steps, with real expressions and conditions.
One playbook, two modes: converge a machine to the declared state, or verify it matches without making any change.
check re-runs the playbook read-only and reports each step — what's already configured and what would change — without touching the box.
A single self-contained executable. No agent, no interpreter, no shared libraries to chase across distros.
The same playbook runs on both — one statically-linked binary per platform, cross-compiled and ready to drop onto a fresh box.
requires sequences dependent steps into a DAG; condition targets steps by gathered facts; containers group related steps.
Up and running in three commands.
Grab a prebuilt binary from the releases page — two binaries plus a checksums file, no installer — and put it on your PATH. Then point it at a playbook folder.
On Windows, download config-weave.exe from releases and run the same commands.
Drop a binary. Converge a fleet.
No control plane, no daemons, no dependency hell. Just a playbook folder and one executable that runs the same way everywhere.