meshO Manager

Appearance

Drawing start times ​

Audience: Event organisers allocating individual start times to competitors.

The start draw is Manager's tool for turning a list of competitors into a start list — assigning each competitor a start time, spaced at a regular interval, in an order you choose: randomised, spread out or grouped by club, or seeded by ranking. It lives in the Starts section and produces each competitor's individual allocated start time.

This page covers how the draw is organised, how to configure it, how to run it, and how to fine-tune the result afterwards.

Note: The draw assigns individual start times. These sit at the top of the start time hierarchy, so a drawn start time overrides any class or event mass start for that competitor. If your event uses a single mass start instead of individual starts, you don't need the draw at all — set the mass start on the event or class and skip this page.

Where the start draw lives ​

Navigate to Starts in the side menu. The page has two tabs along the top:

  • Start list — the read-only, printable start list. This is what you publish and hand out. It shows the start times the draw has produced, grouped and sorted however you like, with PDF, IOF XML, Orienteering JSON, CSV, and print options. See the Start list tab below.
  • Manage starts — the draw tool itself. This is where you produce the start times that the Start list tab displays.

The rest of this page is about the Manage starts tab.

The core idea: lanes ​

The draw is organised into lanes. A lane is one course, and one course is one lane — the two are the same thing. Each lane is a single timeline of start slots, stepping from a first-start time by a fixed interval.

A few consequences follow from this:

  • Classes that share a course share a lane. They're laid out one after another as contiguous blocks down the lane's single timeline. You choose the order the blocks appear in.
  • No two competitors on the same course can get the same start time. Because each lane is one strictly increasing timeline, clashes on a course are impossible by construction — you don't have to check for them.
  • Each lane has its own settings. Interval, first start, and gap rules can all be set per lane, falling back to event-wide defaults when you leave them blank.

In the draw grid, lanes are the columns and time runs down the rows.

Running a draw — the short version ​

  1. Open Starts → Manage starts.
  2. Click Draw starts (top right).
  3. Set the First start and Event start interval under Settings, and adjust any lane that needs different settings.
  4. Click Allocate start times.
  5. Review the result on the order screen, and drag individual competitors around if you need to.

That's the whole loop. The sections below explain each step in detail.

Step 1: Open the draw ​

The Manage starts tab opens on the order screen — the view of allocated start times. Until you've run a draw, it's empty and prompts you to click Draw starts.

If you haven't assigned courses to classes or added competitors yet, the screen tells you so. The draw needs classes with courses and competitors in those classes before it has anything to lay out.

Step 2: Configure the draw ​

Click Draw starts (top right) to open the configure screen.

Warning: If start times have already been allocated, Draw starts becomes Re-draw starts and asks you to confirm first. Re-drawing reconfigures and re-allocates from scratch, which replaces the current start times and ordering — including any manual reordering you did. There's no undo.

The configure screen shows a live preview of the plan: the lanes laid out as columns, time down the rows, with each class's block of slots labelled by class short name and position. No real competitors appear yet — the preview is purely structural, so you can see the shape of the draw before committing to it. A summary line above the grid reports the competitor, class, lane, and gap counts, the first and last start time, and Busiest minute — the most competitors this plan starts within any one Event start interval, across every lane at once. That last figure is the load on the start team, and the number Smooth the start load exists to bring down: switch it off and on and you'll see it move.

Start draw settings ​

Click Settings to open the event-wide configuration. The dialog is titled Start draw settings and has four tabs: Details, Draw algorithm, Lanes and Classes.

Details and Draw algorithm hold the event's own settings, and everything on them applies unless a lane or a class overrides it. Lanes and Classes are those overrides, one row per lane and per class. Neither table holds any editors: a row names the settings that lane or class has been changed on — or says Using defaults — and an Edit button opens the form where they are changed. A lane's opens the same dialog the grid's ⋮ Lane options → Settings does; a class's is its own.

Under the summary, in smaller type, a row also reports what the draw did to that lane or class, which is a different thing from what you set: where a class's block begins, the time a lane is actually being drawn from once smoothing has shifted it, and any spacing levelling changed. Those are not settings and there is nothing to correct — they are there so a row saying "Interval 2:00" cannot sit beside a grid starting that class's runners four apart with nothing accounting for it.

Details ​

