Half & Half

Create together, paint apart, reveal the magic.

Comment

Inspiration

Half & Half was inspired by the idea that distance should not prevent people from creating something together. We wanted to turn a simple drawing activity into a shared experience with an element of surprise.

Two people contribute an idea each. AI combines them into one hybrid black-and-white illustration, and each person secretly colors one half without seeing the other person's work. The final artwork is revealed only when both participants are finished.

Although the project was initially designed with long-distance couples in mind, it can be enjoyed by friends, families, classmates, or anyone who wants to create something together.

What it does

Half & Half is a collaborative AI-powered coloring experience for two people.

  • Create or join a room using a short code.
  • Submit one creative idea per person.
  • Generate one shared hybrid illustration with OpenAI.
  • Paint privately using a brush and fill bucket.
  • Save progress locally and continue after reloading.
  • Reveal the complete artwork when both people finish.
  • Download the final shared PNG.
  • Start another room and keep up to three revealed artworks locally.

The core experience is simple: imagine together, paint apart, and reveal together.

How we built it

We built Half & Half as a full-stack web application.

  • React and TypeScript power the interface.
  • Vite provides the development environment and frontend build.
  • Node.js and Express handle the API and room coordination.
  • OpenAI's Images API generates one hybrid illustration from both ideas.
  • Supabase PostgreSQL stores rooms, participants, generation attempts, and final submissions.
  • Supabase Storage keeps generated images private.
  • Sharp processes, splits, and recombines the artwork.
  • Canvas 2D powers the private painting experience.
  • IndexedDB stores each participant's local painting progress.
  • Playwright and Node's test runner verify the core flows and privacy rules.

The server is responsible for room state, participant permissions, generation limits, image processing, and the final reveal. Each participant receives only their assigned half while painting.

Challenges we ran into

One of the biggest challenges was making sure both participants always worked on the same generated image without accidentally triggering duplicate AI requests. We solved this with server-side reservations, idempotent operations, shared room state, and controlled generation attempts.

We also had to protect the privacy of each person's painting. The server never sends the other participant's half during the painting phase, and the final image is only composed after two valid final submissions.

Another challenge was making AI-generated images suitable for coloring. Early results sometimes produced two separate subjects instead of one hybrid subject, or included contours that were not fully closed. We improved the prompt to explicitly request one physically merged creature or object and tested the result with both brush and fill tools.

Accomplishments that we're proud of

  • Built a complete two-person creative workflow without requiring accounts.
  • Generated a real shared image through the OpenAI Images API.
  • Prevented duplicate generations and uncontrolled retries.
  • Implemented private left and right halves with server-side authorization.
  • Built both brush and fill-bucket painting tools.
  • Added local autosave and recovery with IndexedDB.
  • Implemented a synchronized final reveal and identical downloads for both participants.
  • Added a local history of the three most recent revealed artworks.
  • Tested the experience across desktop and narrow responsive layouts.
  • Verified the core journey with automated domain, integration, and browser tests.

What we learned

We learned that the most important part of an AI product is not only calling the model, but designing the surrounding system carefully.

A generation request needs clear limits, recovery behavior, and protection against duplicate calls. AI output also needs to be evaluated as a real artifact: a technically successful response is not necessarily a useful coloring page.

We also learned that privacy must be designed into the data flow from the beginning. Separating each participant's view on the server made the collaborative surprise possible and reduced the risk of exposing private painting data.

What's next for Half & Half

Next, we would like to make the experience easier to share remotely with a public deployment and improve the quality and consistency of generated coloring illustrations.

Future ideas include:

  • More expressive image styles and generation prompts.
  • Better support for mobile and tablet painting.
  • Optional accessibility improvements for canvas interactions.
  • More collaborative activities beyond coloring.
  • A shareable export flow while keeping private progress protected.
  • Optional public galleries or saved collections, if privacy concerns can be handled responsibly.

Built With

Share this project:

Updates

Submission history