Rivet is an open-source, self-hosted CI/CD platform for defining, running, and
operating build pipelines from one focused control room. It combines an
explicit Rivetfile.toml, a Rust execution engine, durable SQLite history, a
headless HTTP/WebSocket API, a CLI, and a Tauri desktop application.
If you are evaluating Jenkins alternatives, Rivet is a candidate self-hosted Jenkins replacement for teams that want a fresh architecture to try: local- first operation, visible queue and stage state, typed events, remote-agent execution, and a modern developer-tool interface. It is built independently from Jenkins and is intentionally not a feature-for-feature clone of Jenkins or its Java plugin ecosystem.
Rivet is currently an early alpha. The working slices below are real and tested, but cross-platform packaging, production operations, broad Jenkins migration, and full Jenkins parity are not claimed.
Download · Roadmap · Issues · Discussions · Contributing · Support · Code of Conduct · Security · Changelog · Citation
98% verified · ███████████████████▌
Weighted evidence score: 98.21 / 100 · displayed conservatively as the
whole-number floor. This measures the weighted product scope in
ROADMAP.md, not Jenkins parity.
The 50-second preview shows the real macOS control room, a passed local pipeline, the Jenkinsfile migration assistant, queue visibility, remote-agent status, and the light/dark workspace. Watch or download the full MP4.
Jenkins remains a capable and widely used automation server. Rivet exists for teams that want to evaluate a newer CI/CD architecture alongside it: a smaller local-first control room, explicit pipeline contracts, and build state that is easy to inspect from the CLI, API, or desktop UI.
In many CI/CD systems, the operator reconstructs what is happening from scattered logs, opaque configuration, queue state, and provider callbacks. Rivet keeps the execution model explicit:
- the pipeline is a versioned TOML file;
- each build has a durable identity, source snapshot, stage state, logs, and history;
- queue admission, cancellation, retry, and resource requirements are visible;
- the same Rust core powers the CLI, headless server, and desktop client.
The result is an auditable foundation for local development and self-hosted automation, with a path toward distributed runners. Think of it as a modern Jenkins alternative for teams who value inspectability and a Rust-native core, not as a promise that every Jenkins plugin already works in Rivet.
Rivetfile.toml uses explicit executable and argument arrays. Pipelines support
validated stage dependencies, stable topological ordering, parallel independent
stages, parameters, deterministic conditional stages with explicit skipped
outcomes, timeouts, declared artifacts, optional stage ownership, and
per-artifact retention windows.
The native process runner streams stdout and stderr with bounded line retention, supports cancellation and cleanup, and records typed build events. The scheduler provides FIFO ordering, bounded priorities, per-project/global capacity, pause/resume, queue telemetry, and pre-execution cancellation.
Build details, stage movement, live output, retry actions, checksummed artifact downloads, retention pruning, and project-scoped local CI cache operations are available through the CLI, API, and desktop control room. Cache keys can include branch, platform, local Git revision, and lockfile-hash context.
Rivet can inspect Git source at build admission and exercise clone, checkout, fetch, clean, submodule, and explicit revision preparation. It supports local project onboarding, remote clone onboarding into an explicit destination, repository polling, persistent UTC cron schedules, signed generic webhooks, internal passed-build gates, and provider completion mappings for GitHub Actions, GitLab CI, and Bitbucket Pipelines.
Use the migration analyzer to turn a readable Jenkinsfile into a reviewed
Rivetfile.toml draft. Simple declarative stages, quoted shell steps, typed
parameters, static environment values, safe archive patterns, and explicit
parallel-stage dependencies can be converted; unsupported Groovy and
plugin-specific behavior is reported instead of executed or guessed.
cargo run -p rivet -- migrate Jenkinsfile --output Rivetfile.tomlReview the generated file and every warning before running it. Rivet does not claim arbitrary Jenkins plugin compatibility. The machine-readable Jenkins compatibility matrix records each claim with an explicit status and evidence path.
Remote agents register through a versioned authenticated protocol, advertise executor/CPU/memory/disk capabilities, receive compatible assignments, run through the shared Rust pipeline runner, and relay typed events, output, cancellation, artifacts, and bounded retry/recovery state.
The Tauri desktop client embeds a loopback Rust engine and starts in light mode,
with a persistent dark-mode toggle. The headless server provides health and
readiness probes, scoped API identities, opaque sessions, audit records,
authenticated metrics, graceful shutdown, and a bounded extension surface.
The local credential vault encrypts provider credentials, records an owner
identity for rotation/audit, and keeps projects scoped to opaque references
rather than ordinary pipeline records. The CLI supports --owner without
placing secrets in process arguments.
For example, list only credentials owned by one identity from the CLI:
rivet credential list \
--owner user:42 \
--passphrase-file /private/path/passphraseFor destructive CLI removal, pass the same --owner guard; Rivet refuses the
operation when the credential belongs to another identity:
rivet credential remove github \
--owner user:42 \
--passphrase-file /private/path/passphraseThe headless API exposes the same inventory boundary with
GET /api/v1/credentials?owner=user%3A42. This endpoint is admin-authenticated
and returns summaries only; credential secrets are never returned. DELETE
/api/v1/credentials/{id}?owner=user%3A42 applies the same ownership guard.
The desktop credential inventory also has an owner filter so operators can
review one identity's scope without mixing it with the rest of the vault.
| Pipeline control room | Migration assistant |
|---|---|
![]() |
![]() |
| Queue control room | Remote-agent fleet |
|---|---|
![]() |
![]() |
The interface is intentionally honest about boundaries: unavailable engine state, experimental areas, empty queues, and future work are shown in the UI instead of being presented as completed functionality.
The first public release is a source-oriented alpha. The current repository does not require Docker or Podman for the local pipeline path.
- Rust stable and Cargo
- Git
- Node.js and npm for the desktop client
- Tauri desktop prerequisites for the operating system where you build the UI
The checked-in local validation and release smoke path is verified on macOS. Windows and Linux packaging, clean-install behavior, and target-platform interoperability still need their own evidence.
git clone https://github.com/OthmaneBlial/Rivet.git
cd Rivet
cargo run -p rivet -- init .
cargo run -p rivet -- project create rivet --repository .
cargo run -p rivet -- run rivet
cargo run -p rivet -- builds rivet
cargo run -p rivet -- inspect rivet --build 1
cargo run -p rivet -- logs rivet --build 1The sample Rivetfile.toml runs the repository formatter and workspace tests.
For a short, dependency-light walkthrough use
examples/demo/Rivetfile.toml, which is also
the pipeline used for the checked-in desktop demo capture.
cargo run -p rivet -- migrate ./Jenkinsfile --output ./Rivetfile.tomlThe command refuses to overwrite an existing file unless --force is passed.
The output is a draft: inspect its status and warnings before using it in a
real CI/CD workflow.
Container steps can be restricted to a deployment-owned comma-separated
allow-list. Unqualified images such as rust:1.85 are evaluated as
docker.io; an image from any other registry is refused before the runtime is
invoked.
export RIVET_ALLOWED_CONTAINER_REGISTRIES=ghcr.io,docker.ioThe policy does not install or start Docker/Podman. The repository verifies the policy and process controls through a local runtime shim; behavior against a real container daemon remains an explicit release gate.
cd apps/desktop
npm install
npm run tauri devUse New project to connect a local checkout or bootstrap a remote clone. The app starts in light mode; use the top-right theme control to switch to dark mode. The theme preference is persisted locally.
v0.1.0-alpha
contains:
- an optimized macOS arm64 CLI binary;
- an unsigned macOS
Rivet.appbundle for local evaluation; - SHA-256 checksums and the local validation manifest;
- the demo MP4 used by this README.
The macOS bundle is unsigned and is not notarized. macOS may ask you to confirm the first launch. There are no Windows or Linux installers in this release.
Rivetfile.toml
│ parsed and validated by rivet-core
▼
Queue + scheduler ───────► local Rust process runner
│ │
│ ├── stage events / logs / artifacts
│ ▼
├──────────────────────► SQLite history + local cache
│
├── REST + WebSocket API ──► CLI / Tauri control room
│
└── authenticated agent protocol ──► compatible remote workers
The native boundary owns process execution, filesystem access, Git/SCM operations, persistence, credentials, cancellation, and transport. The web client is an interaction layer over typed HTTP/WebSocket and Tauri commands.
- Rust 2024 workspace for domain contracts, execution, storage, SCM, authentication, credentials, extensions, server transport, and CLI behavior.
- SQLite for migrations, build projections, event replay, schedules, cache metadata, audit records, and artifact metadata.
- Axum/Tokio HTTP + WebSocket transport for the headless server and live build events.
- React + TypeScript + Vite for the operator interface.
- Tauri 2 for a native desktop bundle with an ephemeral loopback engine origin.
- WASM and subprocess extension contracts with bounded frames and explicit permissions; filesystem, network, process, and clock capabilities are not exposed to WASM modules.
Rivet is designed for local-first operation, but it is not a security product or a hosted service. Review the security policy and keep these boundaries in mind:
- never commit tokens, private keys, passwords, or real provider payloads;
- use opaque credential IDs and the encrypted local vault for SCM/provider secrets;
- use an exact CORS allow-list and authenticated transport for remote binds;
- treat container declarations, remote agents, extensions, and migration drafts as capabilities that require deliberate review;
- use disposable repositories and loopback fixtures for protocol testing.
The repository currently reports 98.21 / 100 weighted evidence points and displays 98% verified. This is an engineering progress measure, not a promise of complete platform coverage.
| Boundary | Status |
|---|---|
| Rust pipeline model, local runner, SQLite history, CLI workflow | Working and locally tested |
| Headless API, WebSocket events, queue controls, schedules, triggers, artifacts, cache | Working slices with local evidence |
| Tauri control room, light default, dark mode, offline recovery, packaged loopback engine | Working and locally tested, including packaged window QA |
| Remote-agent protocol and shared-runner execution | Working local vertical slice |
| GitHub/GitLab/Bitbucket signed completion mappings | Working locally; provider deployment evidence remains |
| Docker/Podman daemon behavior and artifact extraction, external identity providers, signed installers, Windows/Linux packages | Planned or unverified |
| Jenkinsfile migration | Experimental analyzer; review every finding and draft |
See the weighted roadmap for the exact gates and denominator.
Format, test, and build the core locally:
cargo fmt --all -- --check
cargo test --workspace
(cd apps/desktop && npm install && npm run build)
./scripts/local-documentation-check.shThe common baseline is also available as make check. Use make desktop-build
for the desktop-only build or make release for the full macOS packaging gate.
Run the full macOS release gate:
./scripts/local-release-check.shThe gate checks repository hygiene and progress consistency, Rust formatting and tests, the optimized CLI, the desktop web client, the native Tauri host, the unsigned macOS bundle and packaged loopback engine, real temporary-data SCM/CLI workflows, queue priority and cancellation, backup/restore, authentication, the checked-in compatibility corpus and live adapters, and deployment hardening. It writes a versioned SHA-256 manifest to a temporary release directory. The gate is local by design; this repository intentionally has no GitHub Actions workflow.
If the release gate reports no Tauri window (-2700), the bundle and engine
may already be healthy but macOS has denied the automation probe. Grant
Accessibility access to the terminal running the check under System Settings
→ Privacy & Security → Accessibility, then rerun the gate. The window check
is intentionally strict and is never skipped.
The next meaningful gates are:
- final packaged Tauri-window interaction and clean-install QA;
- broader provider lifecycle/event coverage and deployment-specific keychain evidence;
- external identity providers and richer ownership workflows;
- permanent differential compatibility evidence from a deployed Jenkins instance;
- broader container runtime, migration, platform, observability, and release packaging coverage.
Read ROADMAP.md before treating a partial or experimental slice as production-ready.
The most useful contributions are reproducible and focused:
- Read CONTRIBUTING.md and the relevant roadmap gate.
- Run the local checks before opening an issue or pull request.
- Include the operating system, exact command, fixture/repository shape, and observed result.
- Contribute tests, fixtures, protocol evidence, documentation, or a small vertical slice with its boundary clearly labelled.
Please do not include secrets, private keys, provider tokens, real hostnames, customer repositories, or personal configuration in issues, screenshots, or pull requests.
Rivet is released under the Apache License 2.0.