The Details tab holds the values every lane inherits unless it overrides them. The five switches each carry their full explanation behind the ⓘ beside them — hover or focus it. Four of the five are event-wide and have no lane or class level; Honour start requests is the exception and can be answered differently by a lane or a class:

  • First start — the time the earliest slot in each lane sits at. It's also the origin of the event's start grid: every start lands on this time stepped by the Event start interval.
  • Event start interval — the grid every start has to land on; nothing may be spaced more finely. Must be greater than 00:00 — you can't allocate until it is.
  • Default lane interval — the interval each lane actually runs at unless it sets its own. Only whole multiples of the Event start interval are offered, so a lane's starts still land on the grid. One minute against two staggers the lanes: the start team gets a steady start every minute with fewer competitors in each slot, instead of several lanes going at once.
  • Smooth the start load — on by default. Sends each lane off on a different minute of the grid so the starts arrive evenly instead of in lumps: with twenty two-minute lanes all beginning at 10:00 you'd get 20 starters in one minute and none in the next, and smoothing turns that into 10 and 10. It only moves a lane's First start, and by less than one lane interval — nobody is reordered, no lane's own spacing changes, and lanes that share a first control are still kept apart. See Smoothing the start load.
  • Also spread classes across the window — off by default, and only available when Smooth the start load is on. Smoothing evens out the minutes; this evens out the morning. See Spreading classes across the window before switching it on — it changes when a class starts, and Manager asks you to confirm.
  • Separate lanes sharing a first control — on by default. Two courses that begin at the same control share the leg out of the start, so this moves one of them out of the other's way instead of refusing to draw. See Lanes that share a first control.
  • Honour start requests — on by default. Reads what each entrant asked for — an early start, a late one, or a start near or well away from the others in their group — and lets it decide who takes which start time. It moves no start time at all. See Honouring start requests.
  • Allow a request outside the class's own window — on by default, and only available when Honour start requests is on. Lets an early or late request be answered with a free minute on the entrant's own lane outside their class's block, anywhere inside the event's own start window. A lane or a class can answer this differently too. See Answering a request outside the class's window.
  • Reserve a gap every N starters — leaves one empty slot after every N runners (e.g. set to 15 to keep a free slot every 15 starters for late entries or vacancies). Set to 0 for no reserved gaps.
  • Gap between classes — the number of empty slots inserted between one class's block and the next, down a shared lane. Set to 0 to butt the blocks together.

Draw algorithm ​

The Draw algorithm tab holds the one setting of that name: how competitors are ordered within each class. See Draw algorithms below. Picking By ranking adds two more settings directly beneath it — Ranking order and Competitors with no ranking. They appear only for that algorithm, because nothing else reads them.

Which classes are drawn ​

Whether a class takes part in the draw at all isn't in that dialog. The Classes button — labelled with the count included, as in Classes (12/14) — sits beside Settings in the header while you're on the configure screen, and lists every class with a switch. By default every class is included in the draw — switch a class off to exclude it.

Excluding a class leaves it out of the draw entirely: it doesn't appear in the configure-screen preview, and Allocate start times skips it, so its competitors get no drawn start time. Use this for classes you're handling separately — for example a class running a mass start, or one whose start times you're entering by hand.

Note: Exclusion only affects drawing starts — it never deletes start times that are already allocated. If a class already has allocated starts (for instance because you excluded it after a draw), its competitors still appear on the order screen and in the start list. The exclusion simply keeps the class out of the next draw.

Tip — redrawing only some classes: Because a re-draw only touches included classes and leaves excluded classes' existing times untouched, you can use exclusion to redraw a single class (or a selected few) without disturbing the rest. Exclude every class you want to leave as it is, leave only the class(es) you want to redraw included, then run Allocate start times again — only the included classes are redrawn, and everyone else keeps their current times. This works most cleanly for a class on its own course; if the redrawn class shares a lane with classes you kept, it's laid out from the lane's first start independently of them, so you may need to fine-tune on the order screen to avoid overlaps.

Per-lane settings ​

Each lane (course) can override the event defaults on six settings — First start, Start interval, Reserve a gap every N starters, Gap between classes, Honour start requests and Allow a request outside the class's own window. A lane that starts late, or runs at a 3-minute interval while the rest run at 2, is set up here. Start interval offers only whole multiples of the Event start interval.

There are two ways to the same dialog: the ⋮ Lane options → Settings on a lane's column header on the order screen, and the Edit button on that lane's row on the Lanes tab of Settings. Both open the lane's own dialog, on its Lane tab.

The four numbers start out inheriting, and say so: each shows Using default (…), with the value it is inheriting in the brackets, and an Override button beside it. Press Override and an editor appears already holding that value, with a Use default button above it that hands the field back to the event setting. There is no blank state — a field is either inheriting or overridden, and the two buttons are how you cross between them.

The two start-request settings work differently, because they are yes/no. Neither has an Override button and neither needs one: each is a picker offering Using default (…), Yes and No, and inheriting is simply the first of the three. Leaving one on the default is not the same as choosing No — the default follows the event switch if you later change your mind about it, and No does not.

The rows on the Lanes tab stay in name order whatever you do to the lane columns on the grid — a settings row is found by looking a lane up by name, so it should not move because you dragged a column somewhere else.

The dialog's other tab, Classes, lists the classes running down this lane — a lane carrying one class shows just the one. It is the same table as the Classes tab of the event settings, narrowed to this lane, and the rows also drag to reorder, which sets the order their blocks appear down the lane. Edit opens the class's own dialog, holding five settings:

  • First start — holds a class until a given time. The class's block won't begin before this time even if earlier slots in the lane are free; it snaps up to the next slot at or after it. Leave blank for no floor. It only ever holds a class back: it can't start one earlier than the lane would. Once you have typed one, none of the draw's own shaping moves it — see A first start you set is a fixed point.
  • Class start interval and Draw algorithm — for a class that needs its own, where the rest of the lane keeps the lane's.
  • Honour start requests and Allow a request outside the class's own window — the most specific level of those two. A class saying No to the first keeps the order its draw algorithm produced whatever the lane and the event say; a class saying No to the second still has its requests honoured, but every one of its entrants stays on one of its own starts.

A first start you set is a fixed point ​

Three of the draw's settings move start times about on their own — Smooth the start load, Also spread classes across the window and Separate lanes sharing a first control. None of them may touch a First start you typed yourself.

