Tail Recursion: the snake that only moves when your program says so

Tail Recursion is a programming puzzle game built around a simple, ruthless rule: you never steer. There are no arrow keys, no last-second corrections, no “I meant to turn left.” Your snake sits still until you assemble a program that tells it what to do, and then it executes that logic exactly—including the part you got wrong.

The result is a game that feels like equal parts puzzle box and debugging session. You don’t solve levels by drawing a route; you solve them by building a decision-making machine that can handle whatever the level throws at it, one tick at a time.

Build the program, not the path

Each level gives you a canvas where you drag blocks onto a graph and wire them together. Think of it like a compact visual programming language designed specifically for grid-based movement and tactical decision-making. You’ll use action blocks such as Move Forward and Turn Left, as well as structural blocks like Repeat N Times and If / Else.

Just as important are the “information” pieces: sensor blocks like Wall Ahead?, Food Ahead?, and Door Ahead? allow your program to read the world instead of guessing. Then memory-style blocks like Store and Recall let you keep state—effectively turning your snake into a tiny computer with variables.

Once your graph is assembled, you hit play and watch it execute in discrete steps. It’s satisfying when it works, and educational when it doesn’t—because Tail Recursion makes the consequences of logic errors immediately visible.

Sensors are how your snake understands anything

In Tail Recursion, your program doesn’t have magical knowledge of the map. If you want it to avoid walls, seek food, or deal with doors and gated layouts, you need to explicitly sense those conditions and branch accordingly.

This creates some of the game’s best “aha” moments. A couple of well-placed blocks paired with a single sensor can produce surprisingly robust behavior—like a compact routine that can hug a perimeter indefinitely. The puzzle is figuring out which minimal set of logic elements produces the behavior you need.

Your body is your hardware (and that’s a problem)

Tail Recursion adds a clever twist: your snake’s capabilities are physical. Certain body segments grant functions, and those functions come with trade-offs.

  • Sensor Segments let you see.
  • Memory Segments give you variables.
  • Processor Segments increase your per-tick budget.

These aren’t abstract upgrades—they’re literal length. More capability often means a longer snake, and length is dangerous in any snake-adjacent game. So optimization isn’t just about elegance; it’s also about survival. The game constantly pushes you to balance “more tools” versus “more risk.”

Tick-by-tick execution you can actually read

One of Tail Recursion’s strongest features is its clarity while running. The graph lights up as your logic executes: you can see which block fired, what sensors returned, what budget was spent, and what action the snake took.

When things go wrong, the game doesn’t leave you guessing. It tells you what kind of failure happened—like crashing into a wall versus colliding with your own body—which matters because those mistakes require very different fixes. It’s a debugging loop that feels fair: the game is strict, but it’s also transparent.

70 puzzles now, with 100 planned

Content-wise, Tail Recursion is positioned as a substantial puzzle game. It starts with six tutorials to onboard you into its block-and-graph logic, then ramps up into 70 handcrafted puzzles built around different map patterns and constraints—corridors, spirals, comb-like layouts, keyed vaults, gated floors, and more.

Some stages even remove sensors, forcing a fully planned route: no conditional logic safety net, just pure premeditated execution. A free update is planned to add another 30 puzzles, bringing the total to 100.

Scoring encourages elegant solutions (and replayability)

Each level includes a budget-based scoring system tied to difficulty. Actions cost budget, and slow or bloated runs spend more. In a neat inversion of many games, blocks like loops, conditions, and sensors are free—they’re the tools you use to save budget by making your program smarter instead of longer.

Apples pay for themselves by covering the detour cost to fetch them, turning route planning into a mini economy problem: when is it worth grabbing resources, and when is it better to stay lean? Because you can replay levels to improve your score, Tail Recursion naturally supports a “solve it, then optimize it” rhythm.

Free Play, custom levels, and moddable Lua blocks

Beyond the main puzzle set, Tail Recursion includes extra modes and tools that broaden its appeal:

  • Free Play provides an endless board with a combo score—more arcade-like, but still driven by your program.
  • Custom levels are supported via simple file drops: place .level files into a folder and they show up in the menu.
  • Modding goes deeper than level sharing: blocks are written in Lua and hot-reload while the game is running, inviting experimentation and community-created logic components.

Mac performance and system requirements

Tail Recursion is built for Apple Silicon on Mac, keeping the footprint small and the requirements straightforward.

Minimum Mac Requirements

Minimum:

  • Requires an Apple processor
  • OS: macOS 11.0 (Big Sur)
  • Processor: Apple M1 or later (Apple Silicon)
  • Memory: 2048 MB RAM
  • Graphics: Metal-capable GPU (built in)
  • Storage: 150 MB available space
  • Sound Card: Any

Recommended Mac Requirements

Recommended:

  • Requires an Apple processor
  • OS: macOS 13.0 or later
  • Processor: Apple M1 or later (Apple Silicon)
  • Memory: 4096 MB RAM
  • Graphics: Built-in
  • Storage: 150 MB available space
  • Sound Card: Any

Who is Tail Recursion for?

If you enjoy puzzle games that reward iteration—build, run, observe, refine—Tail Recursion is in its element. It’s approachable thanks to its drag-and-wire interface, but it steadily grows into something that feels like real programming: state, branching logic, optimization constraints, and the occasional humbling bug.

Most importantly, it nails the core fantasy: writing a small “brain,” pressing play, and watching it think. When your snake finally glides through a map flawlessly on logic alone, it doesn’t feel like you got lucky—it feels like you engineered something that works.