Written in Rust · single static binary

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.

Linux · Windows · statically linked · zero deps

target hostapply

$ 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

target hostcheck

$ 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

sample/playbook.wclwcl

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"
      }
    }
  }
}

How it works

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. Each step names a resource like core.file_present; its properties are validated against the resource's declared params before anything runs. apply converges each out-of-state step idempotently, in dependency order — requires sequences steps, condition skips ones that don't apply to this host. check re-runs the same playbook read-only and reports each step without touching the machine; after a successful apply, a re-check returns *already configured*, even in a fresh process.

pkgs/core/package.wclwcl

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 = ""
    }
  }
}

Packages

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. Each is backed by a wscript script obeying the check → apply → re-check contract. Add a folder and its scripts are available to every play — no registry, no recompile; packages are discovered on the next run. config-weave init writes a starter playbook plus an example package, ready to edit.

Static binary

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.

target host · no toolchain

$ 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

Features

Built for people who run other people's machines.

Declarative WCL

Describe desired state in a typed config language — facts, vars, plays and steps, with real expressions and conditions.

apply & check

One playbook, two modes: converge a machine to the declared state, or verify it matches without making any change.

Report-only dry run

check re-runs the playbook read-only and reports each step — what's already configured and what would change — without touching the box.

Static binaries

A single self-contained executable. No agent, no interpreter, no shared libraries to chase across distros.

Linux & Windows

The same playbook runs on both — one statically-linked binary per platform, cross-compiled and ready to drop onto a fresh box.

Ordered & conditional

requires sequences dependent steps into a DAG; condition targets steps by gathered facts; containers group related steps.

Reference

The manual

The reference is published as a wskill — a self-contained WCL model projected into a readable book, a Claude Code skill, an overview deck, and a hands-on training course.

config-weave

Single-binary configuration management driven by WCL playbooks and wscript resource scripts, with a check → apply → re-check convergence contract and a disposable-instance testlab.

Read the manual · deck · course

Install

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 and run the same commands.

Scaffold a starter playbook
config-weave init my-playbook
Converge a machine
config-weave apply my-playbook baseline
Verify with no changes
config-weave check my-playbook baseline