Type one on a lane and that lane goes off at exactly that time: it is never given a smoothing phase, never moved out of another lane's way, and the class at its head is never held back to level the load. Type one on a class and the class keeps it — and the lane it runs on is held with it, because a lane shifted a minute would carry the class's time along with it.

A lane or class that inherits its first start is not pinned. The event's own First start is where everything goes by default rather than a time anybody asked for, so the three settings still have the whole of an ordinary event to work on — and the lanes that are free to move are the ones that end up doing the moving. Pin a first start when it is a promise: a class you have advertised, a lane going out over a road crossing at a marshalled hour, a school group that has to be away before the bus goes.

The one thing pinning cannot do is invent a fix. If a pinned lane shares a first control with another lane and the two would start competitors together, the only move available is the one you have forbidden — so you get the warning below instead, and decide yourself whether to move this lane, move the other one, or wave it through.

Classes that start together aren't drawn ​

A class where everybody goes off at the same moment needs no start times, so the draw leaves it out. That means a class with its own class mass start, and — where the event has a mass start — every class that hasn't been excluded from it. Relay classes are left out for the same reason, and always have been.

The preview says so on the figures line above the grid: an Excluded chip, and behind it a line naming each class it left out. Nothing is wrong; it's the setting doing what it says. If you did want the class drawn, clear its class mass start on Edit class — or, where it's the event's mass start covering it, tick Exclude this class from event mass start.

Warning: A competitor's own start time beats a mass start. So a class you drew before you gave it a mass start is still leaving individually — the draw wrote those times and the mass start can't override them, and leaving the class out of the next draw doesn't clear them. Clear their start times if you want the whole class away together.

Leaving the class out is not the same as ignoring it. The block it would have occupied is not held for it, so the classes that are drawn keep the lane's own first starts rather than being laid out behind an empty stretch.

Lanes that share a first control ​

Two courses can begin at the same control. When they do, they share the leg from the start to it — so a competitor sent away on one course at 10:04 and a competitor sent away on the other at 10:04 run that leg side by side, which is the one thing the start interval exists to prevent.

Separate lanes sharing a first control (on the Details tab, on by default) means the draw simply fixes this rather than telling you about it. It moves the later of the two lanes: usually by slotting it between the other's starts, and — where no offset inside its own interval can clear it — by sending it off after the other lanes have finished starting. Those are exactly the two fixes the warning below suggests; the setting just applies them for you. The lane's own first start on the Lanes tab is left as it stands — blank where it inherits the event's — with Drawn from … underneath it giving the time the draw is actually using. It only ever moves a lane whose first start you left to inherit: a lane you typed a first start on is never moved, and the clash is reported to you instead.

Switch it off and you get the warning instead, which is what the rest of this section describes.

The configure screen checks for this as you build the plan. If two lanes share a first control and would start competitors at the same time, an amber Lanes on a shared first control chip appears on the figures line above the preview; click it for Lanes starting together on a shared first control, with one line per affected lane naming the other lanes involved, the control code, and how many starts coincide. The lane's column header is marked Shared first control too, so you can see which column each line is talking about.

Sharing a control is not by itself a problem. Two lanes that are already staggered — one on the even minutes, one on the odd — never send anyone off together, and the draw says nothing about them. It is the shared control and the shared start time together that raise the warning.

Each line carries a button that clears that lane by moving its first start:

  • Interleave from HH:MM:SS — slots this lane between the other lane's starts. Both lanes keep their own interval; this one simply sits in the gaps.
  • Start later, from HH:MM:SS — holds this lane back to the earliest time from which none of its starts lands on one of theirs.

Which of the two you're offered depends on the lane. If a shift within the lane's own interval is enough to clear it, you get Interleave; if it isn't, a shift that large would no longer be slotting this lane between the other's starts but delaying it, so the draw offers a later start and says so.

Start later means later by as little as it can be. It does not wait for the other lanes to finish: a lane held to the even minutes has cleared one running on the odd ones however much longer that one goes on for, and holding it back anyway would buy an empty morning for nothing. What the start interval is there to prevent is two competitors leaving down the same first leg together, and a lane that never lands on one of the others' start times has already prevented it.

Clicking the button sets that lane's First start to exactly the time printed on it, closes the dialog, and the preview re-runs — so the chip either goes or tells you what is still in the way.

The two suggestions arrive at their times differently. A Start later time is snapped onto the event's own grid — the event's First start, stepped by the Event start interval — which is where a lane being moved out of the way belongs. An Interleave time is measured from this lane's own first start instead, a whole number of event intervals along it, so it keeps whatever phase that start already had — dropping into the other lane's gaps, and keeping this lane's own phase from there on, is the whole point of interleaving.

While the lane's first start is itself on the event grid — the normal state, since the First start field snaps what you type up onto the next event start slot and tells you when it has moved you, and a blank one inherits the event's first start — both suggestions land on that grid too, and typing the time in by hand gives the identical result. A lane can drift off the grid, though: nothing re-snaps a first start you set earlier if you then change the event's First start or Event start interval under it. Retyping an interleave time on such a lane would snap it forward and lose the phase the suggestion was built on, so apply an interleave with the button rather than retyping its time by hand.

Note: A forked course counts every variation's first control, because which fork a given competitor will run isn't known at draw time.

