Constraint solving, not templates
Google's OR-Tools CP-SAT engine assigns slots to all matches at once - field capacity, opening hours, referee availability and rest windows are hard rules, not hopes.
Stop juggling spreadsheets. Tell PoolSolve who plays, where and when - the solver places every match into a conflict-free schedule.
Google's OR-Tools CP-SAT engine assigns slots to all matches at once - field capacity, opening hours, referee availability and rest windows are hard rules, not hopes.
Coaches leading multiple teams and referees with limited availability are modeled directly, so generated schedules avoid personal conflicts.
Fix the matches you like and re-solve the rest. The solver rebuilds around your pinned games instead of starting over.
Every remaining conflict is listed with its reason - accept it explicitly or send it back to the solver. Nothing is silently wrong.
Teams, fields, referees, rest windows and time preferences go in once - nothing else is needed to start.
The CP-SAT solver assigns every match a slot and venue simultaneously, so conflicts are impossible by construction.
Anything it could not place is listed with the reason - accept it or relax a constraint and solve again.
Lock the matches you like; the solver rebuilds around them when a team drops out or a field closes.
Manual scheduling feels safe because every cell is under your control, but control is exactly the problem. A forty-team weekend produces hundreds of matches, and each placement depends on every other: move one game to satisfy a coach and you may break a rest window, free a field too early, or leave a referee stranded between courts. Spreadsheets cannot see those ripples - they only record your last edit, so every manual fix quietly creates the next problem to find and someone has to check the whole grid again by eye. A constraint solver works the opposite way. It reasons about the entire slate at once, testing combinations a person would never have time to check, and either returns a schedule where every hard rule holds or proves that none exists. That proof matters as much as the schedule: instead of discovering on Saturday morning that two teams were double-booked, you learn which constraints clash and see the exact matches, fields and rule groups involved - the decision to relax something becomes yours and deliberate, not an accident.
A fair schedule is not a vague promise, it is a list of measurable rules you can hold the result against. PoolSolve lets you set a minimum rest window between a team's games, cap how many consecutive matches anyone plays, and spread early and late slots so the same squad does not always open the venue or close it. Referee fairness works the same way: officials are assigned from eligible pools, workload is balanced across the day so nobody covers six matches while a colleague covers one, and senior-qualification quotas keep finals staffed at the right level. Even field fairness is expressible - no team should spend the whole day on the farthest pitch while the favourites play every game on the show court. Because each fairness rule can run as a hard constraint or a weighted soft one, you decide what fairness means for your event and how firmly it holds, instead of hoping a manual grid happens to produce it by luck. Every rule also reports its own violations, so fairness stays auditable.
Every schedule starts from painted availability. Venues carry opening hours, fields get slots assigned to the categories that will use them, and teams and referees declare when they can actually be there - unavailable mornings, late arrivals and shared coaches marked once instead of remembered forever. Per-match time windows and matchday bindings then pin specific games where they belong. This model pays off the moment reality intervenes: rain closes a field on Sunday morning, a team drops out on Friday night, a referee calls in sick. In a spreadsheet that means a weekend of manual surgery, hunting every cell the change touches and still missing one. Here you update the availability that changed and re-run, and the solver re-places only what the new information invalidates - the rest of the day stays exactly where participants already saw it. Painted availability also doubles as documentation: instead of tribal knowledge about who cannot play early, the constraints live in the workspace, apply automatically to every future event you run, and stay editable when next season's ground rules differ.
A two-phase constraint solver built on Google's OR-Tools CP-SAT engine. Phase one assigns every match a field and time slot under the hard rules; phase two staffs referees and resources against those fixed placements.
Field capacity and opening hours, painted team and referee availability, rest windows between games, coaches shared across teams, medal-match spacing, per-match time windows and matchday bindings. Each tunable rule runs in hard, soft or off mode, and soft rules carry adjustable weights.
The solver proves the model infeasible and explains why in plain language - the conflicting rule groups plus the specific fields, teams, matches or pinned games involved - so you know exactly what to relax before rerunning.
Yes. Pin the matches you want to keep and repair re-places everything else around them - played games and locked staff are never moved.
Generation runs as a background job: a first complete schedule typically appears within seconds and keeps improving within a time budget you choose - Quick, Standard or Thorough. Watch improvements land live on the board or stop early to keep the best.
Yes - a dedicated staffing phase assigns referees and resources against eligibility, availability, senior-qualification quotas and workload balance, and reports any coverage shortfall instead of silently leaving gaps.
Round robin, group stage into knockout, placement and medal matches - combine stages into the format your sport needs.
Repeated round robin across up to 30 matchdays - paint one day, copy it onto the rest, and let the solver place every fixture.
Teams, organisations, categories, venues and referees in one workspace - create tournaments and matches your way.
Publish a read-only schedule spectators can follow live, and collect entries through open registration links.
Run LAN events, ladders and online brackets with the same solver - stations instead of fields, casters instead of referees.