Skip to main content
For SDK maintainers and indexer operators who plan CI time and disk for the kit: how long each fetch step, CI job and make target took, and how much disk it used. Use the numbers to size runners and timeouts. Unless a section says otherwise, times were measured on one machine: 8 vCPUs, 46 GiB (2026-11-13) and 60 GiB (2026-11-14) RAM, Linux 6.12, local SSD, with other work running at the same time. Each section gives its date; the kit and the corpus have grown since the older measurements, so read those as orders of magnitude. Caches were warm (make fetch had run before) unless a row says otherwise, and every verify target ran under scripts/offline-run.sh with the network unreachable. On a CI runner with cold caches the fetch step takes longer; the rest is similar.

Fetch and build

Fetch parts (measured 2026-11-18)

make fetch is the sum of the parts below (scripts/fetch.sh lists them; make fetch FETCH_ONLY="PART..." fetches only some). Each was fetched cold into an empty home directory (kit cache, Go module cache, cargo registry), one part at a time, so a module set two parts share is counted in both. Together they are about 17 GB on disk, plus about 3.3 GB of container images.

Fetch targets and the build (measured 2026-11-14)

Each fetch target pulls only what one kind of user needs. “Cold” is a run into new, empty caches: the kit’s cache (XDRCHECK_CACHE), the Go module cache, the cargo registry, the pip cache and the adapters’ cache (XDG_CACHE_HOME). Container images were already present, so their download time is not in the cold times; their sizes are listed separately. The build dependencies (Python packages, crates, the Go modules of go/ and lint/) are common to every fetch target. make fetch-nightly (the nightly jobs’ extra driver packages and the stellar-core test image) is not included above. A cache that has been used for development for a while grows well beyond these sizes (old driver versions, scratch builds); deleting ~/.cache/xdrcheck and fetching again brings it back to them.

CI tiers: what each job runs and fetches

Two workflows, one make target per job. The build job builds the tools once; a job that needs them downloads them and names them on its make command line. Each job fetches only its parts and restores only its own caches; nothing else is downloaded, and no job downloads a data set. Jobs marked “no” under “needs build” need nothing the build job makes and start with it: the Rust tests build their own test binaries, and the other make targets build xdrcheck or xdrlint themselves. The runners are GitHub’s standard ones for this repository: 2 vCPUs, 7.7 GiB of memory and about 13 GB of free disk (35 GB after free-disk removes the preinstalled SDKs no target uses, about 75 s). Timeouts are sized for a cold cache (the first run after a lock file or Cargo.toml changes) at about twice the measured time; every cache a job builds in its own step is saved with if: always(), so a job that fails or times out still leaves it for the next run. Pull-request CI (.github/workflows/pr.yml): every pull request, every push to a branch other than main, and by hand. make verify-pr runs the same targets locally. P4a fetches the golden tree: the tests that run the default xdrcheck-corpus verify (tests/verify.rs, tests/render.rs) include the ag1 and ag3 checks, which read it (without it they fail, as on 2026-11-18). Without the stellar-core package the tests that run stellar-core (tests/gen*.rs) skip here; the full CI fetches it and sets XDRCHECK_REQUIRE_CORE=1, so they run there or fail. Each job appends the key lines of its own reports to its job summary (scripts/ci/job-summary.py): corpus verification and round-trip counts, golden agreement, replay result classes per wallet-backend commit, the conformance matrix and its cross-SDK divergences, linter results, the guide table check, the findings link check, mainnet tier coverage, test results. P13 run-summary prints one table of every job’s result with those key numbers. It also runs make acceptance-report-pr (make acceptance-report in the full CI) for the report files it uploads, and prints nothing from them. The driver groups, the same in both workflows (scripts/ci/check-workflows.sh fails when the groups of a workflow leave out a driver directory or one of its versions): a, Python (python@17.0.0,python@17.0.1); b, JavaScript and stellar-core (js,js16,core,stub); c, Go v0.7.x (go@v0.7.1,go@v0.7.2,go@v0.7.3); d, Go v0.8.0 and v0.9.0 and soroban-spec; e, Rust and XDR-JSON (rust,rs-xdr-json@30.0.0,rs-xdr-json@main). GitHub lets a run read the caches of its own branch and of main, so the pull-request jobs that share a cache with a full-CI job (same name and parts) start warm on a new branch once main has run; P8 and P9 fill their own small caches on a branch’s first run. Full CI (.github/workflows/full.yml): by hand (workflow_dispatch) and on release tags (v*); no schedule and no run on a push. make verify and make test run the same targets locally. Every job needs the build, and the unit jobs keep the old unit job’s tools and fetch parts. P14 to P16 are the full-size runs only this tier makes; the findings checks P12 and P12b read their reports. In a manual run P12b runs make verify-findings-acceptance PENDING_OK=1: when the only failure is rows awaiting finding review (they wait on the maintainers’ decisions) it passes with a warning annotation and the job summary line “N failure rows have no linked issue”; any other failure (a failure row with no finding ID and no pending entry, a stale or expired pending entry, a record not filed, a missing report, a tool error) fails it. A release tag (v*) runs the full CI without PENDING_OK, so there the pending rows fail P12b and block the release. make verify-goldens-nightly (stellar-core’s own test binary over the goldens) stays in the manual nightly-goldens workflow: its test-binary part took 20 min 38 s on 8 CPUs (2026-11-13), too long for this tier on 2 CPUs.

