PAINT-IT — What Reddit Remembers

Draw it. Flash it. See what the community remembers.

PAINT-IT is a daily visual-memory game that turns every first attempt into part of a shared Reddit artifact. Players see a colorful segmented doodle for only 5–7 seconds, repaint it from memory, and receive a precise score. After the reveal, the subreddit discovers something no single player could create alone: the image the community collectively remembered.

SEE (5–7s) → REPAINT → SCORE → AGGREGATE → REVEAL → DISCUSS → RETURN

The game has two competitive tracks, a complete in-app challenge studio, deterministic daily content generation, mobile-first Phaser gameplay, and server-authoritative scoring. It is not a solo puzzle wearing Reddit branding. The community’s imperfect memory is the mechanic.

Inspiration

We were fascinated by the gap between what people see and what they believe they saw.

Think about the telephone game, an afterimage that disappears when you blink, or a group of friends describing the same event differently. Memory is personal, fallible, and often funny—but Reddit gives us something more powerful: thousands of independent memories can become a collective answer.

That led to one question:

What if a subreddit could repaint an image together without ever coordinating?

Most memory games end when the player receives a score. PAINT-IT begins there. Each honest first attempt becomes one vote per visual region. At reveal time, those votes reconstruct the scene Reddit remembers: the right sky, perhaps the wrong roof, and one tiny detail almost everybody confidently misremembered.

This creates a natural Reddit conversation. People can compare strategies, debate why the same color fooled everyone, celebrate perfect recalls, and turn recurring mistakes into community lore.

What it does

A complete daily player loop

Discover without spoilers. Feed cards, the home screen, ballots, and the archive show neutral line art—not the target palette.
Memorize. The real artwork appears for an adaptive 5, 6, or 7 seconds based on complexity, with a visible countdown.
Repaint. Players choose from tactile paint drops and fill every closed region on a responsive Phaser canvas.
Use limited help. Peek briefly or undo a move, knowing that ranked scoring records the cost.
Submit. The server validates the challenge version, assignments, elapsed time, and peek count.
Understand the result. Players see the original beside their exact reconstruction, a region-by-region accuracy breakdown, score, rank, streak, and biggest miss.
Return for the collective reveal. First attempts are aggregated into the subreddit’s remembered image, including its most-forgotten region and most-confused color pair.

Two Daily tracks, two reasons to return

Track	Where the challenge comes from	Why it matters
Official Daily	PAINT-IT’s deterministic Doodle Forge creates a fresh, validated scene for the UTC date	A consistent, fair test with its own first-attempt leaderboard and streak
Community Daily	The previous day’s solve-gated subreddit ballot chooses from published creator challenges	Redditors do not merely play the content—they decide what the community plays next

The two tracks have separate leaderboards so a community experiment never compromises the fairness of the official competition.

Creator Studio: UGC that is actually playable

PAINT-IT includes a five-step challenge-authoring pipeline inside the app:

DRAW → FIND REGIONS → ASSIGN COLORS → TEST AS A PLAYER → PUBLISH

Creators can use a pencil, eraser, undo/redo, and shape stamps for circles, rectangles, and triangles. The studio detects closed regions, explains leaks and tiny shapes, supports touch-friendly region selection, and requires a full playtest before publishing.

Published geometry is immutable. An edit becomes a new version instead of silently changing a puzzle after people have played it. Each member can publish up to three challenges per UTC day. Ballot voting unlocks only after playing the candidate, allows one vote per day, and blocks self-voting.

That turns user-generated content into a sustainable loop:

CREATE → PLAYTEST → PUBLISH → PLAY TO UNLOCK → VOTE → COMMUNITY DAILY
   ↑                                                               ↓
   └──────────────────── recognition + discussion ─────────────────┘

Daily variety without runtime uncertainty

Our Doodle Forge does not rotate a small list of static pictures and does not ask an AI model to invent scoring geometry at runtime. The UTC date deterministically selects and combines:

8 primary illustrated subjects;
6 companion motifs;
4 sky treatments;
multiple ground layouts, transformations, palettes, and composition variants.

Adjacent dates cannot repeat the same primary subject. More importantly, the visible SVG and the pixel-ownership map are generated from the same polygons, then assigned a SHA-256 integrity identity. Every edition is reproducible, schema-valid, and auditable.

Why PAINT-IT belongs on Reddit

