Tappy Color

Tappy Color is a free tap-to-survive arcade game for iPhone and iPad. Built in the summer of 2016 by two college kids, shelved for eight years, remastered in 2024, and refactored from the ground up in 2026. Ten years, three versions, same pixelated clownfish.

How the game works

The water level is constantly dropping. If it falls too low, Tappy dies. The whole game is keeping him alive.

• Blue screen. Tap as fast as you can. Each tap raises the water level.
• Red screen. Stop tapping. Tapping while red drops the water suddenly — the trap.
• Starfish. Tap it for invincibility. While invincible, red won't appear, so tap freely.
• Difficulty. The color changes get faster as your score climbs. What starts as a reaction game becomes a test of impulse control.

Game Center leaderboards track global rankings. No subscriptions, no ads, no in-app purchases.

Why the studio shipped this

Tappy Color exists because the studio doesn't believe small things should die in folders. In 2016 Chris Greer and Blake Crosley shipped a finished, working game to the App Store, and then life moved on — the project sat untouched for eight years while Swift evolved past it and the original code became archaeological.

The honest reason to remaster it wasn't business strategy. The reason was that the game still worked, the design still held up, and it deserved to be playable on a current iPhone. The studio's whole posture is shaped by that instinct: ship the smallest version that works, live with it, then come back and improve the part that's actually used.

The full personal case study — the credits, the design decisions, the engineering archaeology — lives on blakecrosley.com/work/tappy-color. This page is the studio's product overview, focused on what the app is now and how it was made.

How it was made

The 2016 original was Swift 2.x, UIKit, and Core Animation, with a hand-rolled GIF decoder that Chris wrote because no good Swift library existed at the time. He parsed each frame with ImageIO, extracted timing metadata, found the greatest common divisor for optimal playback, and returned a proper UIImage animation. It worked then. With minor syntax updates, it still works today.

The 2024 remaster started with 300 compiler errors. Swift 2 syntax doesn't exist anymore — every NSBundle became Bundle, every NSURL became URL, every CGAffineTransformMake* function was replaced with an initializer. The migration was tedious, not heroic. The pay-off was a codebase that could compile against current Xcode and run on iOS 16.4+ with all the modern APIs available.

The 2026 pass was the architecture clean-up. The studio extracted a dedicated GameModel class so the view controller only handles UI and the model handles logic. Four independent timers became one master game loop — one tick that dispatches to every subsystem, inspired by John Carmack's game engine philosophy. The difficulty curve, which originally called tanh() on every tick, became a pre-computed array lookup. Score labels stopped updating every frame and started using dirty flags. Magic numbers moved into a documented GameConstants.swift.

What still holds up from 2016

Eight years is a long time in mobile development, but some of the original patterns survived the rewrite without changes.

The difficulty ramp uses a hyperbolic tangent function instead of a linear curve — gentle at first, steep in the middle, plateaus at a ceiling. It feels fair even when it's hard. The studio kept the math; only the implementation changed.

The fish movement system reads from Core Animation's presentation layer instead of the model layer, so the on-screen position is accurate even mid-animation. This is the kind of small Core Animation gotcha that's easy to get wrong and hard to debug. Chris solved it in 2016 and the solution didn't need to change.

The hand-rolled GIF decoder is still in the codebase. The studio could have replaced it with a third-party library at any point and chose not to. It does exactly what's needed, has zero dependencies, and works.

What the studio learned shipping this twice

Two things. First, that small games age better than big ones. Tappy Color is 12 pages of game state and a few thousand lines of code. The migrations were possible because the surface was small. A 2016 codebase ten times this size would have been a rewrite, not a migration.

Second, that the original game-design instinct was correct. The first version Chris and Blake shipped was just a screen that turned green when you tapped and red when you failed. Chris kept pushing for a character that players would care about. The pixel-art clownfish was the thing that took the game from "tap test" to "the one with the fish." At the time it felt like the studio wasn't shipping fast enough. In hindsight it was the thing that made the game worth remembering.

Frequently asked

What is Tappy Color?

A free tap-to-survive arcade game for iPhone and iPad. The water level is constantly dropping; tap on blue to keep it up; stop tapping when red appears. Score climbs as long as Tappy stays alive.

Who made Tappy Color?

Chris Greer and Blake Crosley built the original in the summer of 2016. The 2024 remaster and the 2026 refactor were done by Blake Crosley at 941 Apps, the studio he operates.

Is Tappy Color free?

Yes. Free on the App Store. No subscriptions, no ads, no in-app purchases. Game Center leaderboards are included.

What devices does it run on?

iPhone and iPad running iOS 16.4 or later. The remaster dropped support for older devices to take advantage of modern Swift and iOS APIs.

Why is the game called Tappy Color?

Because tapping happens at the speed of color. The screen switches between blue and red without warning; tapping blue keeps you alive, tapping red drops the water. The whole game is a race between your reflexes and your impulse control.

What technology was used to build Tappy Color?

Native Swift and UIKit, with Core Animation for the fish movement and Core Graphics for the hand-rolled GIF decoder. Game Center for leaderboards. The 2016 codebase was Swift 2.x; the 2024 remaster migrated everything to Swift 5; the 2026 pass extracted a clean GameModel and a single Carmack-style game loop.

Where is the full case study?

Blake's personal case study with credits, code snippets, and engineering archaeology lives at blakecrosley.com/work/tappy-color. This page is the studio's product overview.