Compose
A reproducible stack from many repos: a haw.toml manifest and a committed haw.lock pin every repo to an exact SHA. Stacks & overlays, shallow and partial clone.
One binary · in Rust · v0.1.7
haw pins your whole multi-repo stack to one lockfile — so you, your
CI, and your teammate check out the identical tree, every time.
One binary, in Rust.
No submodules · no detached HEADs · no symlinks · no Python runtime.
haw is a multi-repo platform for teams that ship a product spread across
many Git repositories. Five capabilities, one binary — each solving a slice of the
multi-repo problem.
A reproducible stack from many repos: a haw.toml manifest and a committed haw.lock pin every repo to an exact SHA. Stacks & overlays, shallow and partial clone.
Run work across the whole fleet: parallel run/build/test, a fleet-wide grep, and a verify gate that exits 3 on drift — drop it straight into CI.
Cross-repo, cross-forge change flow: one feature = one branch across N repos, with linked PR/MRs on GitHub, GitLab & Bitbucket, and land to merge in dependency order.
A k9s-style TUI cockpit (bare haw): read → drill → act. Live fleet grid, PR checks, CI progress — then merge, approve, or checkout from the keyboard.
Supply-chain & audit, built in: plugins, SBOM (CycloneDX + SPDX), SLSA/in-toto provenance, cosign/minisign signing, and evidence bundles for qualification.
It's not a git wrapper. It's the layer above git: the manifest, the lockfile, the fleet-wide build/test/CI, the cross-forge change flow, and the audit trail.
Three commands from install to cockpit.
# install the one binary
$ cargo install hawser
# clone every repo, write haw.lock
$ haw sync
# open the cockpit
$ haw
New here? Start the guided course below, or explore runnable manifests in
examples/.
A guided course, from zero to productive. Nine short chapters — read them in order.
haw, and see the cockpit.
haw.toml.
Splitting a product across repositories is routine — and domain-agnostic. The manifest, lockfile, changeset flow, fleet build/test, and governance hooks are the same in every domain; only the repos and commands differ.
Shared HAL/BSP/MCAL reused across many ECUs; AUTOSAR/ARXML config repos pinned beside the code.
One feature spanning N services plus a shared proto/lib — branched, PR'd, and landed together.
Model repo + data-pipeline repo + serving infra, pinned as one reproducible baseline.
Terraform, Helm, and reusable module repos composed and versioned as a unit.
An app repo and its SDK repo(s), changed in lockstep across a single changeset.
“It's not a git wrapper. haw orchestrates Git and the forge APIs — it does not reimplement Git's merge engine, replace a forge, or replace your toolchain.”
If you manage multiple git repositories and need a reproducible multi-repo build,
submodules and hand-rolled scripts both fall short. haw pins every repo to
an exact SHA in one lockfile, then builds, tests, and ships changes across the whole fleet.
No detached HEADs, no fragile .gitmodules, no nested-checkout surprises.
Each repo stays a plain, autonomous git clone; reproducibility comes from haw.lock.
Stop maintaining a bash script that clones N repos. One manifest declares the stack;
haw sync writes exact SHAs so you, CI, and teammates get the identical tree.
Keep independent repos, histories, and access control — get monorepo-style "one coherent version" without merging everything into a single tree.
Beyond composition: run haw build / haw test in parallel across
every repo, and open cross-repo pull/merge requests as one changeset.
hawser. It pins many git repos to exact SHAs in a single lockfile without the detached-HEAD and nested-checkout pain of submodules — one static binary, no Python.
Declare them in a haw.toml manifest, run haw sync to clone and pin
every repo, then drive builds, tests, and cross-repo changes from one TUI cockpit.
haw sync writes haw.lock with the exact commit SHA of every repo, so
any machine checks out the identical tree — reproducible by construction.
Submodules embed pinned pointers inside one repo and detach HEADs. hawser keeps each repo autonomous, adds a shared lockfile, and layers parallel build/test plus cross-repo PR flow on top.
Everything, published as an mdBook under /hawser/docs/.
The guided learning course, chapter by chapter.
Runnable manifests per domain + real embedded fleets you can build.
Docker cross-compile, QEMU/FreeRTOS, tresos/Vector/IAR wiring.
The full verb lexicon and the cockpit keymap.
Writing haw-<name> plugins and the dispatch contract.
Plugins, hooks, auth, and CI/CD integration.
Crate layout, concurrency model, forge abstraction, data flows.
How the manifest/lock/changeset loop maps onto each domain.
Full install matrix + signature verification.
Release channels and packaging.
Tool qualification, SBOM/CRA, crypto/signing, GDPR.
The trust model — what haw executes, plugin trust, tokens.
Pick a package manager — all install the same haw binary v0.1.3.
# Rust / crates.io (canonical)
$ cargo install hawser# macOS + Linux (Homebrew)
$ brew install nastwinns/tap/hawser# Windows (Scoop)
$ scoop bucket add nastwinns https://github.com/Nastwinns/scoop-bucket
$ scoop install hawser# Fully static — no glibc, no runtime; ideal for servers, containers, air-gap
$ curl -sSL https://github.com/Nastwinns/hawser/releases/download/v0.1.3/\
haw-0.1.3-x86_64-unknown-linux-musl.tar.gz | tar xz \
&& sudo install haw /usr/local/bin/
Every release is signed (cosign .sig/.pem + .sha256).
Full matrix & verification: docs/INSTALL.