Skip to content

About

Open-source project management for continuous delivery teams. A Jira alternative built for small, frequent, safe releases. Works with or without coding agents.

Topics

Resources

Contributing

Security policy

Stars

1 star

Watchers

0 watching

Forks

Latest commit

 

History

180 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Mainline

Open-source project management for teams working with coding agents. Coding agents write fast. By default, two people see every story before it is released, and your team decides what correct means. Works the same without agents.

Mainline is project tooling for teams that practise continuous integration and continuous delivery. Work lives on a user story map instead of a backlog: activities across the top, releases sliced down in priority order. Each person has one active story at a time, enforced by the system. A team can raise its limit, and the change is an event everyone sees. Deploy and release are separate events with separate buttons, so nothing is called done until users have it. A story is released once two people have seen it, by working on it together or in a walkthrough. There are no story points, no sprints and no individual metrics. Every change is an immutable event and the whole team sees the same views: the map, flow, teamwork and inventory. The CI Monitor shows how long each branch has lived on every connected GitHub repo.

A story map in Mainline: activities across the top, steps beneath them, and stories under each step

Bring a Jira backlog in from a CSV export. It lands in the Ticket Museum, frozen, and you promote what's worth building onto the map one story at a time, rewritten with its acceptance scenarios. A specification or research comes in the same way: a model writes a Mainline file of small proposed stories, checked against a published schema, and each one waits in the museum for a person to promote it.

Everything a team has can be downloaded again as one zip, by any member: the stories in map order with a Gherkin feature file each, a CSV that Jira's importer reads, the museum, and the full record as JSON described by a published schema.

Importing a Jira CSV into the Ticket Museum and promoting one ticket onto the story map

Documentation and practice guides: https://mainline.dev/docs

Mainline has been in development since April 2026 in a private repository. This repository publishes the open-source core, exported from it since 7 November 2026. The hosted service at https://mainline.dev runs this same code.

Quick start

You need Docker with Compose.

git clone https://github.com/mainline-dev/mainline-core.git
cd mainline-core
docker compose up

It pulls the published image, seeds sample teams on its first start and prints a login link for each person in its log. Open one at http://localhost:3000 to look around. Every value in docker-compose.yml is a throwaway for a trial on your own machine.

To try it with your own team instead, sign up with an email address. The trial sends no mail, so it doesn't ask you to verify the address. The Google, GitHub and GitLab buttons appear once their variables hold real OAuth apps.

Self-host

docker-compose.selfhost.yml runs the app, a Sidekiq worker, Postgres and Redis with RACK_ENV=production. Every variable is required and has no default. Set them in your shell, or in a .env file next to the compose file, then:

docker compose -f docker-compose.selfhost.yml up -d

This pulls the published image, ghcr.io/mainline-dev/mainline-core. To run your own checkout instead, add --build.

Variable Purpose
POSTGRES_PASSWORD Password for the mainline database owner
MAINLINE_APP_USER_DATABASE_PASSWORD Password for the mainline_app role the app connects as (row-level security applies to it)
MAINLINE_SESSION_SECRET Session cookie secret, at least 64 random characters (openssl rand -hex 32)
LOCKBOX_MASTER_KEY 64 hex characters used to encrypt email addresses at rest (openssl rand -hex 32)
BASE_URL Public URL of the app, for example https://mainline.example.org
SIGNUPS open lets anyone sign up. Anything else lets in only the first person and people with an invite
MAINLINE_HOST Host name of the app, for example mainline.example.org
SMTP_HOST Mail server host name
SMTP_PORT Mail server port, usually 587
SMTP_USERNAME Mail server user name
SMTP_PASSWORD Mail server password
SMTP_TLS starttls (port 587) or tls (encrypted from the start, port 465)
MAIL_FROM Sender for all email, for example Mainline <noreply@example.org>
CI_MONITOR_GITHUB_APP_ID CI Monitor GitHub App ID, or disabled
CI_MONITOR_GITHUB_APP_SLUG CI Monitor GitHub App URL name, used for the install link, or disabled
CI_MONITOR_GITHUB_APP_CLIENT_ID CI Monitor GitHub App client ID, or disabled
CI_MONITOR_GITHUB_APP_CLIENT_SECRET CI Monitor GitHub App client secret, or disabled
CI_MONITOR_GITHUB_PRIVATE_KEY CI Monitor GitHub App private key (PEM), or disabled
CI_MONITOR_GITHUB_WEBHOOK_SECRET CI Monitor GitHub App webhook signing secret, or disabled
SENTRY_DSN Sentry DSN for error reports; a plain word such as disabled turns sending off
SENTRY_ENVIRONMENT Label on error reports, for example production

