Appearance
Multi-stage events (carnivals)
Audience: Event organisers and timing operators running a competition scored across more than one day or race.
A multi-stage event is one competition decided over several races — an Easter 3 Days, a summer carnival, a two-race sprint weekend, a winter league. Manager models it as a container that references two or more ordinary events as its stages. Each stage is a completely normal meshO Manager event: it has its own classes, courses, competitors, start times, card downloads and results, and it runs on the day exactly as a standalone event does. The container adds what a carnival needs on top — matching each runner across the stages, combining their results into overall standings, and generating chasing starts for a later stage.
Are multi-day events a separate kind of event? No — and that is the whole design. There is no "multi-day event type" to choose at creation and no separate mode to run the day in. Every stage is an ordinary event, so everything you already know still applies; the container sits above them and is the only new thing to learn.
The vocabulary
| Term | What it means |
|---|---|
| Multi-stage event | The container: the carnival as a whole. Appears as one row on the Events page. |
| Stage | One race of the carnival, numbered from 1. Each stage is an ordinary event (or a placeholder for one that doesn't exist yet). |
| Placeholder stage | A stage you have declared but whose event doesn't exist yet — a planned day. |
| Standing | One competitor's combined result across the stages: their per-stage contributions, a total, and a position. |
| Identity | One person, matched across the stages. Two stage entries that are the same runner share one identity, and therefore one standing. |
| Scoring method | How a stage result becomes a number to combine — total time, points, a place→points table, a formula of your own, and more. |
| Chasing start | A start list for a later stage where each competitor starts at their deficit behind the leader, so the first across the line wins. Also called a pursuit start. |
Creating a carnival
From scratch
Click New event on the Events page — and, if you have Eventor configured, Create manually…. The dialog offers three cards — Individual, Relay and Multi-stage. Above the cards the dialog asks for the competition's name and its date, both pre-filled. Choose Multi-stage, and the card itself asks you for one thing only:
| Field | What it does |
|---|---|
| Kind | Carnival — stages scored and combined into overall standings, which is everything this page describes. Or Knock-out — rounds whose field comes from the round before, described on Knock-out competitions. Chosen once: it cannot be changed after the container is created. |
Click Create. Before anything is made, Manager says "Multi-stage events are experimental": they are still being finished, so check a carnival or knock-out carefully before you publish anything from it. Click Continue and Manager makes a Carnival under the name you gave it, with three placeholder stages on consecutive days from the date you chose, and opens it at its overview. (A Knock-out gets no placeholder stages — its rounds are created from a template instead.)
Why it doesn't ask for a stage count. A number of stages chosen before the competition exists is a guess you revise anyway, so the dialog seeds three and gets out of your way. Add, remove and re-date stages on the Stages tab, where you can also rename the carnival if the name you gave it turns out wrong. Nothing seeded here is fixed.
From Eventor
An Eventor event that has several races (Eventor's own multi-day forms) is imported as a carnival in one step, and you don't have to say so: click New event → Import from Eventor, pick the event, and Manager tells you underneath the list that Eventor holds several races for it and that it will be created as a multi-stage event. Click Create event (and Continue past the experimental notice) and it creates the container — named after the Eventor event — and imports one meshO event per Eventor race, splitting the entries and the start times by race and attaching each as a stage. The summary lists each stage with its classes and competitors, and Open takes you to the carnival.
Only carnivals arrive this way. A knock-out's rounds come from a template rather than from an entry list, so it is always created manually.
An Eventor event with only one race is never offered as a carnival: it imports as an ordinary event, Individual or Relay. A multi-day relay also arrives as an ordinary relay event — see Not yet supported.
Re-importing entries into one stage later (Linked Event in its Import dialog) brings in only that stage's race — its own entrants and start times, not the whole carnival's.
From events you have already created
If the events already exist — you set up each day separately, or a previous day has already been run — create the container as above and then attach each event to a stage on the Stages tab. Attaching changes nothing about the event itself; it only records that it belongs to this carnival.
Where a carnival appears on the Events page
A multi-stage event renders as one row, with its stages nested under it:
▾ Australian 3 Days 2027 Multi-stage · 3 stages
Stage 1 — Prologue Fri 26 Mar Complete
Stage 2 Sat 27 Mar ● Live
Stage 3 — Chase Sun 28 Mar Upcoming- The group is collapsed by default, and expanded automatically when one of its stages is live or dated today.
- Clicking the group header opens the carnival's overview.
- Clicking a stage row opens that stage's event, exactly as clicking any event card does. Everything about running a stage is unchanged.
- A stage never also appears as a standalone row — an event belongs to at most one carnival.
- The group is Upcoming if any of its stages is upcoming, otherwise History — so a carnival half-run stays in front of you rather than disappearing into History.
- A badge on the header shows how many cross-stage identities are waiting for a decision (see Matching competitors).
Inside a stage, the app bar shows a breadcrumb back to the carnival, plus previous/next stage navigation.
The carnival overview
Opening the group header lands you on the overview — on the Stages tab, which is where a carnival's next move usually is. There are six tabs:
| Tab | What it's for |
|---|---|
| Stages | The stage list — name the carnival, add, remove, reorder, create or attach events, counting flags and weights. |
| Standings | The overall result: position, per-stage columns, total, status. Live. |
| Scoring | How stage results combine: method, best-N, tie-breaks, per-class overrides. |
| Chasing starts | Generate a chasing (pursuit) start into a later stage. |
| Competitors | Cross-stage identity: who is the same person in which stages — and class linking. |
| History | Everything done to the carnival, with its time: stages added, removed or re-ordered, events attached or detached, identities linked or split, stages dropped for a competitor, chasing starts written, scoring changed. |
A knock-out competition shows a different set — Bracket, Rounds, Classification, Stages and History. See Knock-out competitions.
The Stages tab
This is where you name the carnival and lay out its stages. A Name field sits above the table — the carnival's own name, seeded from the day of the week when you created it, so this is usually the first thing you change.
Below it, one row per stage, in order:
| Column | What it does |
|---|---|
| Stage | The stage number, 1..N. Always contiguous — removing a stage renumbers the rest. |
| Event | The stage's event, as a link. A stage with no event yet reads Not yet created. |
| Date | The event's date once the event exists; the planned date — which you can edit in place — while it's a placeholder. |
| Event data | What's in the stage event so far: how many classes, courses and competitors (hover for the words). A zero shows in a warning colour — a stage with no classes, courses or entries is the one to notice. Empty for a stage with no event. |
| Counts | Whether this stage counts toward the standings. Off for a training race, a come-and-try, or a prologue that only seeds the chase. Its results still show against each competitor, marked as not counting. |
| Weight | Multiplies this stage's score before the stages are combined — 1 is ordinary, 2 counts it double, 0.5 half, and 0 makes it score nothing while still being a stage everyone must run. It is applied before best-N chooses what to drop, so it decides what gets dropped too. |
| Optional | When on, a competitor who missed this stage isn't penalised for it. |
Each of the three scoring columns has an ⓘ explaining it. Weight and Optional are greyed out on a stage that doesn't count — they keep their values and come back when you tick Counts again. | Actions | The ⋮ menu — see below. |
A stage has no name of its own. There is no Name column: a stage is identified by its number, and by the name of the event attached to it. If you want stage 1 to read Prologue, name its event Prologue. The carnival's own name is the field above the table.
Add stage at the foot of the table adds another placeholder.
The ⋮ menu on each row offers:
- Move up / Move down — reorder, which renumbers.
- Create event — creates a new event pre-filled from the stage's planned date and attaches it. The quickest route from "we're planning three days" to three real events. Only offered while the stage has no event.
- Use existing event… — attaches an event you have already created. Only events that aren't already part of some carnival are offered, because an event belongs to at most one container.
- Detach event — removes the link but leaves the event alone: it becomes a standalone event again, with all its data. Removing a stage, or deleting the whole container, does the same — stage events are never deleted with the carnival.
- Copy entries from… — see below. Offered once this stage has an event and another stage does too.
- Remove stage.
Copy entries from another stage
Most carnivals run the same field every day, and typing it in twice is nobody's idea of a good time. Copy entries from… brings another stage's classes and entered competitors across into this one, choosing whether to copy classes, competitors, or both.
What travels is the entry and nothing else: names, clubs, cards and bibs — no times, no statuses, no results. A class of the same name is reused rather than duplicated, and anyone already entered in this stage is left alone, so running it twice is safe and the confirmation tells you how much was already there as well as how much was added.
One catch it warns you about: a competitor has to be in a class, so if you copy competitors without their classes, anyone whose class isn't in this stage yet is left behind. Copy the classes too.
Relay classes are not copied. A relay is a roster of teams, so the copy leaves its classes behind and says how many; build those on the stage's Relay teams page.
Tip: To give each runner the same bib on every day, allocate the numbers across all the stages at once — see Bib numbers. To seed every day's draw from the IOF world ranking in one go, see Seeding from the IOF world ranking.
Note: A list of more than ten stages draws an advisory note. There's no hard limit, but a long list is far more often a mistake than a real carnival.
The tab also raises advisory notes when the stage flags and the scoring settings disagree — for example, optional stages under a summed, lower-is-better method that counts every stage (skipping an optional stage would help a competitor), a How many stages count that keeps as many stages as count (so nothing is ever dropped), or no stage counting at all.
Warning: A stage whose event is a different type from the rest — a relay day among individual days, say — is allowed, and the tab says so in a warning. Its individual classes are scored as usual, but relay team classes are never ranked in the overall standings, so a relay stage contributes nothing to them.
Matching competitors across the stages
Each stage has its own competitor list, with its own competitor records. Before anything can be combined, Manager has to work out who is the same person in which stages. This is the part of a carnival that most often goes wrong in practice, so it is explicit and reviewable rather than hidden.
How Manager matches
Signals are tried strongest first. The top four match automatically:
| Rank | Signal | Notes |
|---|---|---|
| 1 | Registry ID | The Competitor Registry entry behind the entry. The strongest signal available. |
| 2 | IOF ID | The competitor's IOF person ID, where the entries carry one. |
| 3 | Registration number | The external entry id (e.g. Eventor's), with its provider. |
| 4 | Name and club | Used only when it isn't ambiguous — a name+club that names two people in the same stage is twins (or a duplicate entry), so it isn't used to merge them at all. |
Then two weaker signals:
| Rank | Signal | Notes |
|---|---|---|
| 5 | Name only | Also matched automatically, but only when no club contradicts it — that is, when at most one of the entries records a club at all. A field entered by hand often carries no ids and no club, and leaving those runners unmatched isn't a neutral outcome: they drop silently out of the standings and out of any chase seeded from them. Where the same name appears under two different clubs, the merge is not made — it becomes a Suggested identity for you to decide. |
| 6 | Card number | Off by default, and only ever a suggestion. Hire cards are reassigned between stages, so card matching can merge two different people into one standing. Turn on Match on card number only when everyone uses their own card. |
What this means in practice. Two entries with the same name and nothing else to go on will be merged for you. That is deliberate — the alternative loses people from the results — but it is the one automatic merge that can be wrong on a large field with common names. Two runners called Sam Taylor, both entered by hand with no club, become one standing. Check the Matched panel for a carnival where hand entry is the norm; splitting them takes one click.
The Competitors tab
Identities are grouped into four panels:
- Matched — automatically matched on a strong signal. Each shows what it matched on. Use Split off this stage if it's really two people.
- Suggested — a weak signal suggests these are the same person. Same person as … (naming the other entry, its club and stages) merges them; leave them separate by doing nothing.
- Ambiguous — two competitors of one stage resolved to the same person. Their standing is blocked until you decide, because publishing a total for someone who might be two people is worse than publishing nothing for them.
- One stage only — appears in a single stage. Normal for a late entry or someone running one day.
Confirming a suggestion or splitting an identity is remembered: a split is a targeted rejection of that particular grouping, so rejecting a name-based suggestion doesn't stop the same runner being matched by their registry ID later. A rejected suggestion isn't offered again.
Changed your mind about a split? The entry you split off carries a Rejoin action. Rejoining records the two as one person again — in the standings, and in every chase seeded from them. So a split made under time pressure is not a one-way door.
Where an identity was matched only by name, Manager notes that adding the competitor to the Competitor Registry would match them by ID at future events instead of by name — the durable fix.
The switch at the top of the tab is Match on card number (rank 6 above), with its warning about hire cards. Refresh re-runs the matching, and once nothing is left to decide the tab says so.
Dropping a stage for one competitor
Sometimes a stage cannot be made right. Day 1's timing data is lost for one runner, the jury agrees to drop the day for them, and there is nothing to correct in the stage itself — the stage is fine, it just should not count for that person.
Each stage cell on this tab carries a Drop this stage for this competitor button. It asks for a reason, which is required and is recorded with the decision, then:
- The stage's own result is left exactly as it is — the day's own results list is unchanged, and so is every export of it.
- It stops counting towards that competitor's overall standing, which shows the stage struck through and labelled Excluded for this competitor by the operator.
- The cell here shows the time struck through too, with your reason on the tooltip.
Count this stage again puts it back, and needs no reason.
This is the only way to change what a stage contributes without changing the stage. There is deliberately no way to type in a time or a score for a stage somebody has no result in — that would make the standing impossible to reproduce from the stages, which is the guarantee the whole carnival rests on.
Classes across stages
Classes are linked between stages by exact name — M21A in stage 1 is M21A in stage 2. This is the same rule most timing software uses, and it is what makes the standings work without you configuring anything.
Keep class names identical across your stages. A class named M21A on day 1 and M21 A on day 2 is two different classes, and everybody in it will fall out of the combined standings. Renaming the class on the later stage is the fix.
When a competitor's class genuinely differs between stages — they moved up an age class between days, or were entered in the wrong one — they are listed under their latest class and are not ranked in the earlier one. This is deliberate: a total combining two different classes is a wrong result nobody notices.
Both can be changed in the Class linking section, below the identity panels on the Competitors tab:
- When a competitor changes class — Keep the new class, no standing (the default: listed under their latest class, never ranked) or Keep the new class, still ranked (ranked under their latest class, with their earlier stages counted).
- Class name mappings — each row maps one stage's class name onto the linked class the standings use: pick the Stage, the Class name in that stage and the Linked class. This is how
M21 Aon day 2 joinsM21A. Classes with the same name in every stage need no mapping.
Changes here are saved as you make them; a row is saved once both sides are filled in.
Scoring
The Scoring tab decides how a stage result becomes a number, and how the numbers combine.
Choosing a method
Thirteen built-in methods are offered. The Method list is alphabetical, with your own custom methods among them, and the selected method's one-line description shows beneath it:
| Method | What it scores |
|---|---|
| Total time (default) | Adds up the stage times. The fastest total wins. |
| Total time behind | Adds up how far behind each stage winner a competitor finished, so a long stage cannot dominate the total just by being long. |
| Points, scaled ratio (Scottish) | The winner scores the points scale you set and everyone else scores in proportion: the scale × the winner's time ÷ their own. A scale of 1000 is the Scottish method; 800 and 1200 are also in use. |
| Standard (z-score) | Measures a run against the spread of the field: 1000 points for an average time, and 200 more for each standard deviation faster. Comparable across very different courses. |
| Percent of winner | The winner scores 100; a score is that competitor's percentage of the winning run. |
| Percent behind | The winner scores the full points scale, and every one percent behind the winner costs a point. |
| Kilometre rate | The pace each competitor ran: stage time divided by course length, in minutes per kilometre. A stage with no course length scores nothing. |
| Points from par (Welsh) | Scores against par, the mean time of the leading half of the field: par is 1250 points, and each one percent from par is worth six. |
| Median-normalised | Measured against the median time rather than the winner, so one exceptional run does not compress everybody else. A median run scores the full points scale. |
| Points less minutes behind (Danish) | The winner scores the full points scale, and each whole minute behind costs one point. Runners inside the same minute tie. |
| Fixed place points (Brazilian) | Scores by place from an F1-style table: 100 for the win, then 85, 75, 68 and so on down to 1 point for 35th. |
| Reverse place | Scores by place counted from the back: the winner scores the number of starters, and last place still scores 1. |
| Participation | Every eligible finish scores the same, whatever the time. |
Where is "Place points"? Scoring from a place→points table is not offered as a built-in, because a built-in has no table to read — it would score everybody nothing. Author one as a custom method of the Place table kind instead; see below.
Whichever you pick, the rest of the tab is the same:
- Points scale — the points a stage winner scores, for the methods that use one. 1000 is usual; 800 and 1200 are also in use.
- Combine stages by — Sum, Average, Best stage, or Count of stages.
- How many stages count — All stages, Drop worst, Drop two worst, Only best counts or Best two count (a choice is left out when it can't apply to this many stages). The dropped stage stays visible in the standings, struck through and labelled Dropped as the worst counting stage — never silently hidden.
- Rounding (Round, Truncate or Round up) and Decimals — applied once, to the final total, not stage by stage.
- Tie-breaks — applied in order until one separates the tied competitors: better final stage, better single stage, count back by stage, or share the position.
- Per-class scoring — Add a class override to give one class its own method and How many stages count; anything left on Inherit follows the carnival's setting. Carnivals commonly score elite classes on total time and junior classes on points with a dropped worst stage.
Changes on this tab take effect when you press Save; Cancel throws them away.
Custom methods
If none of the built-ins is your federation's rule, build your own on the Scoring tab with Add custom, beside the method list (Edit changes the selected custom method). Give it a Name, an optional Description and a Kind. Two kinds:
Formula — an expression evaluated per competitor per stage, e.g. maxPoints * winnerTime / time. Variables cover the competitor's own run (time, place), the stage's field (winnerTime, meanTime, medianTime, stdDev, parTime, starters, finishers), the course (courseLengthKm) and the carnival (stageNumber, stageCount, maxPoints). Times are in seconds. The functions are min, max, abs, round, floor, ceil, sqrt, pow, clamp and if. The editor lists them all, inserts them on click, validates as you type, and points at the exact character where an expression is wrong.
Place table — points per finishing place: rows of from place, to place, points, plus points for places beyond the table. A fill-down helper builds long tables quickly. This is how you score from a place→points table, including the Nordic and club-league tables.
Tied places. Shared places decides how runners tied on a stage score: Average the tied places (the default — two runners tied for 3rd each score the mean of 3rd and 4th place's points), Give every tied runner the highest, or Give every tied runner the lowest.
Both show a live preview against your carnival's real results while you edit, so you can see what the rule does before applying it. Deleting a custom method only takes it out of the list: a carnival already scored by it keeps its own copy, so no standings change.
Note: A method is snapshotted into the carnival when you select it. Editing the global method afterwards does not silently change published standings — the carnival tells you the method has changed and offers Update to latest when you're ready. Renaming a method isn't a scoring change.
Standings
The Standings tab is the overall result.
| Column | What it shows |
|---|---|
| Pos | Overall position. Blank when the competitor isn't ranked. |
| Competitor / Club | The identity's name and club. |
| Stage 1..N | That stage's contribution. A stage that didn't count is struck through, with a tooltip saying why. |
| Total | The combined total, with * while it's provisional. |
| Status | Complete, Provisional, Incomplete or Not ranked. |
Standings update live. A card downloaded at stage 3 updates the overall within about half a second — nothing to press, no recompute step in the normal flow. (There is a Recompute action, under the Actions menu, for the rare case where you want to force it — for example straight after changing something outside Manager.)
Choosing what to show
The Class selector at the top offers more than one class at a time:
- A single class — the ordinary view, one class ranked on its own.
- All classes — every class, one after another.
- Combined (all classes) and Combined (selected classes) — one ranking pooled across classes. This is what you want for an overall carnival prize, or a club competition ranked across age classes.
Combining is only offered when it is honest. If the classes aren't all scored the same way, or the method's scores don't mean the same thing from one class to another — total time across a 3 km and a 9 km course, say — Manager refuses rather than producing a league table of unlike things. Scoring the classes on a method that normalises across courses (Standard z-score, Percent of winner, Median-normalised) is what makes a combined ranking meaningful.
Two more controls sit alongside: Show (all, or the top N) and Times (show or hide the per-stage columns), for cutting the table down to something you can read on a screen or hand to a prize-giving.
Warnings you might see
Two banners appear above the table when something is wrong, and both mean the standings in front of you are not the whole truth:
- A stage could not be read. "Stage N could not be read, so these standings are missing it." Usually the stage's event is open somewhere else — another Manager window, another operator's machine. Close it, then Recompute.
- The scoring method isn't in this build. "This carnival is scored by X, which this version of meshO does not have." No standings are produced at all, deliberately — scoring by a different method would be worse than scoring by none. Choose a method on the Scoring tab, or update Manager.
Why a stage didn't count
The tooltip on a struck-through cell always names the reason:
| Reason | Meaning |
|---|---|
| This stage does not count toward the standings | The stage's Counts flag is off. |
| Dropped as the worst counting stage | Best-N is in force and this was the dropped stage. |
| The stage result cannot be counted | The stage status can't produce a result — MP, DNF, DSQ, over time, or an OK with no running time. |
| No result in this stage | Didn't start, didn't enter, or hasn't finished yet. |
| Excluded for this competitor by the operator | You dropped this stage for this competitor — see Dropping a stage for one competitor. |
What the overall statuses mean
| Status | Meaning |
|---|---|
| Complete | Every required stage counted. A normal, final overall result. |
| Provisional | Something is still in progress or preliminary — a stage still running, or a preliminary (radio-derived) result. The total is real but may change; it carries *. |
| Incomplete | A required counting stage produced no countable result. Under a time-based method they have no overall time and no position — the standard carnival rule. Under a points method they still carry a total and a position; the missed stage scores zero. |
| Not ranked | Never rankable: an unresolved ambiguous identity, or a status like Out of Competition / No Timing. |
An optional stage forgives a missed stage entirely — no penalty and no Incomplete.
Chasing starts
A chasing (pursuit) start sets each competitor's start time in a later stage to their deficit behind the leader, so the finishing order across the line is the overall result. Generate it on the Chasing starts tab.
The settings are grouped into three sections.
Chase
| Setting | What it does |
|---|---|
| Chase into | The stage the start times are written into. |
| Standings after | Which stages the deficits come from — usually every stage before the target. |
| Classes | One class, or all of them. |
Start times
| Setting | What it does |
|---|---|
| Mode | Chase (leader first), Reversed chase (leader last), Seeded interval start (leader first) or Seeded interval start (leader last). |
| Leader starts at | The time of day the overall leader sets off. |
| Time scaling | Compresses the gaps — 0.5 halves every deficit. Chase modes only. |
| Round to (seconds) | Rounds the computed times. Chase modes only. |
| Maximum time after | The cutoff. Anyone further behind than this goes into the restart block. Chase modes only. |
| Start interval | The gap between starters. Seeded interval modes only — they have no cutoff and no restart block, so the whole class goes off in standing order from the first start. |
Restart block (chase modes only)
| Setting | What it does |
|---|---|
| Restart block begins | When the block sets off. |
| Restart block starts | At intervals, or All together — the mass restart most carnivals run for the competitors who are out of the chase. |
| Restart interval | How far apart its starters are, when starting at intervals. |
Preview shows the full plan before anything is written — each competitor's gap, current start time, new start time, and whether they're in the restart block. Apply to N competitors writes the times into the target stage's competitors as ordinary allocated start times, so everything downstream (start lists, exports, the start-time cascade, the audit trail) works with no special handling.
Points to know:
- The restart block catches everyone outside the cutoff, anyone unranked, and anyone with no standing at all (a late entry to the final stage). They start in standing order, at even intervals from the restart time or all together.
- Applying twice is safe. The second run writes nothing, because nothing changed. Regenerate freely after a correction.
- A competitor who already punched a start in the target stage is flagged in the preview.
- Competitors on identical computed times are left together. They are level on the standings, and separating them would be a handicap nobody raced for. There is no setting for this — the behaviour other software calls start pairwise is simply always on.
- Nobody entered in the target stage yet? The tab says so, and offers to copy the classes and entries from an earlier stage — the same Copy entries operation, from where you are already standing.
- Stage 1 can't be chased into — there are no standings before it.
- A competitor no longer entered in the target stage is skipped when the times are written, and the result says how many.
Points-based scoring cannot be chased
A chase is a race against a time gap, and a points method has none. If a class is scored on points, Manager refuses to build a chase for it and says so on that class's card: "{class} is scored on points, so there are no time gaps to chase. Score it on time to generate chasing starts." Other classes in the same carnival that are scored on time preview normally alongside it.
It is refused rather than quietly turned into something else. If it degenerated into an interval start, your first start, cutoff and scaling would all be silently ignored, and what came out would look like a chase that had gone wrong rather than a start list anyone chose. If an interval start in standings order is what you want, ask for it — that is the Seeded interval start mode, on a class scored by time.
Exporting a carnival
The Standings tab's Actions menu holds both exports, next to Recompute.
Overall standings as CSV — Export CSV. One row per competitor, one column per stage, plus the total. A stage that didn't count is bracketed rather than blanked, and a provisional total carries *, so the spreadsheet says the same thing the screen did. Export one class, or all of them.
Overall standings as PDF — Export PDF. The table as you have it on screen, laid out for printing or pinning up: whatever class or combined view you have selected, and whichever of the Show and Times options you have set. This is the one to reach for at prize-giving.
IOF XML — export a stage's results the usual way. When the event is a stage of a carnival, the file additionally carries the stage's raceNumber and each competitor's overall standing as an IOF OverallResult — the standard's own answer to multi-stage results, which makes the output consumable by SplitsBrowser, Eventor and Livelox with no bespoke format. A standalone event's export is unchanged.
The overall standing in the file is the standing as it stood after that stage, so exporting stage 2 during stage 3 doesn't mix in stage 3. A provisional standing is never written: as with any official results file, Manager stops and lists the unsettled results the file would rest on — here including those of earlier stages. If you publish anyway, those runners are written as they would be exported (no status as DNS, still on course or a radio-only finish as DNF), never as a stage still to come. A stage that couldn't be read, or that has no entries, still stops the export.
Live results, screens and splits work per stage exactly as they always do.
Running a stage
A stage runs exactly as a standalone event does — card download, radio punches, results, screens. One thing at the download desk is aware of the carnival: hire cards. When a runner on a hire card downloads at a stage and is entered in a later stage on the same card, the Collect hire items prompt leaves the card with them, and asks for it back after the last stage they carry it to. Whenever Manager can't be sure — not the same person, an Ambiguous identity, a later stage it can't read — it asks for the card back. Other hire items are asked for as usual.
A card number, class or club changed at the desk on one day doesn't reach the later days by itself, because each stage is its own event. The changes report carries the changes you pick into the stages still to come.
A worked carnival
A three-day Easter carnival, days 2 and 3 counting, day 3 a chase:
- New event → Multi-stage → Carnival. Name it, set its date to Good Friday, and Create. You get three placeholder stages on consecutive days from that date.
- Stages tab. Set each stage's planned date to Good Friday, Saturday, Sunday. Turn Counts off for the prologue if it only seeds the chase. Create event on each stage, or Use existing event to attach the events you've already built — naming those events Prologue, Middle and Chase is what puts those words on the stage rows.
- Set each stage up as an ordinary event — classes, courses, competitors, start times. Nothing carnival-specific here. If days 2 and 3 run the same field, Copy entries from… stage 1 rather than importing three times.
- Competitors tab, once at least two stages have entries. Work through Ambiguous first (they block standings), then Suggested. Aim for an empty badge.
- Scoring tab. Total time, summed, is the default and what most carnivals use. Set best-N, weights or per-class overrides if your rules call for them.
- Run stage 1 normally. The Standings tab fills in live.
- Run stage 2 normally.
- Chasing starts tab before stage 3: chase into stage 3, standings after stage 2, leader at 10:00, cutoff 30 minutes, restart block from 11:00. Preview, then Apply.
- Run stage 3. The finish order in each class is the overall result; the Standings tab confirms it.
- Export the standings as PDF for the prize-giving and CSV for the spreadsheet, and each stage's IOF XML for upload.
Not yet supported
- Knock-out scoring inside a carnival. A knock-out is its own kind of multi-stage event, not a scoring method — see Knock-out competitions.
- Relay carnivals. A multi-day relay isn't modelled — times carried forward between stages of a relay aren't computed. Individual stages of an ordinary relay event work normally. See Relay events.
- Creating a carnival from a multi-race IOF XML file. Import each race into its own stage event instead: when an entry list, start list or course file holds more than one race, the import stops and asks which race this event is.
- Editing race names and dates during the Eventor import. They're imported as Eventor has them; rename and re-date afterwards on the Stages tab.
- Team/patrol carnivals — a carnival of team events isn't modelled.
- Registry write-back — confirming an identity doesn't yet create or update the Competitor Registry entry for you.
- Near-miss names. Matching is exact. Andersson on day 1 and Anderson on day 2 become two One stage only identities with no suggestion, and the badge stays at zero. Look through that panel, and correct the spelling in one stage's event so the names match.
Common mistakes
- A competitor is missing from the standings entirely. They're probably in an Ambiguous identity, which blocks the standing until you decide. Check the Competitors tab — the badge on the group header counts these.
- Two people merged into one standing. Almost always card-number matching with hire cards. Turn Match on card number off, and split the identity.
- A total looks too short. Look at the struck-through stage cell — the tooltip names the reason (didn't count, dropped as worst, ineligible status, no result).
- Someone has no overall time at all. Under a time-based method, an Incomplete competitor has no total and no position by design. If your rules say otherwise, score on points — a missed stage then scores zero and they keep a position — or mark the stage Optional.
- The chase refused a class. That class is scored on points, so there are no time gaps to chase. Score it on time, or use the Seeded interval start mode instead.
- Everyone from one class dropped out of the standings. Check the class is named identically in every stage —
M21AandM21 Aare two different classes. Rename it, or map the names under Class linking. - Two people with the same name became one standing. Where there is nothing but a name to go on and no club contradicts it, Manager merges them. Split the identity on the Competitors tab; Rejoin puts it back if you were wrong.
- Editing the global scoring method didn't change the standings. Correct — the method is snapshotted when selected. Use Update to latest on the Scoring tab.
- A stage event vanished from the Events list. It's nested inside its carnival's row. Expand the group.
- Deleting the carnival didn't delete the events. Also correct — stage events survive as standalone events.
Related
- Creating an event — the New event dialog and event settings
- Importing event data — Eventor and IOF imports, including multi-race
- Start times and Drawing start times — the ordinary start-allocation routes
- Knock-out competitions — the other kind of multi-stage event: rounds whose fields are advanced from the round before, rather than stages added up
- Relay events — the other multi-part event shape
- Competitor Registry — the durable fix for cross-stage matching
- Hire items — a hire card kept across stages
- Bib numbers — one bib per runner across every day
- Changes report — carrying the desk's card and class changes into the later days
- Results and Exporting data
- Status and race time rules — the statuses behind stage eligibility