This article walks an organizer through the whole life of a competition: from creating the event in the site calendar and registering participants online, to refereeing the race on site and publishing the results. The whole process — from a few clicks in the browser to capturing times in the field — is linked into one chain, and internet is not required on race day.

The big picture

  1. The organizer adds the event to the calendar on the website.
  2. In a couple of clicks they enable registration (with or without approval) and accept participants online.
  3. Before the race they close registration and sync the final participant list to the judge's local computer.
  4. On site they referee the race with the timing suite (start-line registration, time capture, protocol calculation).
  5. The finished protocol is uploaded back to the website and visible to everyone — in real time if needed.

Each step in detail below.

Step 1. Creating the event and registration on the website

Add the competition to the calendar

Log in and open "Calendar → Submit competition". Fill in the title, discipline, date and location. Organizers and admins publish immediately; submissions from regular participants go through moderation.

Enable registration in a couple of clicks

On the competition page (as the organizer) there are registration settings. The key options:

  • Registration mode: "self only" (tied to the participant's account) or "free" (you can register any person — handy when a team captain or volunteer signs people up).
  • Approval: with approval (the organizer confirms each entry manually) or without (the participant is considered entered right away).
  • Registration deadline and participant limit.
  • Categories/groups (e.g. by age and gender) and the birth-date mode (year or full date).
  • Relay/teams with a cap on team size.

Entry-fee payment

Important: automatic online payment of the entry fee by the participant is not available yet. If fee collection is enabled, payment is confirmed manually by the organizer — with the "Mark paid" button in the participant list. In other words, the participant transfers the fee however you arrange (off-site) and you mark them as paid. This is on the roadmap, but for now it works exactly like that.

Accepting entries and managing participants

In the participant list the organizer sees every entry and can approve, reject (with a reason), mark as paid and delete records. The list can be exported (CSV) and shown to spectators. Display settings let you hide unpaid/unapproved entries until the start.

Closing registration before the start

Once the field is set (the deadline passed or you turned registration off), the participant list is fixed and ready to move to the judge's computer.

Step 2. Syncing participants to the judge's computer

Every competition has a timing-system token — visible on the competition page to the organizer/admin. With this token the judging programs talk to the site without a login/password.

In Start Protocol Maker open Settings → HTTP, enter the site URL and token — the app calls GET /api/v1/participants/?competition_token=<token> and fills the start list with the entered participants. After that everything runs locally; no more internet needed.

Step 3. Refereeing the race: the timing system

Now a suite of three desktop programs takes over (Python 3.14, cross-platform UI). They exchange simple text files (start protocol, group list, results), so they are easy to move between judges' laptops.

How a race runs

  1. Registration and bibs. In Start Protocol Maker mark who showed up and hand out bib numbers. Numbers can be assigned automatically ("Get number"); for an interval start you set the first number and the delay between participants in seconds.
  2. Start. Chronometer records the start time: individually, by group, or as a common mass start.
  3. Finish and laps. At the finish a judge taps the time for each participant. Multi-lap races are supported ("finish / nextLap" mode), as are several finish slots, a second finish post and disqualification (DSQ).
  4. Protocol. Finish Protocol Generator merges the start protocol and the timing, computes placings (laps, control points, DNF/DNS/DSQ) and produces a clean HTML protocol — both absolute and per-group.

Key features

  • On-site registration and bib assignment: manual entry and auto-numbering, groups/categories, interval start with a delay, time shift and stage number.
  • Flexible timing: individual, group and mass start; several finish slots; multi-lap races; a second finish post; DSQ.
  • Smart protocol calculation: sorting by laps and control points/segments, correct handling of DNF, DNS and disqualifications.
  • Branded protocols: HTML templates (neutral and club-specific), absolute and group standings.

Working without internet (offline)

There is often no internet at the start line — and that's fine. All three programs run locally: registration, timing and protocol generation use only files on the laptop. Talking to the website is optional: you pulled the participant list in advance and can upload protocols later. You can run an entire competition fully offline and publish the results in the evening.

Reliability and backups

Refereeing carries responsibility, and a laptop can freeze, run out of battery or get damaged. That is why almost every action is saved to disk:

  • Start Protocol Maker keeps a backup of the protocol (data/spm_backup.txt) and snapshots changes; on the next launch the state is restored automatically.
  • Chronometer writes a timestamped snapshot to the temp/ folder (temp/stc<time>.txt) after almost every time capture. Auto-backup can be turned off with the "Disable backup" checkbox.

The practical upshot: even if the laptop is almost completely destroyed but the hard drive survives, you can recover most of the results from these snapshots and rebuild the protocol.

Publishing results back to the website

The finished protocol returns to the site. In Finish Protocol Generator the Upload button sends the HTML protocol to POST /api/v1/protocols/upload/ (multipart, with the same competition token and an is_live flag). The site stores the protocol and shows it on the competition page. In "live" mode it can be refreshed during the race so spectators see results in real time. An FTP upload is available as an alternative.

Installing the judging programs (quick)

All three are installed the same way. You need Git, Python 3.14 and Poetry.

First — Python 3.14 and Poetry:

# macOS
brew install git python@3.14 pipx && pipx ensurepath && pipx install poetry

# Linux (Ubuntu/Debian)
sudo apt install git && sudo add-apt-repository ppa:deadsnakes/ppa && sudo apt update && sudo apt install python3.14 python3.14-venv
pip3 install pipx && pipx ensurepath && pipx install poetry

# Windows (PowerShell): install Git and Python 3.14 (check "Add Python to PATH"), then:
pip install pipx; pipx ensurepath; pipx install poetry

Install and run each program (Start Protocol Maker shown — swap the URL and folder for the others):

git clone https://github.com/dchernykh1984/StartProtocolMakerPython.git
cd StartProtocolMakerPython
poetry config virtualenvs.in-project true
poetry install --no-root
poetry run python -m app.main

Likewise: https://github.com/dchernykh1984/ChronometerPython.git (Chronometer) and https://github.com/dchernykh1984/FinishProtocolGeneratorPython.git (Finish Protocol Generator).

For macOS there are prebuilt application bundles (.app) you can launch with a double click, without a terminal.

Room to extend

The system is open source and modular, so it is easy to adapt:

  • Your own protocol templates — club/federation branding is a separate HTML template, no change to the calculation logic.
  • New upload formats — besides HTTP to the site there is FTP; by analogy you can add connectors to other platforms.
  • New participant sources and start-protocol formats — the file format is simple text.
  • Calculation logic (laps, control points, scoring) lives in a separate module and extends to non-standard race formats.

Repositories

*This description is based on the source code of the website and the judging projects as of June 2026. For exact installation steps and current capabilities, see the README of each repository.*