Tip: The warning is reported against the later of the lanes involved, in left-to-right lane order. If several lanes share a control, work down the list from the top — each fix you apply is re-checked against the lanes above it, so the list converges rather than shuffling the same problem sideways. Applying one closes the dialog; open the chip again for what is left.

Reordering lanes ​

The lanes start out in course-name order, read the way you numbered them — so Course 2 comes before Course 10, the same order courses are listed in everywhere else in Manager.

Drag a lane's column header sideways onto another to change the left-to-right order of the lanes. This is purely presentational — it doesn't change any times — but it's handy for grouping related courses/classes together on screen and in the start list. Once you've dragged one, the order is yours: name order is only where the lanes begin.

Step 3: Allocate ​

When the preview looks right, click Allocate start times and confirm.

Allocation writes a start time onto every competitor in the draw, replacing any start times already allocated. The order within each class is decided by the chosen draw algorithm. Manager then switches to the order screen so you can review and adjust.

Note: Allocation only ever touches competitors who are in scope — those in a class that has a course. If nothing gets allocated, it's almost always because classes have no courses assigned, or there are no competitors yet.

When allocation is refused ​

While the shared first control warning is on screen, allocation stops: no start time is written, and every competitor keeps whatever start time they already had. The confirm dialog repeats the warning, and its button reads Allocate anyway instead of Allocate.

Only the start times are withheld. The settings you were editing when the refusal came are saved as usual — configuration writes live, and a refused allocation doesn't roll it back — so you can cancel, adjust one more lane, and try again without retyping anything.

From there you have two ways on:

  • Cancel, apply one of the suggested first starts — or set the lane's first start yourself — and allocate once the warning has cleared.
  • Allocate anyway, which goes ahead and draws what the preview shows.

Note: Manager re-checks the plan the moment you press Allocate anyway, so that what you agreed to is what actually gets drawn. If the warning has moved on in between — a lane you had just fixed, or a pair that has only now appeared — nothing is drawn and you'll see "The warning changed while you were looking at it — check it and allocate again." The dialog then shows the warning as it now stands; read it and press again. You'll see the same message if the plan can't be re-checked at all, for instance if the connection drops.

Going ahead is a legitimate answer rather than a last resort. The check is about how the courses are set up, not about your data, and it knows nothing about where the two lanes stand on the ground. If your two starts are nowhere near each other, or the shared control is close enough to the start that nobody is going to be led anywhere, Allocate anyway is the right button.

Step 4: Review and fine-tune ​

The order screen shows the allocated start list as a grid: lanes across, time down, with each competitor in their slot (bib, name, and class).

Moving a competitor ​

Drag a competitor onto a different slot in the same lane. The other competitors ripple to keep the course clash-free:

  • Moving a competitor into an occupied slot rotates the displaced competitors along, usually filling the gap your competitor left.
  • If you drop onto an empty (reserved) gap, the competitor simply takes it.

You can only move a competitor within their own lane — a competitor's course doesn't change just because you're reshuffling start times. Drops onto another lane are ignored, and the competitor snaps back.

Double-click a competitor to open their Edit competitor dialog.

Spreading classes across the window ​

Smooth the start load decides which minute of the grid each lane fires on. That fixes the lumpiness within each repeat, but it cannot change how many lanes are running at once — so it leaves the shape of the morning alone. And that shape is lopsided by default: every lane goes off at the first start, the small classes finish early, and the start team works through something like

10, 10, 9, 8, 8, 7, 3, 5, 4, 4, 3, 2, 0, 2, 3, 0, 2, 1

Ten people a minute at the beginning, and empty minutes at the end. Also spread classes across the window fixes that half of the problem, and the two together give you roughly

5, 6, 5, 6, 5, 5, 6, 5, 4, 4, 5, 6, 5, 3, 4, 2, 3, 2

The same starters, the same window, a morning you can actually staff.

It has three ways of getting there, and uses whichever helps:

  • Moving a class later, into the quiet second half. This does most of the work. The class stays compact and its runners keep their spacing — only the hour changes.
  • Widening a class's interval where its lane has room, so it runs more thinly across more of the morning. Always safe on the ground: a wider interval only ever puts more air between competitors on the same course.
  • Adding gaps inside a class, which reaches the spans that doubling an interval steps straight over. It costs even spacing, so it is the last of the three to be used.

A class is never spread over more than twice the time it would otherwise take. Arithmetically the flattest possible morning would thin every class across the entire window, but a class spread over ninety minutes is running in noticeably different conditions at either end, and that is not a trade worth making.

Everything the draw normally guarantees still holds: nobody is reordered, no two runners on a course ever share a time, lanes that share a first control are still kept apart, and it never runs past the last start your draw would have had anyway.

Holding a class where it is ​

Give the class a First start on the Classes tab. A class with one is pinned: it is never delayed, never spread, and nothing above it on its lane may be delayed into it either. Use this for anything with a required time of day — a class you have advertised, or one that has to be away before something else.

A First start on the lane holds the class at its head in the same way, for the same reason: that first start is when the lane's first competitor goes, so levelling may not hold the block behind it back.

It applies when you draw ​

Spreading is a decision the draw makes, so it takes effect on Allocate start times. It is never applied to start times already placed: it reshapes each lane's own timeline, which would mean putting every runner back on a slot and undoing anything you had moved by hand. To spread an allocation you already have, draw again.