PAINT-IT uses Reddit as more than a place to host a web game:

Subreddit-scoped identity: creator libraries, ballots, winners, and community results belong to the subreddit that produced them.
Meritocratic UGC: challenges earn tomorrow’s spotlight through solve-gated community voting.
Collective outcomes: every honest first attempt changes the delayed reveal.
Daily anticipation: players return for new official art, a community-selected puzzle, both leaderboards, their streak, and yesterday’s reconstruction.
Conversation fuel: the most-forgotten detail and most-confused colors give the community an immediate story to discuss.

The result is asynchronous multiplayer: Redditors do not need to be online together, but their individual actions still create a shared moment.

How we built it

Layer	Technology	Role in PAINT-IT
Reddit platform	Devvit Web	Feed entrypoint, expanded game, subreddit context, menu actions, scheduler, and app lifecycle
Game runtime	Phaser 4.2.1	Region rendering, pointer acquisition, paint propagation, countdown transitions, particles, tweens, and reduced-motion behavior
Interface	React + TypeScript + Vite	Home, dual Daily tracks, leaderboards, Creator Studio, results, archive, and reveal
Server	Devvit server + Zod	Authoritative validation, challenge resolution, moderation routes, and strict request schemas
State	Redis	Attempts, idempotency, streaks, rankings, UGC versions, daily quotas, ballots, and collective vote matrices
Audio	ElevenLabs sound effects	Eleven lightweight interaction cues with a persistent mute control

One geometry model from drawing to scoring

The hardest technical rule was simple to state: the pixels a player taps must be the same pixels the server scores.

Every challenge therefore stores immutable polygons, exact row-major ownership runs, region metadata, palette assignments, and an integrity hash. Rasterization follows a deterministic smallest-detail-wins policy for overlapping shapes. On mobile, Phaser adds a bounded 12–24 px acquisition radius for small regions, while the actual scored region remains exact.

This single-source geometry prevents three subtle failures:

a visible area that cannot be painted;
two shapes competing for the same pixel;
a creator thumbnail that looks correct but produces different gameplay.

Fair scoring with explicit math

Large backgrounds should matter, but they should not erase the importance of a small memorable detail. For region (i), with area (a_i), total region area (A), and (n) regions, we use a blended weight:

$$ w_i = 0.65\left(\frac{a_i}{A}\right) + 0.35\left(\frac{1}{n}\right) $$

The exact-color recall accuracy is:

$$ \text{accuracy} = \sum_{i=1}^{n} w_i \cdot \mathbf{1}[\text{player}_i = \text{target}_i] $$

Speed is a modest tie-breaker rather than the main objective:

$$ \text{timeMultiplier} = 0.70 + 0.30\max\left(0, 1 - \frac{t}{60}\right) $$

The final score rewards accurate recall nonlinearly, applies the recorded peek multiplier, and adds a perfect-recall bonus:

$$ \text{score} = \operatorname{clamp}\left(\operatorname{round}\left(1000 \cdot \text{accuracy}^{1.6} \cdot \text{timeMultiplier} \cdot \text{peekMultiplier}\right) + \text{perfectBonus},\ 0,\ 1100\right) $$

Only the first ranked attempt affects streaks, leaderboards, and the collective reconstruction. Practice remains unlimited. Redis watched transactions and idempotency keys prevent duplicate submits or racing requests from creating multiple ranked outcomes.

Honest community data

We made a deliberate product decision: never fake momentum. Empty leaderboards say “Be first.” A collective insight appears only when real first attempts exist. Vote counts, sample sizes, rankings, and reveals come from persisted subreddit activity—not seeded demo players.

Challenges we ran into

1. Making a drawing both expressive and mathematically valid

A doodle can look closed to a human while containing a one-pixel leak. It can also contain regions too small for a thumb. We built deterministic flood-fill detection, border-touch rejection, gap guidance, minimum playable-area rules, exact polygon ownership, and mobile acquisition assistance. The creator sees actionable feedback instead of a mysterious “invalid” message.

2. Protecting the memory test before play

A full-color thumbnail would make the timed reveal meaningless. The challenge artwork appears in several places—feed, home, archive, Community Daily, and ballot—so hiding one image was not enough. We created a shared spoiler-free teaser renderer that reconstructs neutral line art directly from challenge geometry. Full color now exists only in the timed flash and post-attempt reveal.

3. Keeping daily content fresh without sacrificing correctness

