A second opinion, with receipts.
gameloom is an engine that has read the record of shipped games — 370,000+ titles and over a million player reviews: what launched, what found its players, what quietly died, and why. Describe your game in a couple of sentences and it shows you the closest games that already shipped, what happened to each one, and what that means for yours. It isn't a guru and it isn't a hype machine — every answer points at named games you can go and look at.
One plain call
Build it, fix it, or rethink it — one sentence in plain words. Never a dashboard of twelve charts you have to decode.
Named comparables
The shipped games yours most resembles — which made it, which died, and the one-line reason why. Receipts, not vibes.
Risks a playtest can't catch
A great prototype can still die: a crowded genre, players who vanish in week one, a pitch the market already rejected. gameloom checks for exactly those.
Your game on one side. Every shipped game on the other.
The loop is the product. The left side holds your idea — what it is, how it earns, who it's for. The right side holds the market's memory. The answer lands where the two sides cross. And it keeps looping: ship, learn what held, feed the next release.
Four steps. No data-science degree.
Tell it what you're making
A working title, a two-line pitch, the genre, the platform. That's genuinely all it needs to start — no build, no trailer, no deck.
It finds your game's closest relatives
It reads your idea the same way it has read every shipped game — the hook, the core loop, how it earns, who it's for — and pulls the nearest matches on your platform. Think of it as your game's DNA, matched against everyone who came before you.
It checks what actually happened to them
Not star ratings — outcomes. Which of those games found an audience and lasted. Which died, and how: the launch nobody heard, the week-one exodus, the genre that was already full.
You get the call — and the receipts
One sharp sentence up front. Underneath: the named games, a made it or died chip on each, and the plain reason why. If you disagree with the call, you can check every receipt yourself.
It won't fake confidence it hasn't earned.
Most tools in this space fail the same way: they always sound sure. gameloom is built the other way round.
Every read is labelled with the weight it can carry.
Plenty of close, resolved matches → a confident read. Thin evidence → it says "early read" out loud, right on the result — never buried in a footnote.
The big call is earned, not assumed.
The flat "build it / kill it" verdict stays switched off until the engine has proven — on games it wasn't shown — that it can actually predict outcomes. Until then you always get the side-by-side layer: "yours resembles 8 games; 3 made it, 5 died." That claim you can audit yourself, game by game.
Change your game, and the read admits it's stale.
Swap the price model, the platform, the hook — the old answer greys out and says so. One click runs a fresh read. It never quietly pretends the old answer still holds.
Three questions, answered straight.
"Should I build this?"
The graduation check. Take it forward, reshape it, keep experimenting — or stop now. Grounded in how games like yours actually ended up, never in enthusiasm.
project_graduate
"What can't my playtest tell me?"
The failure modes that never show up in a friends-and-family build: a saturated genre, the day-7 retention cliff, a positioning players have already turned down.
concept_risk_check
"Which dead games does mine resemble?"
The blunt one. The already-dead games closest to yours, on your platform — and why each one died. Cheaper to read it now than to live it later.
dead_game_compare
In the app — or right inside your editor.
gameloom.ai
- Request an invite at gameloom.ai — it's early, so access is gated.
- Drop your idea into the Concept Doctor: title, pitch, genre, platform. Two sentences is enough.
- Read the call, then open the receipts — every comparable game, its outcome, and the plain reason why.
- Change something and run it again. Price model, platform, hook — the read moves with you. Iterating before you build is the whole point.
For AI-native builders
If you build inside Claude Code, Claude Desktop or Cursor, gameloom plugs in as tools your AI can call mid-session — ask "should this graduate?" without leaving the window, and the verdict comes back in-flow.
{
"mcpServers": {
"gameloom": {
"command": "node",
"args": ["path/to/gameloom-mcp/server.mjs"],
"env": {
"GAMELOOM_FUNCTIONS_URL": "…with your invite",
"GAMELOOM_MCP_KEY": "glm_…with your invite"
}
}
}
}
Your URL and glm_ key arrive with your invite. The key is durable and revocable — no daily logins, and you can kill it any time.
The verdict is the start, not the product.
Once the call lands, gameloom drafts the work that follows — always in plain view, always yours to accept or throw out.
What to build, in what order
A stage-by-stage build plan and what to cut first when time runs short. Drafted for you — you set the dates.
Does the budget survive the plan?
Your spend against your timeline — including the honest red flag when the money runs out before launch day.
Runbook + store pages
A countdown runbook and drafted store-page copy. It drafts, it tracks — you hit publish.
Did the call hold?
Your forecast against your real result, player feedback pulled into one place, and a drafted next release. The loop closes — then starts again.
Stop guessing. See what it sees.
One idea, two sentences, and an honest read of what usually happens next.
gameloom.ai →