How Endless Cat Runner Games Work

Here is the central trick of every endless runner ever made: the cat does not move. It sits at a fixed horizontal position for the entire run. What moves is the world, sliding past from right to left at a speed the game controls. Once you know that, every other design decision in the genre follows from it.

This article explains how that works, why it is done that way, how obstacles are generated without producing impossible situations, and how difficulty is tuned with essentially one number. It is written for players who want to understand what they are up against, and for anyone thinking about building one.

Why the cat stays still

Keeping the player fixed solves several problems at once.

• No camera. If the player never moves horizontally, there is nothing to follow. A camera system is one of the fiddliest parts of a platformer, and this removes it entirely.
• Cheap collision checks. Only objects near the cat's fixed position can possibly collide with it. Everything else can be ignored without any spatial data structure.
• A constant reaction window. The distance from the right edge of the screen to the cat is fixed. Divide it by the scroll speed and you have exactly how long the player has to react - a number the designer can tune directly.
• Trivial object management. Anything that scrolls off the left edge is deleted; anything needed is created off the right edge. The list of live objects stays small no matter how long the run lasts.

The illusion of running is done entirely with animation and background motion. The cat's legs cycle, the ground texture scrolls, and layers behind it move more slowly to suggest depth. Nothing about the cat's actual position changes except vertically when it jumps.

The main loop

Every frame, a runner does the same six things in the same order. The whole genre is variations on this list.

1. Measure the time since the last frameMovement is multiplied by this elapsed time so the game runs at the same speed on a 60Hz laptop and a 120Hz phone. A runner that skips this step is twice as fast on a fast display, which is the single most common bug in amateur implementations.
2. Update the scroll speedSpeed increases as a function of distance travelled. This one value drives almost all of the difficulty.
3. Move the worldEvery obstacle, collectible and background element shifts left by speed multiplied by elapsed time. The background layers use a fraction of that speed to produce parallax.
4. Update the cat verticallyGravity is added to the cat's vertical velocity, the velocity is added to its position, and the position is clamped when it reaches the ground. This is the only physics in most runners.
5. Check collisionsCompare the cat's box against nearby obstacles and collectibles. A hit on an obstacle ends the run; a hit on a collectible adds score and removes the item.
6. Spawn and cullDelete anything past the left edge, and decide whether to create something new at the right edge.

How speed becomes difficulty

The reaction window is the whole game, and it is a simple division. If the screen is 900 pixels wide and the cat sits 200 pixels from the left, an obstacle appearing at the right edge has 700 pixels to travel. At a scroll speed of 300 pixels per second, you have about 2.3 seconds. At 600 pixels per second, you have about 1.2 seconds. At 900, you have under 0.8.

Human reaction time to a clear visual signal is a meaningful fraction of that last figure, which is why high-speed runner play stops being reaction and becomes anticipation. You are no longer responding to the obstacle you can see - you are responding to the rhythm you have learned.

Most runners raise speed on a curve that flattens out rather than climbing forever, because a genuinely unbounded speed makes the game impossible in a way that feels arbitrary rather than challenging. The curve, and why it usually approaches a ceiling, is covered in detail in how progressive difficulty works in runner games.

Generating obstacles without generating disasters

Pure randomness produces unplayable games. If a runner places obstacles at random intervals, it will eventually place two so close together that no jump can clear both, and the player will lose to something they could not have avoided. That single experience does more damage to a game than a dozen fair deaths.

Real runners use constrained generation. The rules are usually some version of the following:

• A minimum gap derived from current speed. The next obstacle cannot appear closer than the distance the cat covers during a full jump, plus a margin. Because this is calculated from the live speed, it tightens automatically as the game gets faster without ever becoming impossible.
• Category exclusions. Certain combinations are forbidden outright. In Cat Dash, a hanging awning is never placed in the same slot as a ground crate, because that would require ducking and jumping simultaneously.
• A grace period at the start. The first few seconds of a run are deliberately empty, so you are never killed before you have settled.
• Weighted selection, not uniform. Obstacle types are chosen with weights that shift as the run progresses, so harder types appear gradually rather than from the first second.

