Chim is a 2D platformer set in a microscopic world, where you guide a small, blobby microorganism through biological structures in an attempt to reach its mother cell. The game is inspired by Ynglet, and shares a similar emphasis on fluid, free-form navigation within a biology-themed setting.
You move through cells that act as zero-gravity zones, avoid viruses that track your position, interact with explosive lysosomes, bounce off pads that redirect your trajectory, and ultimately reach the goal cell to complete each level. The world feels alive: everything wiggles, breathes, drifts, and pulses.
The defining constraint behind Chim is that the entire game contains no sprites, no textures, and no imported art assets of any kind. Every visual element on screen, from the player to the enemies to the background organisms, is rendered entirely through Godot's _Draw() function using procedural geometry: polygons, polylines, arcs, and Bézier curves, all constructed in real time.
This project started as an experiment. The visual side of game development is consistently the part I struggle with the most. I'm not an artist, and every new project hits the same wall when it comes to creating sprites and textures. I wanted to explore an alternative: what if the visuals were just code? Godot's _Draw() function offered exactly that, a way to define every shape, outline, gradient, and animation procedurally, with nothing but math and geometry.
The result is a game where every object is fully customizable through exported parameters in the Godot inspector. There are no image files to swap out; changing the look of any entity means adjusting numbers: radii, segment counts, colors, wiggle amplitudes, border widths. It also means that effects like destruction, pulsing, and organic deformation come for free, since the shapes are already defined as malleable geometry rather than static bitmaps.
Every entity in the game overrides Godot's _Draw() method and constructs its visuals from scratch each frame. As a simple example, the function below draws a circle with a filled interior and an outline. It generates the points around the circumference, draws the filled polygon, then closes the loop and draws the polyline on top. This same pattern (generate points, fill, outline) scales up to every entity in the game, from the player's spline-based trail to the virus's spiked body to the lysosome's pulsing oval.
private void drawStandaloneCircle(
Vector2 center, float radius,
Color outlineColor, Color fillColor)
{
int nbPoints = ARC_SEGMENTS * 4;
Vector2[] pts = new Vector2[nbPoints];
for (int i = 0; i < nbPoints; i++) {
float angle = 2 * Mathf.Pi * i / nbPoints;
pts[i] = center
+ new Vector2(Mathf.Cos(angle),
Mathf.Sin(angle)) * radius;
}
DrawColoredPolygon(pts, fillColor);
Vector2[] closed = new Vector2[nbPoints + 1];
for (int i = 0; i < nbPoints; i++) closed[i] = pts[i];
closed[nbPoints] = pts[0];
DrawPolyline(closed, outlineColor, BORDER_SIZE);
}
More complex entities layer additional techniques on top of this foundation. The player, for instance, builds a Catmull-Rom spline from a buffer of recent positions, extrudes it into a tapered ribbon with semicircular endcaps, and applies per-vertex color gradients that shift between red, yellow, and grey depending on dash state. When the player dies, that same procedural shape is sliced into polygon fragments with jagged cuts, and each shard becomes an independent node with its own velocity, rotation, gravity, and fade. The destruction is never the same twice.
Cells are the core navigation structure: polygon-based areas where gravity is disabled and full directional movement is allowed. When the player enters a cell, they can move freely in any direction, and the cell recharges their dash ability. Visually, each cell is drawn from its collision polygon with quadratic Bézier curves smoothing every vertex corner, and per-vertex sine/cosine offsets create a membrane-like wiggle that makes them feel organic and alive. Cells also gently drift and rotate using a spring-damper system, carrying any bodies inside them along for the ride.
Viruses are the primary enemy, drawn as a circular body with evenly-spaced rectangular stalks capped by semicircular bulbs. A multi-layered noise function continuously wiggles spike lengths, angles, and body radius each frame, while a separate spring-damper jitter system randomly offsets and rotates the entire shape, giving them a threatening, fidgety appearance. Viruses track the player within a configurable sight range using raycasts that respect wall occlusion, and upon death they shatter into directionally-biased polygon fragments using the same destruction system as the player.
Lysosomes are physics-driven oval objects that explode on sufficient impact. They contain floating internal particles that drift and bounce off the oval walls, and a pulsing outline that expands and contracts using a cubic-eased triangle wave. Push them into viruses or into each other to trigger chain explosions. When they burst, a separate effect node draws an expanding shockwave ring, a fading flash circle, and scattered splatter blobs that wobble, decelerate, and shrink, with blobs respecting cell gravity so debris floats properly in zero-gravity zones.
Bouncepads are static polygonal surfaces that reflect anything that collides with them, with configurable bounce multipliers and optional per-edge bouncing. They draw periodic pulsing aura waves, expanding copies of the bounce edges with fading alpha, to telegraph their function. BounceLines take a different approach: they act as dash mirrors, reflecting the player's dash trajectory while preserving the full dash distance from the hit point. Walking through one triggers a localized fracture effect, and dashing through one creates directional aura arcs on both sides of impact.
Checkpoints are drawn as small circles with radial gradient auras and a breathing animation. When activated, converging lines travel inward along Catmull-Rom spline paths, followed by a flash overlay and expanding pulse rings. Respawning uses a metaball-based mitosis animation: the checkpoint circle splits into two blobs connected by a pinching neck, computed via metaball field sampling, and the daughter cell transitions into the player's color before spawning them.
The goal cell extends the standard cell with rich biological detail: a pulsing radial aura, orbiting energy wisps, and procedurally generated organelles. Reaching it triggers a capture sequence where the player is pulled toward the center and dissolved, followed by tilted 3D-perspective rings expanding outward with a central flash.
Behind the gameplay layer sits a fully procedural background populated by twelve distinct organism types (given below), each drawn with its own unique procedural geometry. These organisms are not decorative loops; they exhibit five behavioral patterns: follow (chase smaller organisms), flee (escape predators), school (align velocity with same-type neighbors), orbit (circle a point of interest), and wander (gentle drift with direction changes). The entire layer renders with parallax scrolling and size-based alpha, so larger, closer organisms appear more opaque while smaller ones recede into the background.
Since every visual in the game is code, a variety of procedural drawing techniques are used across entities to achieve the organic, living aesthetic. These are some of the recurring approaches:
Beyond the core entities and drawing techniques, Chim includes a typewriter-style text reveal system where characters are unmasked one by one with a top-down wipe effect and a pulsing cursor, as well as an image reveal system using the same approach. Both support trigger areas so content can appear when the player enters a region. The game uses Godot's [Export] attribute extensively, so every parameter across every entity is tweakable from the inspector without touching code, making iteration fast despite the entirely code-driven visual pipeline.
Chim is a personal project whose source code isn't publicly available. It's something I may revisit in the future. In the meantime, a demo is available on itch.io.