Fedora build system overview

Fedora Release Engineering takes package source code and turns it into installable releases : RPM repositories, ISO images, cloud images, and atomic desktops. This page shows how the pieces connect. For team contact and meetings, see Fedora Release Engineering.

Fedora CoreOS is built separately and is not part of this pipeline.

The build pipeline

Pungi and Koji talk to each other in both directions during a compose: Pungi pulls RPM tags from Koji, then submits image build jobs back for Koji to run. The numbered step table below explains each arrow.

Main pipeline (steps 1–5)

  +-------------+       +-------------+       +-------------+
  |  dist-git   |       |    Koji     |       |   Pungi     |
  |  src.fp.o   |       |  koji.fp.o  |       | pungi-fed.  |
  +------+------+       +------+------+       +------+------+
         |                     ^                     |
         |  (1) build RPMs     |  (3) image jobs     |
         +-------------------->+                     |
                               |  (2) RPM tags       |
                               +<--------------------+
                                                     |
                                               (4) assemble
                                                     v
                                               +-------------+
                                               |   compose   |
                                               |   output    |
                                               |  kojipkgs   |
                                               +------+------+
                                                      |
                                                (5) rsync
                                                      v
                                           dl.fedoraproject.org

(3) Kiwi / Lorax jobs run on Koji builders : Pungi submits them, Koji executes them.

Post-release (steps 6–8, stable releases only)

  +-------------+       +-------------+       +-------------+
  |    Koji     |       |    Bodhi    |       |   updates   |
  |   updates   |       | bodhi.fp.o  |       |    repos    |
  +-------------+       +-------------+       +------+------+
        (6) -----------------> (7) ----------------->|
                                                      |
                                                (8) after QA
                                                      v
                                           dl.fedoraproject.org

Step	What happens
(1)	Maintainers build from dist-git; Koji compiles and signs RPMs.
(2)	Pungi queries Koji for the latest tagged RPMs to include in the compose.
(3)	Pungi submits Kiwi / Lorax / OSTree image jobs to Koji; builders run them and return results.
(4)	Pungi assembles the full tree under kojipkgs.fedoraproject.org/compose/.
(5)	`nightly.sh` rsyncs the compose to dl.fedoraproject.org mirrors.
(6)–(8)	After GA, update builds go to Bodhi → `updates-testing` → stable `updates` → mirrors.

What each stage does

dist-git : where source lives

src.fedoraproject.org holds one git repo per Fedora package.
Maintainers commit spec files, patches, and source references here.
A build starts when someone runs fedpkg build or submits an SRPM to Koji.

Koji : where RPMs are built

koji.fedoraproject.org is the build farm.
Each build runs in a clean mock environment and produces signed RPMs.
Builds are tagged (for example f45, f45-updates) so Pungi knows which RPMs to include.
During a compose, Koji also runs the image build jobs that Pungi submits.
Source code: forge.fedoraproject.org/koji/koji.

Pungi : where release trees are composed

pungi-fedora is the best place to start if you want to understand Fedora composes. It holds the Fedora config for Pungi, the upstream compose tool.
Pungi pulls the latest RPMs from Koji, resolves dependencies, builds repo metadata, and submits image jobs to Koji.
Mostly what Pungi does is create jobs in Koji and wait for them to finish.
Rawhide composes run every day via nightly.sh, triggered by a cron job in Infra Ansible (05:15 UTC).
See Compose generation for logs, STATUS values, and debugging.

Kiwi / Lorax : where images are built

Most image jobs in Koji use Kiwi : live ISOs, cloud images, container disks, and ARM images.
Job recipes live in spin-kickstarts (Forge) and fedora-kiwi-descriptions (Pagure).
Lorax still builds some network-install and offline installer media.
Atomic desktops (Silverblue, Kinoite, etc.) are committed as OSTree refs during the compose.

compose output : where the results land

Finished composes are stored at kojipkgs.fedoraproject.org/compose/.
Rawhide: /compose/rawhide/, with latest-Fedora-Rawhide pointing at the newest one.
Each compose directory has a compose/ tree (the actual files), plus logs/ and a STATUS file.
Start with pungi.global.log : it logs Pungi’s run and links to the Koji tasks it kicked off.
After a successful Rawhide compose, nightly.sh rsyncs the tree to dl.fedoraproject.org for mirrors and users.

Bodhi : stable updates after release

bodhi.fedoraproject.org handles updates for released Fedora versions (steps 6–8 above).
Maintainers submit updates; they land in updates-testing first, then stable updates after QA approval.
Not part of the daily Rawhide compose : see Post-release.

Rawhide compose : daily automation

Every night the pipeline above runs on its own:

Cron fires on the compose host (configured in infra/ansible).
Script : nightly.sh clones releng tooling and runs pungi-koji.
Output : a new directory like Fedora-Rawhide-20260608.n.0 under /compose/rawhide/.
Logs : pungi.global.log shows progress; follow Koji task IDs from there.
STATUS : check the STATUS file: FINISHED is good, FINISHED_INCOMPLETE or FAILED needs investigation.
Email : a compose report goes to devel@lists.fedoraproject.org when the run completes.

Branched releases and Beta/Final candidates use the same tools but are triggered manually. See Fedora release process for that lifecycle.

Documentation

Fedora release process : branching, freezes, Go/No-Go, signing, mirrors, post-release.
Compose generation : Rawhide and release composes in detail.
Release schedule : milestone calendar.
Miscellaneous SOPs : signing, updates, package operations.
Fedora Release Engineering : team, meetings, contact.

Where to find things

What URL Notes

What	URL	Notes
Rawhide composes	/compose/rawhide	`latest-Fedora-Rawhide` = most recent
Compose logs	pungi.global.log	Trace Koji tasks from here
pungi-fedora	releng/pungi-fedora	Configs, nightly.sh, RC scripts
spin-kickstarts	releng/spin-kickstarts	Kiwi kickstarts and image defs
Koji	koji.fedoraproject.org	Builds, tasks, tags
Bodhi	bodhi.fedoraproject.org	Stable updates, updates-testing
RelEng tickets	releng/tickets	Compose requests, freeze exceptions
RelEng tooling	releng/tooling	Staging, signing, branching scripts
Infra Ansible	infra/ansible	Cron jobs, compose host config

Rawhide composes

/compose/rawhide

latest-Fedora-Rawhide = most recent

Compose logs

pungi.global.log

Trace Koji tasks from here

pungi-fedora

releng/pungi-fedora

Configs, nightly.sh, RC scripts

spin-kickstarts

releng/spin-kickstarts

Kiwi kickstarts and image defs