Smoothing the start load ​

Smoothing runs as part of every draw, so like spreading it takes effect on Allocate start times. To even out an allocation you already have — after turning the setting on, changing an interval, or taking a lane's worth of late entries — draw again.

It is not a re-draw of the order. Whole lanes shift onto a free minute; nobody changes place, no lane's own spacing changes, and each lane's runners stay exactly as far apart as they were.

It follows every rule the rest of the draw follows: no two runners on a course ever share a time, and two lanes that share a first control are never sent off together.

It leaves alone any lane whose First start you typed, and any lane carrying a class you typed one on — see A first start you set is a fixed point. Those lanes stand still, and the lanes that are free to move are smoothed around them.

Smoothing prefers not to move the event's last start, and usually doesn't have to: it moves the lanes that finish starting early and leaves the long lane that sets the last start where it is. When every lane is the same length there's no slack to spend, and it will push the last start out — never by as much as one lane interval, and only where that's the one way to bring the busiest minute down.

Drawing again doesn't compound it: each lane's phase is measured from the First start you set, so it's recomputed rather than re-applied, and a draw that's already even is left alone. Where every lane runs at the Event start interval there is only one minute for each to sit on, so there is nothing for smoothing to even out.

Clashes and warnings ​

The grid marks a slot in two ways, and they mean different things. Both appear at the left of the slot, so read the colour before you act on it.

Red — two or more competitors at this time on this course. A normal drag can't produce this, because the other competitors ripple to keep the lane clash-free; it means the times came from somewhere else, such as editing a start time on the competitor, importing a start list, or re-drawing a lane that still holds times for an excluded class. Resolve it by dragging one of them onto a free slot.

Amber — this start and a start on another lane at the same time head for the same first control. Nobody is double-booked; the two competitors would run the leg from the start to that control together. Hover the marker to see which lane (or lanes) the clash is with. This is the same check the configure screen runs, applied to the times as they now stand — which is how a manual drag that re-creates the situation gets marked on the slot where you made it.

The amber marker doesn't block anything: the times are allocated already, and it's a warning about how the courses begin rather than a fault in the data. Leave it, if you know the two starts are far enough apart that it doesn't matter. To clear it you have to change which times the lane sends runners away at — moving people between the times it already uses won't do it:

  • Drag the competitor onto a free slot — a reserved gap, or a slot you've opened up with Add earlier slots / Add later slots. That is the move you can rely on: the time they came from is left empty, and its marker goes with it (though if the slot you drop onto is shared with the other lane too, a fresh marker appears there). Dropping onto an occupied slot is a different move, and not one to rely on for this. Everybody between the two slots shifts one row towards the one you dragged out of, so mostly what you have changed is who stands on the lane's times: expect your old time to still be occupied — by the neighbour that has just shifted onto it — and its marker to stay put against that runner. An empty row somewhere in between doesn't rescue it, because the hole shifts one row along with everybody else; your old time comes free only in the narrow case where that empty row was directly alongside it. The lane does pick up the time the hole has just left, so a fresh marker can appear there instead. Read the marker after any drop rather than assuming, and when you actually need a time cleared, drag onto a genuinely free row.
  • Re-draw the lane from the ⋮ Lane options menu described below, having changed something in the same dialog that moves its times — First start, Start interval and Reserve a gap every N starters all do. Gap between classes only does so on a lane carrying two or more classes: the padding it sets goes between one class's block and the next, and never in front of the first. On the dialog's Classes tab, a class's own Class start interval and First start move times, and so does the class order in the usual case where the blocks aren't all the same size — reorder equal-sized blocks running at one interval with no class First start and exactly the same times come back, with different people on them. The per-class Draw algorithm moves nothing: it changes who occupies the lane's times, which is the very thing this list has just said won't clear the marker. Re-drawing on unchanged settings isn't wasted either: the lane is laid out again from its own first start and interval, so anybody a drag had left on an added slot or a reserved gap is pulled back onto the lane's regular slots, and a shared time that only existed because of such a drag is vacated. Where every runner was already on a regular slot, the same set of times comes back and the re-draw only reshuffles who starts when. The menu's Settings item clears nothing by itself — it edits the lane's settings but never re-allocates, so no allocated time moves until you re-draw.

See Lanes that share a first control for what the warning is about.

The start-conflict summary ​

Both Starts screens carry the same panel at the top: Start conflicts, and how many there are. It only appears when there are some — an event with a clean start list shows nothing at all.

It reads the start times competitors actually hold, so it covers times you drew, times you imported, and times you typed. That's what makes it different from the shared first control warning on the configure screen, which asks the same question of a draw you haven't run yet. Two things put a line in the panel:

  • Two starts at one moment on one course. The line names the moment, the course, and the competitors. This is the red marker of the section above, gathered up where you can see all of them at once.
  • Two courses that begin at the same control, both starting somebody at that moment. The line names the moment, the control, and the courses. This is the amber marker, gathered up the same way. It names courses and not competitors, because the fix is to move a lane.

A class on a mass start counts as one start rather than one per competitor — that's what a mass start is, and counting them individually would bury everything else. So a mass-start class on its own is never a conflict, while a mass-start class meeting a drawn class on the same course at the same minute is.

Competitors marked as not starting — Did not start, Not participating, Cancelled — are left out: withdrawing somebody doesn't clear their start time, and there'd be nothing you could do about a warning naming them.

