ngit-ci v0.2 launch
Release preview
This is the launch preview for the upcoming v0.2.0 release. The linked guides describe the reviewed development version; the final release has not yet been published.
Your workflows, your machines, reusable builds.
ngit-ci v0.2 lets coordinators delegate workflow jobs to compute providers running on different machines, including your own Mac for macOS builds. Nix workflows replace act as the default. Jobs and results are coordinated over Grasp CI, our Nostr-based CI protocol.
Trusted providers can share cached build inputs and outputs to save work and help builds keep running when central services go down, rate-limit us or block access. We’re building for an internet where access isn’t guaranteed.
Self-hosting and manually arranged provider sharing work today. Next, we want to make room for community-donated compute and operators offering repository hosting, CI and blob storage together. The marketplace, subscriptions and community compute arrangements described below are future plans, not features of v0.2.
One workflow, different machines
A coordinator watches your repositories and schedules jobs. Providers supply the compute and execution environment. Those roles can share a machine or run separately, with distinct identities and explicit trust.
A workflow can build on Linux and Apple Silicon macOS, then publish once both jobs succeed. Linux providers use disposable Firecracker VMs; macOS providers use disposable macOS VMs. An explicitly authorized container tier is also available for trusted code.
Each provider signs its job result, and the coordinator assembles the workflow result. Clients can show who executed the work and why that coordinator was authorized to run it.
Choose a deployment or understand the roles and trust model.
Nix is the build foundation
Build inputs and commands come from the repository's root flake and lockfile. CI-only definitions live beside the workflows under .grasp/nix/, while shared packages and modules stay with the product.
This gives local development and CI a common build definition. The coordinator handles job dependencies and provider selection; Nix handles the build graph. You can request resources and a timeout for each job, pass artifacts between jobs, and restart a failed job and its dependants while retaining verified results outside that rerun set.
We chose this foundation for independently operated compute, rather than continuing to make GitHub Actions compatibility the centre of the design. Coding agents can help translate existing workflows, with review and validation of the resulting builds and publication steps.
Why we moved from act to Nix explains the decision. Write a Nix workflow when you are ready to try it.
Shared caches make builds faster and more resilient
We are designing for an internet where central services can rate-limit or block us. Keeping builds running under those conditions matters as much as making them faster. Shared caches help preserve useful work under the control of operators we choose to trust.
Providers can publish caches, and other providers can explicitly trust and reuse their matching build outputs. A toolchain built on one machine can save another machine that work. Fresh job VMs remain disposable without throwing away the useful dependencies they needed.
When an upstream repository or service is offline, rate-limiting requests or blocking access, a trusted cache can supply retained inputs and outputs instead. Builds whose dependencies are available can keep running without fetching them again from the original service. This resilience depends on retaining the objects a build needs; caching cannot replace missing inputs or a live service that a workflow calls directly.
Provider cache sharing explains how identities, signing keys and trust fit together.
Opening the door to independent providers
The coordinator and provider roles let you run CI on your own machines and experiment with sharing compute between independent operators. You can agree to provide capacity for another project's coordinator, or arrange for another operator to run jobs for yours.
In v0.2, those arrangements happen through direct coordination and manual configuration. Providers own resource budgets and explicitly choose which coordinators and caches they trust. Authorization to run jobs is separate from authorization to receive repository secrets.
Where we want to take this
We want operators to be able to offer maintainers a complete service: GRASP for repository hosting, Grasp CI for coordinating workflows, and Blossom for storing related blobs, including build logs and artifacts.
Community members could contribute spare compute to projects they support: selected repositories, projects in their web of trust, or anyone. That could make routine tests and CI freely available, while jobs that need secrets run only on providers explicitly trusted to receive them.
Operators could combine free hosting and community compute with a small monthly subscription covering storage and a modest allowance of compute from trusted providers. Maintainers would have a straightforward way to get started, without having to run every part themselves.
This is our vision for future releases, not an offering available in v0.2. Today, you can self-host Grasp CI and experiment with sharing compute through direct coordination and manual configuration. The marketplace, subscriptions and community compute arrangements described above are still to be built.
Set up CI for your repositories or provide compute for other projects.
Upgrading from v0.1.1
Act is deprecated and disabled by default. Existing act workflows can still run with an explicitly enabled backend while you migrate. Nix workflows use a different format: moving or renaming an act YAML file does not convert it.
Read the migration guide before upgrading an existing installation. For a new setup, start with Run ngit-ci.