Connect the Numbers is a browser-based dot-to-dot puzzle where you join eight fixed numbered points in strict order on a Canvas board, drawing seven segments to land on an audited score of exactly 1,000 points. The board opens with point 1 already anchored at its starting coordinate, so the first move you actually make is to choose point 2; from there the interface dictates the order through point 8. Every accepted segment is drawn live on the Canvas, while the connection ledger, current score, mistakes counter, next-required number, layout identifier, and feedback line all stay visible above the board at every moment. Processing and drawing happen entirely inside the browser, with no account, no remote puzzle feed, and no upload step required. A small responsive board, paired HTML buttons, full keyboard navigation, and an audit-friendly validator make the puzzle accessible to mouse, touch, and keyboard players on a single reproducible layout. Because the geometry, ledger, and scoring rules are all local and authored, every accepted route can be replayed and verified step by step.
What You're Looking At on the Board
The page opens to a single Canvas with eight original numbered points positioned inside fixed in-bounds coordinates. Point 1 is anchored automatically; you do not need to "connect" it. Above the Canvas sit eight large HTML buttons that mirror the eight points: each is reachable with a mouse click, a tap on touch, or a keyboard sequence (Tab to focus, then Enter or Space). The numbered buttons stay aligned with the visible point locations so you always know which control matches which dot.
A status panel remains visible throughout the run and reports the next required number (the only point the validator will accept right now), the current score (starts at zero and ends at exactly 1,000), the mistakes counter (which counts only distinct invalid attempts), the layout identifier (which names the active arrangement so it can be replayed later), the connection ledger (a running list of every accepted segment in order), and a short feedback line about the last move. Nothing leaves your browser. The Canvas drawing, the validator, the scoring, and the layout generator all run client-side. There is no upload step, no account, and no remote puzzle feed.
Try Connect the Numbers with the fixed opening layout first so you can see the controls and the ledger before introducing variability through New layout.
How the Segment Validator Decides Each Move
Every time you propose a new segment, the validator runs an audit before the Canvas accepts the line. The audit uses orientation signs plus on-segment bounds and distinguishes three geometry cases:
- A proper crossing — the proposed segment passes through the interior of an earlier nonadjacent segment.
- A nonpermitted endpoint contact — the proposed segment touches a prior segment at one of its endpoints in a way that is not the immediately previous segment.
- A collinear overlap — the proposed segment lies along the same straight line as a prior nonadjacent segment, even if the endpoints do not formally cross.
Only the natural joint with the immediately previous segment is exempt from this audit, because every new segment is expected to share its starting endpoint with the segment you just drew. Any other crossing, contact, or overlap causes the move to be rejected, the signed result to be logged, and a single mistake to be recorded — provided that this exact signed failure has not already been seen during the current run. If the same signature repeats, the validator deduplicates it: a second attempt of the identical invalid move is not allowed to consume your second chance.
The validator also enforces numeric order. If the next required number is 3, choosing 5 is not "skipping ahead" — it is treated as an out-of-sequence attempt and routed through the same mistake audit. Selecting an already connected point, an unknown point, or otherwise issuing an internal action that does not correspond to a valid proposal is an atomic no-op: it neither advances the path nor adds to your mistake counter.
| Attempt Type | Validator Reaction | Mistake Recorded? |
|---|---|---|
| Proper crossing of a nonadjacent segment | Rejected, signed collision | Yes, deduped |
| Nonpermitted endpoint contact with a prior segment | Rejected, signed collision | Yes, deduped |
| Collinear overlap with a nonadjacent segment | Rejected, signed collision | Yes, deduped |
| Out-of-sequence number | Rejected, order violation | Yes, deduped |
| Natural joint with the previous segment | Allowed (shared endpoint) | No |
| Selecting an already connected point | Atomic no-op | No |
| Unknown point or invalid internal action | Atomic no-op | No |
How to Reach Exactly 1,000 Points
Follow these steps in order on a clear, unblocked layout.
- Confirm that point 1 is already anchored on the Canvas. Look at the next required number in the status panel and verify it reads 2.
- Choose point 2 by clicking its numbered button, tapping the same control on a touch screen, tabbing to it and pressing Enter or Space, or pressing the disclosed number key 2.
- Watch the connection ledger accept the segment. The Canvas draws the line in real time, the score updates from 0 to 125, and the next required number advances to 3.
- Repeat the same action for points 3, 4, 5, 6, and 7 — strictly in that order. Each correct segment adds 125 points and pushes the running total through 250, 375, 500, 625, and 750.
- Choose point 8 last. The seventh accepted segment is recorded, the score moves from 750 to exactly 1,000, and the run enters its terminal state.
- Stop. Path actions and layout replacement are frozen to preserve the audited result. Restart is the only way to begin a fresh attempt on the same fixed opening layout.
If you want to swap geometry without leaving the page, use the New layout control before you start drawing. New layout triggers a deterministic seeded generator that produces a fresh in-bounds arrangement; it never fires during React rendering and never replaces the active layout silently.
| Segment | Connection | Points Added | Running Score |
|---|---|---|---|
| 1 | 1 → 2 | 125 | 125 |
| 2 | 2 → 3 | 125 | 250 |
| 3 | 3 → 4 | 125 | 375 |
| 4 | 4 → 5 | 125 | 500 |
| 5 | 5 → 6 | 125 | 625 |
| 6 | 6 → 7 | 125 | 750 |
| 7 | 7 → 8 | 250 | 1,000 |
Six segments award 125 points each and the seventh contributes the remaining 250 points, summing to exactly 1,000.
Reading the Feedback and the Mistake Ledger
The mistake counter is intentionally strict. Two distinct invalid attempts — for example, an out-of-sequence 5 and a crossing proposal from 2 to 6 — close the run. Repeating the exact same invalid move will not let you test the validator twice for the price of one mistake. The signature used by the audit includes the active layout, the expected number, the chosen number, and the collision result, so any collision you trigger is uniquely identifiable within the run.
The connection ledger, by contrast, only logs accepted segments. A clean ledger with seven entries — 1→2, 2→3, 3→4, 4→5, 5→6, 6→7, 7→8 — is the only sequence that yields a 1,000-point finish. If the ledger shows fewer than seven entries at the moment the run closes, the run ended in deadlock rather than completion.
Restart is a deliberate reset: point 1 is restored, the initial fixed layout is restored, the score returns to zero, and the mistake counter returns to zero. Independent tests verify that the board replays 2 through 8 for the exact 1,000-point outcome, that two distinct invalid attempts lead to deadlock, and that duplicate invalid attempts do not consume the second chance.
When to Use New Layout vs the Fixed Opening
The fixed opening layout is reproducible on every visit: the same eight coordinates, the same Canvas, and the same winning route. Use it when you want a golden-path replay, when you are checking a video walkthrough, or when you are demonstrating the validator to someone else. Independent tests pin a literal coordinate table against this layout so the segments can be re-checked by hand.
New layout is an explicit user action. It does not run during React rendering; it runs only when you press the control. A chosen seed is passed into a pure layout function that returns fresh in-bounds coordinates. The same seed always produces the same arrangement, so the new geometry stays testable and identifiable — you can read the layout identifier from the status panel and reproduce the exact board later. The selector enforces bounds, coordinate uniqueness, and route validity before offering the board back to the run.
Because the rules and the scoring formula do not change between layouts, only the geometry does, your strategy stays the same: connect 2, 3, 4, 5, 6, 7, and 8 in order. For a closer look at whether the point positions feel random during play, see Are the Point Positions Random in Connect the Numbers?. The Boss Key from the standard game shell remains available, and no additional dependency, API call, or analytics-driven opponent is introduced.