Long lists are summarised: the first ten are written out and the rest counted. The panel isn't printed — it's a warning about the start list rather than part of it.

Note: The panel appears again as a warning when you press Start event, with the number of conflicts and the time of the first. It's the last moment it can be acted on; once runners are away there is nothing to be done about two of them on the same first leg. Like every pre-start warning it's advisory — an organiser who means two classes to go off together can go ahead.

Showing more slots ​

The grid shows the range from the first allocated start to the last. To make room beyond that:

  • Add earlier slots / Add later slots extend the visible window so you can drag a competitor into a brand-new slot before the first or after the last start.
  • Reset extra slots collapses the window back to the allocated range.

These buttons only change what's visible — dragging a competitor into an added slot is what actually gives them that time.

Working on one lane from the order screen ​

Each lane's column header carries a ⋮ (Lane options) menu:

  • Settings — this lane's own First start, Start interval, Reserve a gap every N starters and Gap between classes, plus the Classes tab. Changing them re-steps the grid the lane is drawn on without re-running the draw: the rows move, no allocated start time does.
  • Re-draw… — re-allocates just this lane. The dialog holds a Draw method picker — and, when that is By ranking, its two ranking settings — above the same per-lane overrides described above and the same Classes tab. Re-draw lane then allocates that lane again, on whatever you have just changed.

The draw method you pick in the re-draw dialog applies to that re-draw alone; the event's own Draw algorithm setting is left as it was. That's how you seed one course by ranking while the rest of the event stays on a random draw.

Note — excluded classes on the lane: A re-draw lays out only the classes currently included in the draw. If a class on this lane is excluded but still holds start times from an earlier draw — which is exactly what the redrawing only some classes tip sets up — the re-draw lays the included classes from the lane's first start without regard to the times that class is still sitting on. The two can therefore land on the same time, and you'll get a red marker to sort out on the grid. Event-wide Allocate start times behaves the same way. It's the trade-off for exclusion leaving allocated times alone: check the lane after re-drawing it.

Draw algorithms ​

The algorithm decides the order competitors within a class are placed onto the class's slots. Four are offered:

  • Random — every competitor in the class is shuffled together, ignoring club. The simplest, fairest-by-default option.
  • Separate club members — spreads members of the same club as far apart as possible, so clubmates don't start back-to-back. Same-club neighbours only occur when one club is so large that separation is arithmetically impossible.
  • Cluster club members — the opposite: members of a club start as one unbroken block. Useful when a club wants its runners out together.
  • By ranking — seeds each class by the competitors' rankings: their places on an external ranking list, where 1 is the best-ranked athlete. See Drawing by ranking below.

The first three shuffle the whole class, so re-running produces a different draw each time. By ranking deliberately does not: a ranking decides the order, so the same rankings give you the same order again. What it does re-shuffle is everything the rankings leave open — competitors on the same ranking, and the block of competitors who have no ranking at all.

Competitors with no club are treated as individuals — neither clustered with, nor deliberately separated from, one another.

Drawing by ranking ​

A competitor's Ranking is their place on an external ranking list — a national ranking, a squad's seeding order, whatever list you were handed. 1 is the best-ranked athlete and the number grows worse. Someone who isn't on the list has no ranking at all.

Rankings aren't points, and Manager never treats them as such: a bigger number is a worse place, not a better score. Set them on the competitor, or bring them in from a ranking list, before you draw — see Ranking.

Choosing By ranking reveals two settings, on Settings → Draw algorithm and in a lane's Re-draw… dialog:

  • Ranking order — Best ranked first or Best ranked last. This orders the competitors who have a ranking, and nothing else.
  • Competitors with no ranking — Start last or Start first. This decides which end of the class block the unranked sit at, and nothing else.

The two are independent, and their four combinations are the four orders organisers ask for:

Ranking orderCompetitors with no rankingThe class block runs
Best ranked firstStart lastRank 1, then down through the ranked field, then everyone unranked. The favourites are away first and through the arena early.
Best ranked lastStart firstEveryone unranked, then the worst-ranked, building to rank 1 as the last starter in the class. The championship shape: the field builds towards the favourites.
Best ranked lastStart lastThe worst-ranked leads off, building to rank 1, and the unranked follow behind the whole ranked field.
Best ranked firstStart firstThe unranked lead off, then rank 1 and down through the ranked field.

A few things worth knowing before you use it:

  • The unranked are never mixed in. They're a block of their own at one end — Manager never treats "no ranking" as a place on the list, so an unranked competitor can't land between rank 3 and rank 4.
  • Ties and the unranked block are still shuffled. Two competitors on the same ranking fall in a random order relative to each other, and the unranked block is shuffled every time, so a re-run varies where the rankings say nothing. The ranked order itself doesn't move.
  • It applies class by class, like every other algorithm. A class where nobody has a ranking simply gets a random draw; you'll see nothing unusual and nothing fails.
  • It doesn't change the times, only the order. Interval, first start, reserved gaps and the gaps between classes work exactly as they do for any other algorithm.
  • Check the rankings first. Someone who should have been ranked but wasn't will start with the unranked block rather than in their proper place, and nothing on the draw screen flags it. Turn on the Ranking column on the Competitors page and sort by it before you allocate.

Honouring start requests ​