Static rotation becomes predictable, while unconstrained generation can create impossible puzzles. Doodle Forge solved both problems by composing daily art from validated templates and deriving artwork plus ownership from the same deterministic source.

4. Making “first attempt only” true under concurrency

Double taps, retries, and simultaneous requests can corrupt rankings if fairness is enforced only in the client. We moved the rule to the server and combined challenge-version checks, idempotency keys, and watched Redis transactions so every submission is safely replayable but only one can become ranked.

5. Making Phaser meaningful inside a mobile Reddit surface

We did not want Phaser to be a decorative dependency. The core memory interaction runs through it: pointer-to-region resolution, paint-state rendering, timed transitions, input locking, burst feedback, tweens, resize handling, and reduced-motion fallbacks. We also tuned the layout for narrow screens, touch targets, and interrupted app sessions.

6. Balancing delight with download size

Audio and motion make painting feel tactile, but a Reddit game must open quickly. We selected eleven short sound cues, compressed the complete sound set to roughly 114 KB, lazy-loaded heavy screens, and added persistent sound and motion preferences.

Accomplishments that we're proud of

We turned a simple memory puzzle into an asynchronous community experiment whose output only exists because Redditors played.
We built two complete Daily ecosystems—Official and Community—with separate leaderboards and fair first-attempt rules.
We shipped a real UGC creation-to-selection pipeline, including region detection, shape tools, playtesting, versioning, quotas, solve-gated voting, and moderation controls.
We created Doodle Forge, providing a reproducible new official composition every UTC day instead of a seven-image shuffle.
We made visible art, hit testing, painting, and scoring agree through one immutable ownership model.
We used Phaser for the interaction layer that players actually feel, including responsive input, transitions, animation, and accessibility fallbacks.
We kept every public statistic honest: no fake players, no invented votes, and no placeholder community insights.
We covered the high-risk mechanics with automated tests and a full type-check, lint, test, and production-build gate before deployment.
We installed a working Devvit release in a public test subreddit, ready for a real judge to play from the Reddit post.

What we learned

Correctness is part of game feel

Players may never read the score equation or ownership rules, but they immediately feel when a tap misses, a tiny detail is unfair, or a result image does not match their choices. Mathematical correctness is not back-office engineering—it is trust.

UGC needs a product loop, not just a canvas

Giving people a drawing tool is easy. Helping them make challenges that are closed, tappable, tested, discoverable, fairly selected, and safe to update is the real feature. Constraints made creation more empowering because creators know someone else can actually enjoy the result.

Reddit-native means the community changes the outcome

Reddit colors, karma, or Snoo references would not make this idea social. The game became Reddit-native when playing, creating, voting, and returning changed what the subreddit saw together.

Retention is strongest when it is curiosity

A streak can remind someone to return. A leaderboard can motivate them. But the deepest hook is an unanswered social question: Did everyone else remember it the way I did?

Determinism can unlock creativity

We initially saw procedural variety and exact validation as competing goals. Doodle Forge taught us the opposite: a deterministic grammar can create a large expressive space while remaining reproducible, testable, and fair.

What's next for PAINT-IT

Community seasons and themed weeks

Subreddits will be able to run themes such as “Tiny Worlds,” “Badly Remembered Logos,” or “One-Color Wonders,” with weekly Community champions and creator spotlights.

Deeper social reveals

We want shareable reveal cards, region-specific discussion prompts, subreddit-versus-subreddit memory comparisons, and a timeline showing how collective recall changes as more first attempts arrive.

Stronger creator tools

Next steps include layers, snapping and alignment, more shape stamps, reusable personal palettes, fork-and-remix attribution, draft recovery across devices, and moderator-curated creator collections.

Accessibility as an alternate way to play

We plan symbol- and texture-based palettes for color-vision accessibility, stronger screen-reader descriptions, adjustable contrast, switch-friendly controls, and a non-timed practice mode that preserves the core region-memory challenge.

Safe assisted creation

Future assistance may suggest how to close gaps, simplify an over-complex drawing, or generate a draft composition. But every published challenge will still pass the same deterministic geometry, ownership, touchability, and playtest gates. Generation can propose; the game engine must prove.

A living atlas of collective memory

Longer term, PAINT-IT can become a browsable archive of how different communities remember color and composition—not as a scientific claim, but as a joyful record of thousands of tiny human mistakes.