CI job times

On GitHub and on two pinned CPUs (measured 2026-11-19)

The first runs of both tiers on GitHub (2026-11-18) and runs on this machine pinned to two CPUs (taskset), the size of a GitHub runner, with the driver package caches copied without their build outputs (so every driver is built, as in CI). “Cold”: no cargo or Go build cache; “warm”: the job’s caches from an earlier run. The pull-request CI’s longest path is P4a: about 24 minutes cold and 12 warm. The jobs that need the build finish by about 13 minutes (build, then guide, then findings and the run summary, which wait for every job). So the pull-request CI takes about 15 minutes warm and about 25 minutes cold. Before the split, the pull-request run took 47 minutes and its unit job hit its 45-minute limit. The full CI’s longest jobs are P4a (cargo test, binaries one after another: about 25 minutes cold) and P8 conformance (17 to 22 minutes). cargo test --locked --workspace on this machine, 8 vCPUs, test binaries one after another: 13 min 32 s with an unoptimised test build; 5 min 46 s after the test build optimises the dependencies (Cargo.toml [profile.dev.package."*"]). A cold test build with full debug information is 13 GB, which filled the first CI run’s disk; with line tables for the workspace’s crates and none for the dependencies it is 3 GB.

Both tiers emulated locally from cold caches (measured 2026-11-19)

make ci-local (scripts/ci/run-local.sh) ran every job of both workflows on this machine, not on GitHub: each job from a fresh clone, with an empty home holding only the fetch parts its setup declares, on 2 CPUs with 7 GiB, the workflow’s run lines as written, two jobs at a time. No cache is restored, so these are cold, first-run numbers; GitHub’s cache steps and the free-disk step are not emulated. “Disk” is the job directory’s peak size (clone, home, caches, build). (P4a ran at the next commit, after a corpus test fix; the other jobs at the commit before.) On GitHub, where jobs run side by side, the cold pull-request CI’s longest path is P4a, about 20 minutes, and the cold full CI’s is P0 then P4a, about 29 minutes, plus queueing. Warm caches shorten the fetch and build steps (the cargo and Go caches, the fetch output); the earlier estimates of about 15 and 25 minutes warm still stand, and have not been measured on GitHub since the split.

make verify and make verify-acceptance, target by target

Two runs on 8 CPUs, warm caches, every target with OFFLINE=1, other work running at the same time: make verify-acceptance on 2026-11-19 and make verify on 2026-11-13 (verify-conformance re-measured on 2026-11-14). In the 2026-11-19 run the corpus check failed on a mirror-map gap fixed since: a local-core entry missing from corpus/mirrors.json. Every other target passed, apart from verify-findings-acceptance, which fails by design while rows await a finding review. The stellar-core tests of the full CI’s P4a (XDRCHECK_REQUIRE_CORE=1 cargo test -p xdrcheck-corpus --test gen --test gen_features --test gen_soroban, offline): 2 min 1 s, six tests, none skipped. make fetch FETCH_ONLY=replay-etl into an empty kit cache (Go modules already downloaded): 24 s, 364 MB. The XDR-JSON converters’ comparison with the manifest (xdrcheck conform build --set json, then xdrcheck conform run --set json: the json level on rs-stellar-xdr 30.0.0 and main) is run by hand; no make target or CI job runs that set. Measured on 2 CPUs with its two drivers already built: 10 s, 1,468 cells, none unexpected. In CI it would first build both drivers, which P4c-e does in about 8 minutes, so it is not in the full CI.

Release dry run (measured 2026-11-19)

From a fresh clone of the commit, 4 CPUs, warm caches; what release.yml runs, published nowhere. make release measured earlier (2026-11-14, 8 CPUs, warm caches; both archive builds, the offline verify of both roots and the npm package check): 1 min 54 s. linux-arm64 needs an arm64 runner (the workflow’s second matrix row) and was not built here.

Cache budget (measured 2026-11-19)

GitHub keeps 10 GB of caches per repository and evicts the least recently used beyond that. After the first runs of both tiers the repository held 11.4 GB in 28 caches, about 3.3 GB of them stale keys of jobs since renamed. The driver jobs build their drivers in every run; their build outputs would add, uncompressed, about 0.4 GB per Go v0.7.x driver, 1.5 GB each for Go v0.8.0 and v0.9.0, 0.3 GB for Rust and soroban-spec and 0.6 GB per XDR-JSON version: about 6 GB. They are not cached: that would push the budget further over and evict the caches the longest jobs need. The full CI’s P18 mainnet caches the mainnet tier’s lake objects, about 1 GB that does not compress further (they are zstd already). Fetching them cold takes about 2 to 3 minutes from the public lake, but a cached copy keeps the check independent of the lake between runs and spares the lake 6,150 GETs per push. With the stale keys gone the live caches are about 8 GB, so the tier’s 1 GB keeps them under the 10 GB limit. The cache key is P18’s fetch key (the fetch scripts, pins and lock files), not corpus/mainnet/tier.jsonl: after a change of the tier, the restored cache serves the unchanged objects and the fetch step gets only the new ones.

Nightly targets (measured 2026-11-13)

The targets of the manual nightly-goldens workflow.