An entrant can ask for something when they enter: an early start because they have to leave, a late one because they are arriving late, or a start close to — or well away from — other people. Two parents splitting the childminding want to be a long way apart; a car-load who travelled together want to go together. You record it on the Start tab of Edit competitor, or in bulk on the Competitors page, and an entry list you import may carry requests already.

Honour start requests, on the Details tab, is what tells the draw to read them, and it is on unless you switch it off. An event that collects no requests is unaffected either way; switch it off for an event where an imported entry list has arrived carrying requests nobody at your event has agreed to, or where a class's draw has to be purely random.

Nothing about the timetable changes. The draw lays the lanes out exactly as it would have: same first starts, same intervals, same gaps, same smoothing and levelling. All that changes is who is on which start time. That is also the limit of it:

  • An early start is the first of the class, not the first of the event — unless the setting below lets it out. If the class runs from 11:20 and its lane is full before then, an early request goes to 11:20. Which part of the morning a whole class runs in is always your decision — set the class's First start, or use spreading.
  • Early and late always work. Everyone who asked to start early leads their class, in the order the draw algorithm put them in; everyone who asked to start late brings up the rear. Neither can be overruled by anything else on this page.
  • Close to and away from are best effort. The draw puts a group as close together, or as far apart, as their classes' own start times allow, and an hour apart is as far apart as it tries for. A family in one small class can only be spread across the width of that class's block; two people in classes at opposite ends of one lane cannot be brought together at all. Nothing warns you about that — check the group on the grid if it matters.
  • A group can span classes and lanes. Members are matched up wherever they are entered, and somebody in a class that is not honouring requests still counts: the draw places the others around the time that person actually has.

A lane or a class can answer this differently from the event, in the Lanes and Classes tables — Default, Yes or No, most specific wins. A class set to No is drawn exactly as it would have been with the setting off, which is the way to keep one class's draw purely random while the rest of the event listens to what people asked for.

Requests are shown on the grid whether or not the setting is on: a small mark on the right-hand edge of a competitor's cell, whose hover names what they asked for. It always says what was asked, never what they were given — the time in the cell is what they were given.

Answering a request outside the class's window ​

A class runs in a window of its own. Say M21 runs 10:00 to 10:45, while the event's last start — on some other, longer lane — is at 14:00. Keeping a late request inside M21's own window means the latest it can be answered with is 10:45, which is not what the entrant asked for.

Allow a request outside the class's own window, on by default, lets the draw answer them properly: the two people who asked to start late are given 13:58 and 14:00 instead. It works the same way in the other direction — somebody in a class that doesn't begin until 11:20 can be given a free minute back at the event's First start, if their lane has one. That is the same move you would make by hand on the grid, so this only saves you making it.

