Sloppio - AI Art Impostor

Everyone sees the category, but only the artists know the secret theme. Each player paints it with an AI prompt, and the impostor has to fake it. Study the pictures, vote, and catch them.

Comment

Inspiration

I wanted a party game for quiet rooms. Spyfall and Chameleon get loud, and some places can't take that: a night flight, a train, a dorm. I built a bluffing game you play in silence. A written prompt replaces the spoken clue, and the painting it produces shows how much the writer knew. You read the gallery instead of arguing.

What it does

Sloppio is a party game for 3 to 6 players over five rounds. Each round has a shared category, such as animals or movies. The artists also get a secret theme inside that category. The impostor sees the category and nothing else.

Each player writes a prompt and the phone paints it. The prompt walks a thin line. A clear prompt tells the impostor the theme, and a vague one gets you voted out as the fake. Once the gallery opens, players study the pictures and vote. The impostor can still win by guessing the theme.

You can play two ways. In pass-and-play, one phone travels around the table. In Party Room, friends join from their own phone browsers by scanning a QR code, with no install and no account. Bots fill empty seats and judge the paintings by sight, without reading what anyone typed. Built-in decks cover pop culture, food, movies, games and history, and you can create custom decks for inside jokes. The app runs in English, German, French and Spanish (Spain and Mexico).

How I built it

I built the game around one constraint: everything runs on the phone, so there's no server to fall back on. The rules live in plain functions that take a game state and return the next one. Pass-and-play, Party Room and the bots all call the same functions, so a vote scores the same way in each mode.

Party Room turns the host's phone into the server. Friends' browsers act as controllers, and each guest gets a private view of the game with only the secrets that guest may see. I kept the web client and the app in step. When I changed a screen, a rule or a string on the iPhone, I made the same change for guests, in all five languages.

I added the bots last, under one rule: they look at the paintings and never read the prompts. Picture generation, bot reasoning and translation all run on the device. I tested on physical iPhones, because memory limits and speed on real hardware decide whether a round feels playable.

Challenges I ran into

  • Memory. A diffusion model is heavy for a phone. I trimmed its memory use and tuned the device threshold until iPhones with 4 GB of RAM could run it.
  • One inference at a time. Six players can submit prompts at once. A queue runs one generation at a time, drops stale jobs when a round resets, and lets the host retry a failed picture.
  • Fair bots. A bot that reads prompts would cheat, so the rule sits at the data boundary. Bots receive images and the category, never player text or role assignments. I also banned keyword lists and hand-written heuristics, so the models do all the perceiving and reasoning.
  • Web parity. Every feature on the iPhone needed a matching feature in the browser, including languages, image zoom and voting. Guests also can't see secrets they shouldn't, so each guest gets its own snapshot and a private token.
  • Local networking. iOS asks for Local Network permission, and café or hotel Wi-Fi often blocks devices from reaching each other. The lobby has to explain both.

Accomplishments that I'm proud of

  • The whole game runs offline, in airplane mode, with no accounts and no data leaving the phone.
  • A friend joins from any browser with one QR scan.
  • Bots judge by looking at the paintings, the same way you do.
  • The app and the web client share the same five languages.
  • A model of about 1 GB runs inside a phone game and paints a picture in one turn.

What I learned

  • The Neural Engine rewards careful memory budgeting. A model that runs on one iPhone can crash on the next.
  • Fair play works better as an architecture rule than as a promise. Once bots couldn't reach the prompts, the cheating question was settled.
  • Local-network games depend on the router as much as on the code. Documenting failure cases mattered as much as building features.
  • A single-file web client keeps guests fast, because the phone serves one request instead of a dozen.

What's next for Sloppio

  • Push delivery instead of polling, to raise the six-player cap.
  • Host migration and mid-game player replacement.
  • Support for Personal Hotspot and IPv6-only networks.
  • More languages and more topic decks.
  • Faster one-step image models, so the gallery opens sooner.

Built With

  • apple-intelligence
  • apple-translation
  • core-ml
  • css
  • dreamshaper
  • foundationmodels
  • html
  • ios
  • javascript
  • mobileclip
  • network.framework
  • neural-engine
  • python
  • stable-diffusion
  • swift
  • swift-package-manager
  • swiftui
  • vision
  • xcode
Share this project:

Updates

Submission history