orbito

A fast, ergonomic multi-repository manifest & sync tool, written in Rust. orbito is a spiritual alternative to Google's repo and Fuchsia's jiri — same core idea (one manifest describing many git repos, synced together as a workspace) but:

• TOML manifests instead of XML — easy to read, easy to diff.
• A single static binary, no Python runtime dependency.
• Parallel sync across projects using native threads.
• Manifest imports, hooks, and pinned projects, matching the parts of repo/jiri that people actually rely on day to day.

See DESIGN.md for the full design doc and specification — manifest schema, import resolution algorithm, command semantics, workspace layout, and known limitations.

Requirements

• git on PATH (used for cloning/fetching all projects).
• curl on PATH, only if you use direct-URL manifest imports ([[import]] url = "https://.../manifest.toml" with no manifest field).

CI & releases

• .github/workflows/ci.yml — on every push/PR to main: builds and runs cargo test on Linux and Windows. A separate advisory job runs cargo fmt --check and cargo clippy (non-blocking).

• .github/workflows/release.yml — on pushing a tag matching v*.*.* (or via manual workflow_dispatch), builds portable, self-contained archives for:

  • windows-x86_64 (windows-latest), windows-arm64 (native, windows-11-arm)
  • linux-x86_64 (ubuntu-latest), linux-arm64 (native, ubuntu-24.04-arm)

  All four are statically linked against musl on Linux / built with the native MSVC toolchain on Windows, and are built on GitHub's native runner for their own architecture — no Docker or cross-compilation toolchain required.

  Each archive (orbito-<version>-<platform>.zip/.tar.gz) bundles the binary, README.md, both license files, and examples/manifest.toml, plus a .sha256 checksum. The workflow finishes by publishing a GitHub Release with all archives and a combined SHA256SUMS.txt attached.

Pushing this repo to GitHub

# create an empty repo on GitHub first, then:
git remote add origin https://github.com/<you>/orbito.git
git push -u origin main

# cut a release (triggers release.yml and publishes binaries):
git tag v0.1.0
git push origin v0.1.0

Before your first release, update the placeholder repository URL in Cargo.toml to your actual GitHub repo.

Install

cargo build --release
# binary at target/release/orbito

Manifest format

A manifest is a TOML file (conventionally manifest.toml) checked into its own git repository, exactly like repo's manifest repo:

[[remote]]
name = "origin"
fetch = "https://github.com/my-org"
review = "https://gerrit.my-org.com"   # optional, Gerrit-style review URL

[default]
remote = "origin"
revision = "main"

[[project]]
name = "platform/core"      # path on the remote, e.g. github.com/my-org/platform/core
path = "core"               # local checkout path (defaults to `name`)
revision = "main"           # branch/tag/commit (defaults to `default.revision`)
hooks = ["./setup.sh"]      # run once, right after first clone

[[project]]
name = "vendor/thirdparty"
path = "third_party/vendor"
pinned = true                # sync will never move this project's HEAD

[[import]]
manifest = "vendor.toml"     # merge in another manifest, relative to this file

[[import]]
url = "https://raw.githubusercontent.com/my-org/manifests/main/extra.toml"
# direct link to a manifest file, fetched over HTTP(S) as-is (no git clone)

[[import]]
url = "https://github.com/my-org/other-manifests"
manifest = "extra.toml"      # file to read inside that repo
revision = "main"            # branch/tag/commit to check out (default: main)

Imports can be nested arbitrarily: a manifest fetched from a URL can itself [[import]] further manifests, either by relative path (resolved against that URL) or by another url. Git-hosted imports are cached under .orbito/imports/; direct file-URL imports are re-fetched on every sync.

Commands

Command	Description
orbito init <manifest-repo-url> [-m manifest.toml] [-b main]	Clone the manifest repo and set up .orbito/ in the current directory.
orbito sync [-j N] [--manifest-only]	Update the manifest repo, then clone/fetch/checkout every project, N at a time (default 4).
orbito status	Show clean/dirty state and current branch for every project.
orbito list [--toml]	List every resolved project (name, remote, revision).
orbito manifest	Print the fully-resolved manifest, after following all [[import]]s.
orbito forall -c "<cmd>" [-p]	Run a shell command in every project's directory. -p keeps going past failures.
orbito branch <name>	Create/check out a branch with the same name in every project (like repo start).

Design notes

• Workspace state lives in .orbito/config.toml (which manifest repo/branch this workspace tracks) plus the manifest repo's own checkout under .orbito/manifest-repo/, mirroring repo's .repo/manifests.git split.
• sync shells out to the system git binary rather than linking libgit2, so it always behaves exactly like your installed git (credential helpers, SSH config, .gitconfig, etc. all just work).
• Project sync is parallelized by chunking the project list across -j worker threads; each worker syncs its projects strictly sequentially, so output per-project stays coherent even though projects interleave.

Not yet implemented

• Gerrit-style upload/push-for-review (the review URL is parsed but unused).
• Manifest snapshotting / orbito manifest --freeze (pin every project to its current exact commit, like repo manifest -r).
• Cross-project rebase/merge helpers beyond what forall gives you for free.