CI Monitor

The CI Monitor shows how long each branch has lived across your GitHub repositories. It needs a GitHub App of your own, held in the six CI_MONITOR_GITHUB_* variables, with its webhook sent to https://your-host/webhooks/github for branch creation and deletion, pushes and pull requests. To run without it, set all six to disabled: the CI Monitor page then says it isn't set up on this server. Disabling only some of them stops the app starting.

Sign-in providers

Email accounts always work. Each provider below adds its button to the login and sign-up pages once its client ID and secret hold a real OAuth app. Set both to disabled to leave that provider out.

Variable Purpose
GOOGLE_CLIENT_ID Google OAuth client ID, or disabled
GOOGLE_CLIENT_SECRET Google OAuth client secret, or disabled
GH_OAUTH_CLIENT_ID GitHub OAuth app client ID, or disabled
GH_OAUTH_CLIENT_SECRET GitHub OAuth app client secret, or disabled
GITLAB_CLIENT_ID GitLab application ID, or disabled
GITLAB_CLIENT_SECRET GitLab application secret, or disabled

HTTPS and public installs

The app listens on 127.0.0.1:3000 and needs HTTPS in front of it, because session cookies in production are HTTPS only. Caddy fetches a certificate for you. With your domain pointing at the server, install Caddy there and put this in its Caddyfile:

mainline.example.org {
    reverse_proxy 127.0.0.1:3000
}

Set BASE_URL to https://mainline.example.org and MAINLINE_HOST to mainline.example.org.

Set SIGNUPS=closed on anything reachable from the internet, and sign up as soon as it starts, because the first person to sign up gets in. After that, people need an invitation. New email accounts verify their address before creating a team, so SMTP has to work.

Upgrading

The image is published as latest and under each version, such as 0.3.2. CHANGELOG.md lists what changed. To move to the newest:

docker compose -f docker-compose.selfhost.yml pull
docker compose -f docker-compose.selfhost.yml up -d

Pull first: up alone keeps the image you already have. The app migrates its database when it starts. Take a backup before you upgrade.

Backups

Everything a team has is in the Postgres database. Redis holds only rate-limit counts and queued jobs.

docker compose -f docker-compose.selfhost.yml exec -T db pg_dump -U mainline mainline_production > mainline-backup.sql

Keep LOCKBOX_MASTER_KEY with the backup. Email addresses are encrypted with it, and a restore under another key cannot read them.

To restore on a new server, start the database alone, load the backup, then start the rest:

docker compose -f docker-compose.selfhost.yml up -d db
docker compose -f docker-compose.selfhost.yml exec -T db psql -U mainline -d mainline_production < mainline-backup.sql
docker compose -f docker-compose.selfhost.yml up -d

Working on the code

Contributors run the development stack, docker-compose.dev.yml, built from the checkout. Point compose at it in your shell, then start it:

export COMPOSE_FILE=docker-compose.dev.yml
docker compose up --build

For sample teams, seed its empty database. It writes a login link for each person to tmp/dev_seed.txt:

docker compose exec app bundle exec rake dev_seed

The suite runs inside Docker. With the development stack up:

scripts/test.sh

It migrates the test database, runs RuboCop, then the model and acceptance tests in Docker, then the browser tests on the host (they need Chrome).

Licence

Copyright (C) 2026 Kipple Pty Ltd.

GNU Affero General Public License v3.0. See LICENSE.

Mainline® is a registered trade mark of Kipple Pty Ltd. The AGPL covers this code, not the name: a fork must use a different name.

About

Open-source project management for continuous delivery teams. A Jira alternative built for small, frequent, safe releases. Works with or without coding agents.

Topics

Resources

Contributing

Security policy

Stars

1 star

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages