Stop debugging your pipeline. Start shipping your code.

Containerized CI/CD pipelines defined in Go — identical builds on your laptop and in CI.

Get Started  •  See the Difference  •  Ecosystem  •  Technical Deep Dive

Every team hits the same wall. The build passes on your laptop but breaks in CI. A new developer joins and loses a day setting up their environment. A silent version mismatch ships a broken artifact to production.

You end up debugging your pipeline instead of building your product.

ContainifyCI eliminates this entire class of problems. Define your pipeline in Go, run it in containers, and get identical results everywhere — your machine, your teammate's machine, and CI.

engine-ci run

One command. No YAML. No drift. No surprises.

Builds that never drift — Containers lock down every tool version. The "but it works on my laptop" conversation is over.

Onboard in minutes, not days — New team members run engine-ci run and get the exact same build as everyone else. No setup wikis. No tribal knowledge.

One tool for every language — Go, Java, Python, and more through a modular extension system. Your team learns one workflow regardless of the stack.

Security built in, not bolted on — Container image scanning, secret management, and automated dependency updates are part of the pipeline — not afterthoughts.

Fast by default — Build steps run in parallel where possible. No configuration needed — ContainifyCI figures out what can run concurrently.

No vendor lock-in — Works with Docker and Podman. Runs in GitHub Actions, GitLab CI, or any environment with a container runtime. Your pipeline is yours.

# 1. Install
go install github.com/containifyci/engine-ci@latest

# 2. Initialize your project
engine-ci init

# 3. Build — same result everywhere
engine-ci run

engine-ci init creates a .containifyci/containifyci.go file — your entire build pipeline in a single Go file that you can read, test, and version-control like any other code.

Here's how dunebot — a real ContainifyCI project — defines its entire build and CI pipeline.

1. Define your build — .containifyci/containifyci.go

package main

import (
    "os"

    "github.com/containifyci/engine-ci/client/pkg/build"
    "github.com/containifyci/engine-ci/protos2"
)

func main() {
    os.Chdir("../")
    opts := build.NewGoServiceBuild("dunebot")
    opts.Application = "dunebot"
    opts.File = "main.go"
    opts.Properties = map[string]*build.ListValue{
        "goreleaser": build.NewList("true"),
    }
    build.Serve(opts)
}

That's the entire build definition. Linting, testing, building, container image scanning, and release automation — all handled by engine-ci.

2. Wire it into GitHub Actions — .github/workflows/pull-request.yaml

name: Pull Request
on:
  pull_request:
    branches: [main]

jobs:
  build:
    name: Build
    uses: containifyci/.github/.github/workflows/pull-request.yml@v1
    secrets: inherit

3. Add a release workflow — .github/workflows/release.yaml

name: Release
on:
  push:
    branches: [main]
    paths-ignore: ['.github/**']

jobs:
  build-and-release:
    uses: containifyci/.github/.github/workflows/release.yml@v1
    secrets: inherit

That's it. One Go file for your build logic. Two tiny YAML files to connect it to GitHub Actions. The same engine-ci run command works locally and in CI — no divergence, no surprises.

See the full working example at containifyci/dunebot/.github/workflows

ContainifyCI is more than a build engine. It's a growing toolkit for modern CI/CD.

Your code (.containifyci/containifyci.go)
        |
        v
   engine-ci CLI  ──>  Compiles to single binary
        |
        v
  Container runtime (Docker / Podman)
        |
        v
  Isolated build steps with pinned tool versions

ContainifyCI is open-source under the Apache License 2.0. We welcome every kind of contribution.

Use it — Try engine-ci on your project and tell us what breaks. Fix it — Found a bug? PRs are always welcome. Extend it — Build a language extension and share it with the community. Talk about it — Open issues, start discussions, share your experience.

github.com/containifyci

Let's make CI/CD better, together.