Pullkin

Pullkin is a physics puzzle game where tiny creatures are trapped between invisible forces and fragile structures. Fire objects to break, pull, push, and reshape the balance, freeing the Pullkin.

Comment

Inspiration

We wanted to combine the immediate, hands-on fun of a slingshot physics game with the planning and replayability of a logic puzzle. The goal was to make something the whole family could enjoy together: simple enough to understand in seconds, but deep enough to keep the adults saying, “Just one more level.”

There are no menus to study and very little that needs explaining. You launch small travellers into compact levels filled with fragile walls, friendly creatures, predators, and invisible forces. The game teaches itself through experimentation: throw something, watch what happens, and adjust your next move.

What we learned

Two lessons stood out.

The hardest problem was not adding more physics. It was making physics the player could trust. Invisible magnets and wind fields can make a shot curve in satisfying ways, but they can also become frustrating very quickly. We model attraction as a spring, $F = -kx$, then cap and damp the force so that a character is pulled firmly and consistently instead of being launched unpredictably across the map.

The challenge should come from the player’s choices: which projectile to use, what to aim at, and in what order. It should not come from the simulation behaving in an unexpected way.

The second lesson was more surprising. With current models, writing the code was often the easy part. Codex could build the architecture, the level generator, and much of the game faster than we could design it. That gave us more time to focus on the part that mattered most: the game itself.

The artwork remained genuinely difficult. Creating a consistent cast, matching environments, and comic panels that clearly communicate the story required many rounds of generation and careful direction. Image generation still works best when a human with a clear visual sense stays closely involved.

How we built it

The original version of Pullkin was a single 4,400-line HTML file. It was fun to play, but almost impossible to expand.

We rebuilt it as a proper modular architecture and protected the physics with a golden-master test. The test fingerprints the deterministic simulation and rejects any change that produces a different result. This lets us improve the code without quietly changing how the game behaves.

The levels are procedurally generated. A generator builds each stage from validated pieces, then runs a full headless simulation, together with a lightweight solver, to check that the creatures can actually reach home. This gives us an endless supply of levels while ensuring that every generated stage is winnable.

On top of that, each level begins with a card draft that gives the player a new set of tools. The game also includes a silent, hundred-level comic that can be read aloud, making the story easy to follow for players of different ages.

We built the project with OpenAI’s models. ChatGPT and GPT-5.6 helped shape the concept and technical plan, Codex helped build the codebase, and the characters, enemies, backgrounds, and comic panels were also generated with AI tools. Most of the original code was generated in web UI of ChatGPT and the final breakdown and asset generation in Codex.

Challenges

Predictability

Each material breaks at a different momentum threshold, and creatures can be injured if a projectile hits them too hard. Balancing those values so that the levels feel dynamic without causing accidental deaths took longer than building the physics itself.

Determinism made that work manageable. Because the same action always produces the same result, we could tune and test the system without chasing random behaviour.

Teaching without words

The early levels introduce one interaction at a time. Later stages begin combining them. Creating a smooth difficulty curve without relying on written instructions was the part we revised most often.

Solvable randomness

A generated level is only accepted after the simulation has successfully guided a creature home. Random generation gives us variety, but verification ensures that every level can still be completed.

Chain reactions that still feel earned

The best moments happen when a single shot solves several problems at once, or accidentally releases something that should have remained locked away.

Those moments only work when the player feels responsible for the result. Success should feel clever, and failure should feel understandable. It should never feel like the game simply got lucky.

Built With

Share this project:

Updates