What it does and does not do:

  • Early and late requests only. Somebody who asked to start away from their partner did not ask to run in the afternoon, so the two group requests are always answered inside the class.
  • On the entrant's own lane, and only where it is genuinely empty. They take a free minute of their lane's own grid — never a time another competitor holds, and never one that would send them down a shared first leg alongside another lane.
  • Never a gap you asked for. A slot held by Reserve a gap every N starters, or by the Gap between classes, is not free space: you set it aside and it stays set aside. What is left is the part of the lane that lays nothing down at all — after its last class, and in front of a class the draw has held back. That is why this mostly answers late requests: a lane's early minutes are nearly always somebody's start or a gap you asked for.
  • Never in front of a class you pinned. A class carrying a First start you typed sends nobody out ahead of it, however early they asked to go — that time is a promise, and a first start is a floor. Its late askers may still go later, which is all a floor ever said. (A first start on a lane is different: it says where that lane's grid begins, not that nobody on it may start earlier, so a lane you started at 11:00 can still answer an early request at 10:00.)
  • Never outside the event's own window. The earliest anybody can be given is the event's First start, and the latest is the last start the draw laid out — so the window you planned does not grow at either end. A lane you started later than the event is not a second limit: its ten o'clock grid positions are still offered if nothing is on them.
  • Nobody else moves. The minute the entrant leaves behind is simply left empty in their class's block; every other competitor keeps the time they had.
  • It needs somewhere to go. A class that runs to the end of the window, or a lane with no free minutes, simply answers the request inside the class as it would with the setting off.

Switch it off — for the whole event, or for one lane or one class on the Lanes and Classes tabs — if you would rather every competitor started inside their own class's window, whatever they asked for. That is a separate answer from Honour start requests: a class can say Yes to being reordered for what its entrants asked and No to sending any of them outside its own block, which is what an advertised class usually wants.

How settings combine ​

Most settings can be set at more than one level. The most specific value wins, and a blank value inherits from the level above:

  • First start cascades lane → event. (It's per-lane because a lane is a single uniform timeline.)
  • The interval cascades class → lane → event: a class's Class start interval, else the lane's Start interval, else the event's Default lane interval. Each of them has to be a whole multiple of the Event start interval, which isn't a level of the cascade at all but the grid the whole draw lands on.
  • Reserve a gap every N starters and Gap between classes cascade lane → event — there's no class-level editor for either, so the Classes tab carries the three settings above and not these.
  • A class's First start is a floor and nothing else — it holds the class's block back to the next slot at or after the time you set, and never moves it earlier. It is also a pin: once you have typed one, none of the three settings below moves the class, or the lane it runs on. See A first start you set is a fixed point.
  • Also spread classes across the window is an event setting with no lane or class level, and depends on Smooth the start load — switch that off and this goes off with it. Like smoothing, what it decides is stored apart from your own values: a class's spread never overwrites its First start, Class start interval or Reserve a gap every N starters, and turning the setting off puts every class back on the next draw. It moves no class you have given a First start, and holds back no class at the head of a lane you have given one.
  • Separate lanes sharing a first control is an event setting with no lane or class level. Like the two above it, what it decides is stored apart from your own values: it never overwrites a lane's First start, and switching it off puts the lane back on the next draw. It only moves a lane that inherits its first start — a lane you typed one on stays where you put it. If it cannot clear a clash, whether because no offset does it or because the lane is one it may not move, the draw still refuses and shows the warning — the setting makes the fix automatic, it does not make the rule optional.
  • Smooth the start load is an event setting with no lane or class level. It never overwrites a lane's First start: the phase it chooses is stored apart and added on top of whatever the cascade above arrives at, so the lane sits less than one interval later than the time in the field. It only chooses a phase for a lane that inherits its first start — a lane you typed one on, or that carries a class you typed one on, is given none and goes off exactly when you said. Turn it off and the next draw puts every lane back.
  • Honour start requests cascades class → lane → event — the only one of the five switches with levels below the event. Default at a level means "take the answer above"; No is an answer of its own, so a lane set to No stays off even if you later switch the event on. Unlike the three switches above it, this one rewrites no times at all: it changes only who occupies each slot, so there is nothing stored apart from your values and nothing to put back when you turn it off. (The one below it is the single exception, and only for an early or late request — see the bullet after this one.)
  • Allow a request outside the class's own window cascades class → lane → event, the same three levels as the switch it widens and resolved separately from it, so a class may be reordered for what its entrants asked while still keeping every one of them inside its own block. At event level it depends on Honour start requests — switch that off and this one is greyed out, though your answer is kept for when you switch it back on. It is the one part of the draw that gives somebody a time their class's block does not contain; it never moves the block, and never gives anybody a start later than the draw's own last one.
  • Draw algorithm (with Ranking order and Competitors with no ranking) is an event setting a class may override on the Classes tab. A lane's Re-draw… dialog starts from the event setting and lets you draw that lane differently, but the choice you make there is used for that one re-draw and isn't saved back to the event — and a class that names its own keeps it.

So you can set a sensible event-wide interval once, then override just the two lanes that need something different, then hold back just the one class that mustn't start before 11:00 — without repeating yourself.

Changes write live ​

There's no draft mode and no separate save step. Configuration changes persist as you make them, and moves on the order screen are written immediately. There's no undo, so when re-drawing would discard manual reordering, Manager warns you first.

The Start list tab ​

Once start times are allocated, the Start list tab is what you publish. It's a read-only view with an options panel on the right, and it carries the start-conflict summary at the top whenever there is one:

  • Group by — Class, Course, or a single combined list.
  • Order by — Start time, surname, or first name.
  • Display — toggle a start-time-over-time graph, a starts overview, and per-class and per-course summary tables (showing first start, last start, and how many competitors have a start time).
  • Print columns — one or two columns, for denser printouts.
  • No start time — include competitors without an allocated time, optionally in their own separate table.

Use the Actions menu (top right) to export the start list, publish it to Eventor, or open a Print view. The PDF and print output mirror the on-screen grouping, sort order, and summary tables.

The three data exports all carry the same start list, under the same rule — the time published is always the allocated start (individual, then the class's mass start, then the event's), never a start somebody punched:

  • Export IOF XML — an IOF 3.0 StartList, for federations and other timing software.
  • Export JSON — an Orienteering JSON startList.
  • Export CSV — the spreadsheet. Its Start column is one Manager's own CSV entry import recognises, so a start list you export, edit in a spreadsheet and post back needs no column mapping. The Ranking column rides along, so the draw and the seed that produced it travel in one file: re-import it and re-run a By ranking draw and you get the same order again.

All three re-import: a start list Manager writes is a start list Manager reads.

Uploading the start list to Eventor ​

Actions → Upload to Eventor sends the start list straight to Eventor, without writing a file first. It appears only when the Eventor connection is switched on in Settings; what it publishes is the same IOF start list Export IOF XML writes, under the same allocated-start rule.

The dialog asks two things:

  • Which Eventor event to upload to. If this event is already linked to one — because it was created from Eventor or has had results uploaded before — that event is selected for you; you can change it. An unlinked event is linked to whichever event you pick here, and that link then stays put: uploading later to a different Eventor event does not repoint it.
  • Which classes to include. Every class is ticked to begin with, which is the usual answer. Untick the ones you don't want; you can't upload with none ticked, because an empty selection would mean "no filter" and publish the lot.

The class selection here is the dialog's own — it is separate from the Classes filter you may have applied to the screen behind it, which only changes what you are looking at.

Re-uploading replaces the start list on Eventor, so publishing again after a late change is the normal way to correct one. A mixed event (relay classes and individual classes in the same event) asks which kind you are publishing first, exactly as the file exports do.

If Eventor rejects the upload, the dialog shows Eventor's own reason — most often an event id you don't have organiser rights to. If the computer has no internet at the venue, it says so instead, and nothing is linked or published.