Some games go further and abandon per-obstacle generation entirely. Cat Obstacle Rush shuffles hand-authored patterns instead, which guarantees fairness because a person played every sequence, and has the side effect of making the game reward recognition as well as reflexes.

Collectibles are level design, not decoration

Coins and fish in a runner are usually placed along the arc of a correct jump. This is not an accident and it is not only about score. The collectible is a visual instruction: it tells you where the game expects your jump to peak.

If you keep passing underneath the fish in Cat Dash, your jumps are late. If you sail over the coins in Cat Hop, you are charging too long. The feedback arrives immediately and without any text, which is exactly the kind of teaching an arcade game needs.

The second function of collectibles is to create voluntary risk. A coin placed slightly off the safe route asks a question: is this worth it? A game with no such question is just an obstacle course.

Collision, and why the boxes are smaller than they look

Runners almost universally use axis-aligned bounding boxes - simple rectangles compared for overlap - because the check is four comparisons and needs no mathematics beyond that. What is less obvious is that the boxes are usually smaller than the sprites they represent.

A cat's drawn shape includes ears, a tail and whiskers. If the collision box covered all of that, players would die to a tail clipping a crate, which feels wrong because the tail is visually incidental. Shrinking the box to the cat's body makes the game feel fair without anyone being able to say why. The equivalent trick goes the other way for collectibles: their pickup boxes are often slightly larger than they look, so a near miss counts as a catch.

The full explanation of how these checks work, including why circles are sometimes used instead, is in how collision detection works in arcade games.

What this means for playing better

Understanding the machinery changes how you play in three concrete ways.

Watch the right edge, not the cat

Every piece of information in a runner enters from the right. The cat does exactly what you tell it and never surprises you. Moving your gaze rightward is the single biggest improvement most players can make.

Press earlier than feels correct

Your reaction time has to be subtracted from the reaction window, and at speed that is a large fraction of it. An obstacle that looks like it is at the right distance is already too close.

Trust the generator

Because obstacles are constrained, there is always a solution. If a situation looks impossible, you have misread it - usually by assuming an obstacle needs a jump when it needs a duck.

Key Takeaways

• The cat is fixed in place; the world scrolls past it. Everything else in the genre follows from that decision.
• Difficulty is controlled almost entirely by scroll speed, which sets your reaction window by simple division.
• Obstacles are generated under constraints - minimum spacing based on live speed, forbidden combinations, and a grace period at the start - so impossible situations do not occur.
• Collectibles are placed on the correct jump arc, which makes them a silent tutorial as well as a score source.
• Collision boxes are smaller than the drawn cat, which is why the game feels fairer than a pixel-perfect check would.

Frequently Asked Questions

Does the cat really not move in a runner?

Not horizontally, in almost every implementation. It moves vertically when jumping. The forward motion is the world scrolling past and the running animation playing.

Why do endless runners have no ending?

Because the score is the point. A finish line would cap the score and turn the game into a level, which is a different genre with a different appeal.

Can an endless runner generate an impossible obstacle?

A badly built one can. A properly built one cannot, because the minimum spacing between obstacles is derived from the current scroll speed and the cat's jump distance, with a safety margin.

Why does the background move more slowly than the ground?

Parallax. Distant objects appear to move more slowly, so drawing background layers at a fraction of the scroll speed creates a sense of depth with almost no computational cost.

Is there a maximum speed in a runner?

Usually yes. Most games approach a ceiling rather than accelerating forever, because unbounded speed produces an ending that feels arbitrary rather than earned.

Why do I sometimes die when it looked like I missed the obstacle?

Either the obstacle's collision box is larger than its drawn shape, or the cat's box is larger than you assumed. Well-tuned games shrink the player's box specifically to avoid this feeling.