Choose your next step in a numeric ranking game by reading every printed rank first, locating the lowest card, and sliding it left while the highest card moves right, repeating until the rail reads from smallest to largest. In Speed Sorting Game, that single rule replaces color matching, hidden interpolation, and reaction scoring: every card displays its exact numeric rank beside a short manifest label, and the only target is strict ascending order. Because each round uses unique ranks, there is exactly one valid final sequence, and your next decision is always the same shape — identify the rank required by the leftmost empty slot, find that card on the rail, and swap it home. Drag, touch tap-to-tap, and keyboard arrow swaps all run through the same reducer, so the input you choose does not change the rule you must follow. Untimed pacing and a five-round, fixed 1,000-point route let you reason in full instead of guessing under pressure.
Why Numeric Rank Is the Only Signal You Need
In Speed Sorting Game, every card carries its exact rank printed beside a short manifest label. That printed rank is the only thing your next move should consider — not the background, not the order the cards happen to sit in, and not the relative position of any neighbour you have not yet read. Because each round uses unique ranks, the rail you see has exactly one valid final sequence, and every other arrangement is, by definition, a step away from that target. This makes your decision space tiny: for any given leftmost slot, there is precisely one card that belongs there, and the rank of that card is sitting on the rail somewhere. Your task is to locate it and move it home.
Other ranking puzzles lean on hue, brightness, color interpolation, or hidden visual steps. Speed Sorting Game does none of that. It asks you to read numbers, not to estimate a gradient or infer an unstated category. The same is true at every setting — monochrome display, reduced color vision, browser zoom, and assistive technology all read the same numbers — so the rule of "find the rank and slide it left" is universal across devices. That uniformity is why your next-step reasoning can stay short: there is no hidden layer to factor in.
Read the Printed Ranks Before You Touch Anything
The first useful habit is to read every card on the rail before you commit to a swap. Five to seven cards is a small set, and a single pass gives you the full picture: where the lowest rank currently sits, where the highest rank currently sits, and which middle ranks still need to migrate. Reading first also prevents the most common choice error — moving a card you have not verified. If you swap before you have confirmed which rank is the lowest, you risk displacing the wrong card and then reasoning from a stale mental picture.
Reading also exposes the round's specific rank format, which matters because the five fixed manifests use different printable styles without changing the rule:
| Round | Manifest | Format of the Printed Rank |
|---|---|---|
| 1 | Parcel Queue | Compact positive parcel codes |
| 2 | Signed Intake | Negative and positive integers mixed together |
| 3 | Decimal Dispatch | Explicit decimal ranks |
| 4 | Rack Ledger | Padded abstract labels that also print the underlying integer |
| 5 | Final Freight | Padded abstract labels that also print the underlying integer |
Signed Intake is the round where most readers pause, because a negative number sits to the left of zero and far left of any positive number. Treat "negative" as a direction, not as "smallest label": the more negative the value, the farther left it belongs. Decimal Dispatch is the round where readers most often round by eye; always read the printed decimal exactly, because two visually similar decimals can differ in the second or third place. For the padded abstract labels in Rack Ledger and Final Freight, the underlying printed integer is the authority — the label is an identifier only and never changes the order.
Decide Your Next Swap in Three Logical Moves
Once you have read every card, choosing your next swap becomes a three-step loop. The loop is short enough to keep in working memory and short enough that you can repeat it from the leftmost slot to the rightmost slot without losing your place.
- Identify the rank that belongs in the leftmost empty slot of the target sequence. If the leftmost card on the rail is already that rank, leave it alone and move your attention to the next slot.
- Find that rank on the rail. Note its current position, then choose any partner card sitting in the leftmost slot (or any other card whose destination you already know).
- Perform a single swap. In Speed Sorting Game, every swap is a true exchange: the two cards trade places, no card is destroyed, and the new arrangement is the input to your next decision.
Repeat the loop for the second slot, the third slot, and so on. Because the rule is strictly ascending, each completed left-side slot never needs to be touched again. Locking in slots from left to right also gives you a visible progress cue, which is useful when a round contains six or seven cards rather than five. If you want extra guidance on swap choices that usually derail a run, the guide on avoiding common mistakes in a numeric ranking game maps each mistake to the swap that causes it.
Match Your Input Method to the Swap You Just Chose
The reducer that applies your swap is the same for every input method, so the choice of pointer, touch, or keyboard is purely ergonomic. Each path has a moment that fits a different kind of decision.
| Input Method | Best Moment to Use It | What It Actually Does |
|---|---|---|
| Pointer drag | When the two cards you want to swap are visually adjacent on the rail | Press the first card, drag it over the second, release; the two cards exchange positions |
| Touch tap-to-tap | When the device does not support browser drag, or when the two cards are far apart on the rail | Tap the first card, then tap the destination card; the same exchange happens |
| Keyboard | When you want to keep your eyes on the printed ranks rather than the pointer | Tab into the rail, focus a card with the Arrow keys, press Enter or Space to select, then press an Arrow key to swap with the neighbour |
Pointer users see the selected card visibly lifted under their cursor. Touch users see the selected state through a native pressed attribute, so they can confirm their pick before committing to the second tap. Keyboard users get a visible focus ring on every card and roving focus that follows the logical cursor after each arrow swap, which keeps the eyes on the numbers rather than on the mouse pointer. All three paths share the same pure swap reducer, which means your decision logic does not have to change when you change devices.
When an Incorrect Check Still Tells You Something
An incorrect check does not end the round. It records a failure signature built from the round identifier and the exact order on the rail at the moment you checked. Re-checking the same unchanged wrong order does not add a second failure — the signature has not changed, so the engine deduplicates. Rearranging the cards and then submitting a genuinely different wrong order, however, creates a second distinct signature and closes the run.
This is useful to keep in mind when you choose your next move. If a check fails and the on-screen status is repairable, you can keep swapping without fearing a duplicate penalty. If a check fails and the status indicates a deadlock, your next decision is to press Restart and reason through the round from the unsorted opening permutation rather than from the locked arrangement. Restart returns the rail to its original permutation and resets the local best score to its unchanged value, so a fresh start is never a sunk cost.
Two practical habits make the most of this design. First, when a check fails, do not immediately swap two random cards — re-read the ranks and confirm which slot is wrong, then target that slot. Second, after every confirmed correct check, wait for the next round to load before touching anything, because the focus jumps to the first new card and you want your first swap to land on the fresh rail rather than the closing one.
From Five Sorted Rails to 1,000 Points
The reward structure is fixed and predictable. A correct manifest awards exactly 200 points and immediately loads the next fixed round. There are no bonus points for fast swaps, fewer moves, or a particular input method, and no penalty for taking your time. Five correct rounds produce the maximum score of 1,000 points, and the score never changes because of animation timing, device speed, or input path.
That fixed reward structure is the reason your next step is so consistent across rounds: every cleared manifest is worth the same, every round has the same ascending target shape, and every round opens with a deliberately unsorted permutation. The "speed" in the name refers to the self-directed challenge of sorting efficiently, not to a measured reaction time. Reading first, swapping in three logical moves, picking the input method that fits the moment, and treating an incorrect check as data rather than failure will carry you through all five manifests with the same procedure.
Once you have cleared the fifth manifest, the game freezes every reducer and only Restart will return the rail to a sortable state. The optional local best score, if it is enabled, persists in browser storage through the shared GameShell and does not affect the deterministic 1,000-point route itself. Everything runs locally with React and ordinary buttons, so no account, upload, or external API is part of the run you just completed.