Read the traffic jam as a dependency chain
A puzzle that hides nothing from you
Gridlock puts the entire problem on screen from the first second. There are cars and longer vehicles on a 6×6 board, every piece has a fixed orientation, and one highlighted taxi sits on the row leading to the exit. Your job is to clear a horizontal corridor to the right edge and drive the taxi out. There are no hidden clues, delayed reveals or values to discover later. That openness is exactly what gives the puzzle its character: seeing every piece does not mean seeing the correct order.
The challenge comes from dependencies. A vertical vehicle may block the taxi directly, yet it cannot move because another car occupies the cell it needs. That second car may depend on a third gap somewhere else. A strong solve begins when individual pieces stop looking like isolated objects and start looking like a network. To free A, you need B out of the way; B requires space created by C; C can move only after D changes lanes within its own axis. Gridlock is ultimately about arranging those conditions in the right sequence.
The rules are short enough to learn immediately
Every vehicle occupies two or three cells. Horizontal vehicles slide only left and right. Vertical vehicles slide only up and down. Nothing rotates, changes lane, overlaps another piece or passes through an occupied cell. If several consecutive cells are open, a vehicle may slide to any reachable position along its lane. That whole continuous slide is one move, whether the piece travels one cell or several. Orientation and obstacles therefore define all legal destinations at any moment.
The taxi follows those same movement rules while it is on the board. Its only special property is the open exit on the right side of its row. When no vehicle remains between the front of the taxi and that edge, you can slide it out and complete the puzzle. The final exit is also one move. This definition matters because it determines par. Gridlock does not count pixels, cells crossed or repeated tiny nudges; it counts complete decisions to reposition one vehicle. A long slide can be more efficient than two short ones even when both end in familiar-looking states.
Your first scan: identify the real blockers
At the start of a game, avoid moving the first car that happens to have room. Look along the taxi row instead. Mark every vertical vehicle crossing the cells between the taxi and the exit. Those are the direct blockers. If they disappeared, the game would already be over. For each blocker, ask where it could move and how much room it needs. A length-three vehicle demands a different corridor from a length-two car, and a single empty cell can be useless when it sits on the wrong end.
This scan reduces a crowded board to a few concrete questions. Perhaps two vehicles block the exit row, but one can move immediately while the other needs two free cells below it. The second one is probably the real problem. Now inspect those two destination cells. What occupies them? Can that piece move? What blocks its own route? Many good Gridlock solutions begin far away from the taxi because the first useful action creates a gap that will later travel through the board as several vehicles reuse it.
Read chains of blockage rather than isolated cars
One practical way to think is in conditional sentences. “To move this truck down, I need the lower cell free.” “To free that cell, I need the blue car farther left.” “To send that car left, I first need the vertical piece in column one to move.” Once the chain reaches a vehicle that actually has usable space, you have found an entry point. Make that move, then walk back through the dependencies toward the taxi.
This habit prevents one of the most common mistakes: treating “legal” as a synonym for “useful.” A loose board may offer many valid slides even though only a small subset contributes to a shortest solution. Moving something merely because it can move creates noise and often forces you to reverse the decision later. A dependency chain gives every action a reason. That discipline becomes increasingly valuable on hard boards, where the number of legal options grows much faster than the number of moves that truly matter.
The scarce resource is not movement; it is space
Gridlock becomes much easier to understand when empty cells are treated as a shared resource. A gap does not belong to the closest vehicle. Another piece may need that exact area two moves later. Sliding a car into an open space can look like progress while consuming the only corridor a long truck needs to clear the taxi row. Before moving, ask two questions: what does this action make possible, and what does it make impossible?
Length-three vehicles make the idea especially visible. They need larger clear runs and cannot exploit every small pocket. They can also act like moving walls, blocking more than one useful route depending on where they stop. When planning a sequence, pay attention not only to where a vehicle ends but to what cells it leaves empty behind. Often the important result of a move is the vacancy it creates. The car itself is almost secondary; what matters is that usable space has been transferred from one region of the board to another.
What par means in Blupoli Gridlock
Every Gridlock level in Blupoli displays a par value. It is the minimum number of moves required to get the taxi out from that exact starting position. It is not a hand-authored recommendation, a rough difficulty estimate or an average player target. The engine explores valid board states with breadth-first search and finds the shortest solution under the same movement definition used during play: moving one vehicle to any reachable position in its lane costs one move, and exiting the taxi costs the final move.
Breadth-first search fits this task because every transition has the same cost. The solver first explores everything reachable in one move, then two, then three, continuing layer by layer. The first time it reaches a state with a clear exit, that depth plus the taxi exit establishes the shortest possible solution. This makes the number beside “Par” a verifiable property of the level. If you finish exactly at par, there is no shorter sequence under the rules you were given.
Playing for par changes the puzzle
Solving a board and solving it at par feel surprisingly different. To finish, any successful chain is enough. To match the minimum, you must remove redundant setup, avoid unnecessary reversals and decide how far each vehicle should travel when you touch it. If a car can move one, two or three cells in a single action, stopping halfway may force another move later. Yet sending it all the way to an edge can occupy space that another piece needs. Distance within one move is therefore a strategic choice, not cosmetic animation.
If you complete a level above par, inspect the vehicles you moved more than once. Repeating a piece is not automatically wrong; some solutions genuinely require it. But a car that goes right and soon afterward comes back left is a useful warning. Could the first move have waited? Could the car have stopped somewhere else? Was its temporary parking place stealing a critical gap? Par turns the move counter into a diagnostic tool: it helps you study why a valid route was longer than necessary.
Why the board stays 6×6
Many Blupoli games support several sizes because their core rule scales naturally. In 15 Puzzle, for instance, a larger grid is still recognisably the same puzzle with a broader state space. Gridlock is different. Its spatial language is tightly connected to the compact 6×6 board: vehicles of length two and three, short lanes, one obvious exit row and blocking chains that remain readable at a glance. Making the board larger just to populate a size selector would add area without guaranteeing more interesting decisions.
So Gridlock has one honest board format and puts variety where it changes the experience: vehicle arrangements and logical difficulty. This is a deliberate exception to Blupoli's general preference for multiple variants. A stable board also helps learning. When you move from Easy to Expert you do not need to relearn scale or visual proportions. Your attention can stay on deeper dependencies, more contested space and more plausible alternatives. The puzzle gets harder because the traffic logic gets harder, not because the canvas simply becomes bigger.
Four difficulties, not just four move counts
Easy, Medium, Hard and Expert use increasing par ranges, but minimum length is only one part of the classification. Two positions can share the same par while feeling very different if one offers only a few obvious branches and the other presents many convincing wrong choices. Higher difficulties therefore use denser templates with more vehicles and more intermediate states for the solver to explore. The label aims to represent the reasoning burden, not only the number of actions in a known solution.
Easy focuses on short blocking chains and low par. Medium introduces more dependencies and more legal moves that do not help. Hard uses denser configurations and deeper sequences. Expert starts from particularly tangled states and accepts longer shortest routes, while still checking each generated candidate before it is used. This matters because procedural generation can easily confuse “more pieces” with “better puzzle.” Difficulty should emerge from several reinforcing properties: depth, density, branching and how constrained the critical spaces are.
How levels are generated without trusting blind randomness
The generator does not scatter vehicles randomly and hope a solution exists. It begins with valid arrangements designed around the game's geometry and performs legal reverse walks from solvable states. Every candidate therefore keeps vehicles on the board, preserves fixed orientation and avoids overlap by construction. But construction alone is not enough. After a position is mixed, the solver evaluates it again, measures its par and rejects candidates that do not fit the requested difficulty profile.
That separation between generation and verification is a central quality rule. A board can look plausible and still be trivial, impossible or repetitive. Independent solving turns procedural generation into something testable. For Gridlock, the important promises are precise: the state must be legal, the taxi must not already have an open exit, the puzzle must be solvable, and its exact shortest distance must fall inside the intended difficulty range. The generator proposes; the solver decides whether the proposal is good enough to publish.
A hint follows an optimal route from where you are now
If you get stuck, the Hint action does not point at an arbitrary movable piece or use a shallow rule such as “move the nearest blocker.” Gridlock solves your current board and retrieves the first move of a shortest route from that exact state. If the exit is already clear, the hint tells you to send the taxi out. Otherwise it highlights both the relevant vehicle and a valid destination that leads into an optimal continuation.
This remains useful even after you have departed from the generated optimum. The engine does not insist that you return to some memorised original path; it recalculates from the position you actually created. The most educational way to use that information is to pause before executing it. Ask why the suggested move matters. Does it free a direct blocker? Preserve a gap for a long vehicle? Avoid a reversal you were about to create? Turning one hint into a reason gives you a pattern you can recognise on the next board.
Drag, select, or use the keyboard — the rule stays the same
On touch screens you can drag a vehicle along its axis. The engine limits the gesture to positions the piece can truly reach, so a fast swipe never jumps through another car. You can also tap a vehicle to select it and reveal legal destinations. Choosing one of those markers makes a complete move. This second method is useful when you want precision, when a piece has several possible stopping points, or when you simply prefer taps to a long drag.
The same destination model creates a clear keyboard path. Each vehicle is an accessible control with a description of its orientation, length and lane. Activating it exposes labelled destinations, so the interaction does not depend on colour or on watching motion. Arrow keys also support nearby moves along the correct axis. Visible focus, ARIA labels and reduced-motion behaviour are part of the same board rather than a separate accessibility mode. Different inputs express the same puzzle decisions and lead to the same legal states.
Mobile Gridlock should still feel like one complete board
A spatial puzzle becomes harder for the wrong reason if the interface crops rows or forces you to mentally stitch together pieces across a scroll. Gridlock uses Blupoli's shared Game Stage but sizes the board from the actual space allocated to it. On phones it uses almost all available width while keeping a square 6×6 geometry. The exit sits alongside the board without creating horizontal overflow. On tablets and desktop, the puzzle grows to a comfortable maximum and stays fully inside the play region.
The priority is straightforward: the relationship among all vehicles must remain visible. Difficulty controls, move count, par and actions belong to the platform shell and do not sit on top of the traffic. In compact landscape layouts, secondary explanatory copy can disappear before the board is allowed to become cramped. That hierarchy matters more than decorative effects. Gridlock asks you to compare gaps and lanes constantly; if the UI hides a row or makes boundaries ambiguous, it is working against the logic the game is supposed to train.
A Blupoli board, not a copy of another traffic table
The sliding-vehicle mechanic is clear enough that it does not need the visual identity of any particular implementation. Blupoli's version uses the current product palette, clean surfaces, simple geometry and small identifiers that keep similar pieces distinguishable without turning the board into a detailed car illustration. The taxi receives a distinct treatment because it has a distinct semantic role: it is the objective. Other vehicles share a controlled visual language and stay readable in both light and dark themes.
Movement feedback is intentionally restrained. Selection, dragging and hints each get enough state change to be obvious, but the board does not rely on decorative gradients, heavy shadows or simulated bodywork. In a puzzle about space, every edge carries information. Knowing exactly where a truck ends and an empty cell begins is more valuable than visual realism. Personality comes from composition, the restrained candy-like Blupoli colours and responsive interaction, while the underlying grid remains precise.
Persistence means returning to the same jam
When you leave a game and come back, Gridlock stores the seed, difficulty, template, current position of every vehicle, move count and the history needed to continue. Restoration does not blindly accept whatever happens to be in storage. The engine regenerates the canonical puzzle from its seed and checks that the saved state is still a legal arrangement. That prevents incompatible or corrupt layouts from silently becoming playable and follows the same local-first contract as the rest of Blupoli Puzzles.
Daily challenges use the same determinism. A daily identifier and difficulty produce a stable seed, so reloading does not give you a different traffic jam and the displayed par continues to describe the published position exactly. The shared platform owns timing, results, progress and streaks. Gridlock's engine owns rules, vehicle movement, generation and solving. Keeping that boundary clean means platform improvements can benefit the game without every engine inventing its own persistence and progression systems.
Undo is not a failure; it is a way to inspect a hypothesis
Gridlock includes Undo and Redo because testing a spatial idea is part of learning. You may believe moving a truck opens a chain, only to discover two steps later that the space was needed elsewhere. Rewinding lets you inspect that hypothesis without reconstructing the entire board. For casual solving, it removes unnecessary friction. For players pursuing clean achievements, the platform can still distinguish a direct solve from one that used recovery tools.
Restart and New Game deliberately mean different things. Restart restores the exact starting arrangement of the same level and resets the move count, which is ideal when you now understand the solution and want another attempt at par. New Game generates a different puzzle inside the chosen difficulty. Keeping those actions separate avoids a subtle but frustrating ambiguity. When you restart a problem you are studying, it should remain the same problem. When you ask for something new, the system should actually change the challenge.
Stars reward efficiency without blocking completion
Par is the perfect reference point. Finish in exactly that many moves and you keep five stars. Each move above the minimum reduces the rating progressively, but going over the star budget never locks the board or invalidates the solve. You can keep working until the taxi leaves. This gives the game two compatible goals: completing the traffic jam is meaningful on its own, while optimisation adds another layer once the rules feel comfortable.
The result records moves, difficulty, stars and useful level metadata such as par and solver complexity. That information can feed progress without turning the play surface into a technical dashboard. Gridlock also emits game-specific achievement signals for things such as an exact-par solve or a route without certain reversals. The intention is not to enforce one “correct” style. These are optional targets for players who want a reason to revisit a solved board and refine their sequence.
A reliable routine for Easy boards
On Easy, try a four-part mental loop. First, identify direct blockers on the taxi row. Second, check whether any can already move far enough to leave the corridor. Third, for each blocker that cannot move, inspect the exact cells it needs and identify what occupies them. Fourth, move the first piece in that dependency chain that has genuinely usable space. After every action, rescan the taxi row because one newly opened cell can change which chain deserves attention.
You do not need to hold the entire solution in memory. It is enough to have a reason for the next move and avoid consuming scarce space casually. When two destinations seem equivalent, prefer the one that preserves more future options. Edge positions can act as temporary parking when they remove a car from the central conflict area, but they can also trap useful movement if chosen too early. After a few games you will begin to recognise recurring structures without memorising particular layouts.
How reasoning changes on Hard and Expert
Higher difficulty boards often contain competing dependencies rather than one neat chain. The same gap may be needed by one vehicle now, a second vehicle later, and finally the direct blocker. It helps to think in phases: what temporary configuration must exist before I can actually attack the exit row? Sometimes the taxi itself should remain untouched until the final move even when it has partial room in front, because shifting it early consumes space without solving a dependency.
You will also see more plausible wrong moves. That branching is part of the challenge. The board does not stop you from making a bad decision; it offers choices whose consequences differ several moves later. The solver may examine many states to prove the minimum, but a human does not need to imitate exhaustive search. Look for strong constraints. A truck with only one reachable destination tells you more than a car with four. A blocker requiring two contiguous cells imposes a stronger condition than one needing a single gap.
Common mistakes are useful evidence
The first common mistake is moving something “to make room” without knowing who needs that room. The second is sliding a vehicle only one cell when the planned chain will require it farther away, wasting another move later. The third is using a critical gap as temporary parking. The fourth is staring so hard at the taxi row that you miss the dependency starting in a distant corner. All four come from the same habit: optimising the current picture rather than imagining the state you need next.
When a line of play gets stuck, do not erase everything mentally. Inspect the impossible condition you created. Perhaps a vehicle must move up but its only destination is now occupied. When did you occupy that space, and why? If the responsible move was not essential, you have found the detour. This kind of causal review is more valuable than memorising sequences. A good Gridlock puzzle should teach relationships that transfer to new boards, not the fact that “vehicle seven goes left” in one specific arrangement.
Where Gridlock sits among other Blupoli puzzles
If you enjoy planning movement in compact spaces, 15 Puzzle also makes the position you leave empty as important as the tile you move, although its entire board revolves around a single vacancy. Ball Sort shares another idea: a legal action can still be strategically poor when it consumes a container you will need later. In each case, visible capacity matters because of the future options it preserves.
Polypivot approaches spatial planning from a different direction, where transformation changes a piece's relationship to the board. Gridlock removes rotation entirely and turns that restriction into its identity. Every vehicle knows its axis forever, so the problem is coordinating many small degrees of freedom. Playing these games side by side reveals a common theme in Blupoli's Spatial category: position matters because it determines what becomes possible after the next action.
Why the solver is part of the design, not merely a test tool
It would be possible to use a solver only during development and ship a fixed collection of prechecked boards. Keeping the solver in the engine provides practical benefits. It can verify every generated position, calculate par when a level is created, and produce a correct hint after any legal sequence a player invents. It also gives future changes a safety net: new templates or generator adjustments can be tested automatically against the same movement model used in production.
None of this means the play experience should look like a computer-science demonstration. Players see cars, gaps, a taxi and a move counter. The technical machinery exists to make that simple surface trustworthy. A solver is valuable only when it models the game accurately. If Gridlock counted every single cell crossed as a separate move while the interface allowed multi-cell slides as one action, its par would be meaningless. The algorithm and the interaction must describe the same game.
How to improve after your first successful solve
Once you can consistently finish Easy boards, do not rush straight to Expert. Replay one solved level and try to explain every movement before you make it. Name the dependency: “this car moves because the truck needs its cell,” or “this truck goes all the way up because leaving it in the middle would cost another move.” This verbal discipline exposes actions you are taking from habit rather than necessity. Then compare your count with par and focus only on the difference.
If you are one move over, the mistake is often local: a vehicle moved twice where one well-chosen destination would have been enough. If you are several moves over, the issue is more likely structural. You may have followed the wrong dependency chain and then repaired the board. Use Undo or Restart to test an alternative, not to brute-force every possibility. Gridlock rewards a small number of thoughtful experiments far more than constant shuffling because every extra motion changes the scarce-space economy.
Why a small board can support repeated play
A fixed 6×6 format might sound limiting until you consider how many relationships can change without changing the canvas. Vehicle length, orientation, lane, starting position and the way several pieces compete for the same gaps create very different dependency graphs. A board with eleven vehicles can feel completely unlike another board with eleven vehicles because the important question is not the count; it is which moves unlock which other moves.
Deterministic generation also means repeatability and variety can coexist. A daily puzzle stays stable long enough to study and compare with your own previous attempt, while a fresh game can use a different seed to produce another verified state. Because the solver measures the result rather than trusting a label attached to a template, new arrangements can join the pool without weakening the promise behind difficulty or par. The fixed board becomes a common language for many different traffic problems.
The real goal is to see future space
At first, Gridlock looks like a game about moving cars. After a while, the cars become markers for something more abstract: future space. You start noticing that an empty pair of cells below a truck is not simply “free”; it has a likely future use. A car parked on the edge may be valuable because it is temporarily absent from the central economy. A move that appears to take the taxi backward may still be correct if it transfers space to a blocker that must move first.
That shift in perception is the satisfying part. The board has not changed, and no new rule has been introduced, yet you begin to read more information from the same picture. The strongest Gridlock moves often look obvious only after you understand which gap they are creating for a later piece. Playing for par sharpens that skill because the minimum solution leaves little room for purposeless motion. Every action tends to have a specific job in the chain.
A compact puzzle built for thinking before touching
Gridlock joins Blupoli Puzzles because it adds a form of reasoning that is instantly visual yet deep enough to reward study. You do not need a legend of symbols or a page of numerical constraints. The objective is visible from the beginning. Difficulty comes from managing freedom: every move opens some routes and closes others, empty cells change function throughout the solve, and the shortest solution emerges from a precise order rather than hidden information.
If this is your first game, choose Easy and ignore the stars for a few minutes. Trace the blocking chain, finish the board, then restart and try to remove unnecessary moves. When you begin to look at an empty cell and think “another vehicle will need that later,” you are already reading Gridlock in the most useful way. And when you want a hard check on how efficient that reading has become, par is waiting — not as the game's opinion, but as the shortest route the solver can prove.