GROUPLAB DOWNLOAD
More

Research › How GroupLab is built

Nightly builds, from commit to installer

On this page

GroupLab project. Researched and written with Claude. Testing and data collection by the developer. Written 2026-09-22; the data is from 2026-09-22.

No figure: This article is about a build pipeline. There is nothing photographable in it, and a screenshot of a green tick would be decoration rather than evidence.

What we found

The hard parts are not building. They are making sure a build happens on a quiet day, that two pushes do not race, and that the release notes say something a shooter can use.

How sure we are

This describes the pipeline as it stands. The numbers in it, such as the run times, are from ordinary runs and are not benchmarks.

The shape of it#

A change is pushed. Tests run on Windows, macOS and Linux. If they all pass, a nightly build starts: it packages a Windows installer, signs a manifest saying what is in it, tags the commit, and publishes a release.

From push to downloadable installer is about half an hour, most of it tests.

That is the easy description. The interesting parts are the three things that went wrong.

Mistake one: nothing was built on a quiet day#

The build was triggered by a successful test run, which only happens when somebody pushes.

So a day with no pushes produced no build. So did a day whose runs were all canceled, which happens more than you would think. Anybody following the nightly train would see it simply stop, with no explanation, because nothing had failed.

There is now a scheduled run as well, once a day. It finds the newest commit on main that passed its tests, and builds that. If that commit already has a nightly it does nothing and says so, so a quiet day produces one build or none rather than a duplicate.

The general shape of the bug: a trigger that depends on activity is silent about inactivity. Anything that is supposed to happen regularly needs a clock somewhere, not only an event.

Mistake two: half the builds were canceling each other#

Pushes went to two branches at once, at the same commit. The test workflow ran twice on identical code, each run triggered a nightly, and a rule that keeps only the newest nightly canceled the first.

The logs looked alarming: on one day, half the nightly runs were cancellations. Nothing was broken and nothing was lost, because the run being canceled was building the same commit as the one replacing it. But it was impossible to tell that from the outside, and a log full of cancellations is a log nobody reads carefully.

Fixed by triggering on one branch only. The rule that keeps the newest push stays, because two quick pushes genuinely should not interleave.

Mistake three, and the one that mattered to people#

For a while the release notes were generated from commit subject lines. That produced entries like:

Entry 130 item 3.3: doubt travels with the number

That is written for the project's own log. Somebody deciding whether to install a build cannot use it at all.

Notes are now written by hand, as part of making the change, in a trailer on the commit:

Release-note: When GroupLab finds fewer holes than the shots you fired, it now
says so and lists the bulls with nothing on them, instead of reporting a clean
result.
Release-note-kind: fixed

Nothing is guessed from a subject line. A commit with nothing a person would notice, a test, a document, a build change, carries no trailer and appears only in a count at the end.

And the generator refuses bad notes, failing the build rather than publishing them. A note is rejected if it is only a reference, begins with "Entry", is shorter than eight words, or uses words that mean nothing to a shooter: folded, gate record, harness, fixture, refactor, and a list of others. That was tested against seven notes, six deliberately bad, and it refused all six for the right reason.

A refused note no longer costs a nightly, though. Seven nightlies were lost with every build fine, each because the checker refused one commit's note: a British spelling, a word only this project knows, a note saying nothing changed. Now the same check runs on every push, so a bad note shows red on its own commit and is put right there. If one still reaches the nightly, the build is published with short notes (the version, the commit and a link to the changes since the build before) and the run carries a warning, instead of no nightly at all.

Notes that say who helped#

The notes now also say which fixes came from people's error reports and which detection changes were made with targets people sent. A line reads, for example, "found from 5 automatic error reports" or "made with 48 targets people sent". Nobody is named, only a count and where the reports or targets came from. Each build's notes end with one line adding them up, and the releases page keeps the running total since the first build that counted them.

One platform does not hold up another#

The nightly is built for Windows, Linux, macOS, Android and the iPhone, and for a while one of them could hold the others back in two ways.

The first was a flaky test: one that fails now and then on one of the three systems the tests run on, though nothing is wrong with the change. One such failure stopped the whole nightly, the phones included. So a test that fails is now run once more, on its own, in the same job. If it passes the second time the build goes ahead, and the test is named as flaky, in the run and in a list the project reads; a test that needs its second run three times in a fortnight goes on the list of things to fix. A test that fails twice still stops everything, because that is what a real fault looks like.

The second was waiting. The desktop release waited for the Android build, which is allowed two hours, so a stuck Android build could hold the Windows installer back that long, though it could never stop it. Now the desktop files are published as soon as they are packaged, and the Android files join the same release when their own build finishes. The signed manifest is written again with them in it. It also lists, for each platform, the newest build that has a file for that platform, so a phone checking in the gap is pointed at the newest earlier build that has an Android file, and installs it, instead of finding nothing. Google Play is sent the bundle only once it is on the release.

A third thing held builds back: checks that no build needs. A nightly is built when the tests pass on Windows, Linux and macOS and the jobs that build what ships succeed. The website build and the ships list (the list that decides whether a nightly is built, which is not what a download contains) used to sit in the same group as the tests, so a failure in either meant no nightly: since 2026-09-28, 12 nightlies were lost to one of them alone, 11 to the website build and 1 to the ships list. Both now live in their own workflow, with the new release notes check. They still run on every push and still show red, but none of them decides whether GroupLab is built.

The rule that is easiest to get wrong#

A release note describes what somebody can do after installing the build, not what is in the repository.

One nightly told people GroupLab "now works out where your group actually landed before deciding which bull each shot belongs to". The code to do it existed. It was wired to nothing, and no screen could reach it. The sentence was untrue on the day it was published and nobody reading it could have known.

So: if the working part cannot be reached from any screen, the note says so in the same breath or there is no note. And a published release is never edited afterwards to cover it up; the correction goes in the next one, where the people who read the wrong one will see it.

What each build carries#

  • The installer, per-user, needing no administrator rights.
  • A manifest listing every file with its size and SHA-256, signed, so the updater can refuse a tampered download.
  • The release notes for that version only, meaning the changes since the previous published build. A canceled or skipped nightly never got a tag, so its changes roll into the next real one rather than vanishing.
  • The notes of the last several versions as well, so somebody who skipped five builds can be shown everything they missed rather than only the newest.

What this means#

If you follow the nightly train, three things follow from all this.

A gap in the build numbers is not a problem. Builds are produced on the days the application changed. A run of numbers with holes in it means work happened that does not reach you, not that something broke, and the releases page says so.

Read the notes and not the version. The notes for a build are written by the person making the change, in plain words, and the build fails rather than publish a note written for the project's own log. So if a note tells you nothing, that is a defect worth reporting, the same as a crash.

Do not trust a note that describes something you cannot find on a screen. That happened once here and it was caught afterwards rather than before. If you install a build for a feature the notes describe and cannot find it, say so: the note is the bug.

Sources#

  1. The workflow itself, with its reasoning in comments: .github/workflows/nightly.yml.
  2. The release-note rule and why it exists: CLAUDE.md, \"Release notes: say what changed, to a person who shoots\".
  3. The retry of a failed test and the late Android files: .github/workflows/ci.yml, scripts/test-retry.py and the android-files job in .github/workflows/nightly.yml, NOTES-FROM-PLANNING.md entry 450.