Ideas, pulled at random
and actually built.

What it is

A four-level, top-down film-noir shooter that runs in a browser tab. Nine days of rain, one night to make it simple again: Detective Ray Calloway, framed for his partner's murder, works his way from a subway platform up fifty-four floors to the man who set him up.

The two moves that matter are the ones the idea was really asking for. Bullet time on Shift drains an hourglass and refills on kills. Shootdodge on Space throws you sideways through the air, in slow motion, still firing — and pays triple. Four weapons, painkillers instead of regenerating health, and hand-drawn comic panels between chapters.

Everything is generated at runtime. There is not one image, sound or font file in the project: the gunshots are synthesised noise bursts, the rain is a filtered noise loop, the comic panels are painted with canvas paths and a halftone screen, and the levels are lists of rectangles.

Mouse and keyboard · no install · no account

Notes from the build

• The lightmap was the whole game. Every level light casts real hard shadows, built from the silhouette edges of the wall rects. Doing that per frame cost 5.6 ms in the nightclub and dragged the game to 24 fps. Lights and walls are both static, so each light's shadowed falloff is now baked once into its own texture and blitted — 0.3 ms, and the frame came back.
• Paint bright, then take the light away. A multiply lightmap can never push a surface past its own colour, so the first pass at the art was unreadably black — the floors had been painted at the brightness they were meant to end up. Repainting every surface at "fully lit" and adding a second additive pass is what makes wet concrete look wet.
• Shots that vanished. Bullets spawned at the muzzle, 22 px ahead of the player. Stand against a crate and that point is inside the crate, so every round died on the frame it was fired — a boss fight that could not be won. Tracing the first step from the shooter's centre makes line of fire and line of sight agree exactly.
• An unwinnable state. Testing found a run that emptied every weapon with hostiles still standing: no ammo, no way to make more, no way out. Calloway now finds a spare clip in his coat when everything is dry.
• Enemies path, they don't cheat. A* over a dilated 40 px grid with corner-cut prevention and string pulling, repathed on a stagger. Goons hunt your last known position, flank, and duck behind cover when they are hurt.
• The board is ours. Scores go to a small PHP endpoint on the same webspace — fixed schema, key-gated, atomic writes, and a data directory the web cannot reach. A client can add a row; it can never wipe the board.

What it is

An app that interviews you. One question at a time, 120 of them across ten chapters — Origins, Childhood, Family, Places, Love, Work, Turning Points, Beliefs, Now, Later — each written to pull a scene or a person out of you rather than a yes or a no. Answers accumulate into a book you can read, reopen and hand to someone.

Rings are sets of questions you switch on and off in any mix. The Core is thirty questions, about two hours, the short book a stranger would need; Deeper and The Long Way add ninety and sixty more, and a future pack is just another ring. Time left is measured at your own pace once it has seen you write a few. Export a printable HTML book, plain Markdown, or a JSON backup that restores on any device.

The note on the idea said "iOS app or better platform independent". It is one Expo codebase: the web build linked below is the same app, and the native builds are an eas build away.

Web build of the Expo app · works in a phone browser · nothing ever leaves the device

Notes from the build

• Tested like a phone, not a terminal. The web export was driven in Chromium emulating an iPhone 13: answer four questions, steer the question order from a chapter, weave, edit, export the book, download a backup, erase everything, restore it. The run is scripted and passes against the live URL with zero console errors.
• A race between erase and restore. Erase used removeItem; every other write was debounced. The harness caught "Restored, 4 answers folded in" followed by an empty store — the erase landed last. Every change now goes through one serialised write, and the store flushes when the app backgrounds.
• Alert.alert does nothing on web. Errors were being swallowed silently in the browser build. A tiny notify() wrapper routes to window.alert there.
• Subpath hosting needs two things. Expo's baseUrl so the bundle resolves under /one-reader/, and an Apache rewrite so deep links like /chapter/origins reach the app. The fonts live under dist/assets/node_modules/ — a deploy that skips node_modules blindly ships a fontless app. It did, once.
• Borrowed a language. The first pass was paper-and-ink; on request it was re-skinned in the "Pop" language of another app on this site: neutral ground, one saturated Khroma-paired colour card per chapter with its partner ink, grotesk UI, pill buttons, an icon-only tab bar, light and dark twins following the system. The prose kept its serif.
• Runs on a phone now, detached. An Expo tunnel on :8098 is launched by a small PowerShell script that survives the shell that started it (and retries ngrok's flaky first handshake). Open it in Expo Go; no store needed.
• Built a backend, then deleted it. The first version had an AI "weave" that rewrote a chapter as prose through a proxy on this webspace. It worked, but it brought a server, a secret, a daily quota and a host quirk into an app whose whole point is that nothing leaves the phone. Cut on request; the app has zero network calls now.
• Not done on purpose: no App Store or Play submission. That needs an Apple account and a human signature; the repo is ready for eas build.

What it is

PureRef is the tool concept artists keep open beside the canvas: an infinite wall you throw reference images on, and almost nothing else. Tack is that, in a browser tab, MIT licensed. Drop or paste images — files, screenshots, a URL dragged from another tab — then move with snapping, scale about a corner, rotate with a knob, crop by dragging edges, flip, greyscale, write notes, marquee and group-transform. Ctrl P packs the whole wall into a tight rectangle.

Boards autosave to IndexedDB and keep the original bytes of every image. A board exports as one .tack file with the images inside, or as a full-resolution PNG. Installed as a PWA it works offline; nothing is ever uploaded, there is no account and no server.

The brief allowed a launch, so there is one: a social card, a launch/ folder with Show HN, Reddit, Product Hunt and thread copy ready to post, and a README written for the repo. Publishing to GitHub is the one step that needs a token this machine does not have.

Vanilla ES modules · one canvas · zero dependencies · MIT

Notes from the build

• Geometry in the gesture's own frame. Scaling about the opposite corner of a rotated, flipped, cropped image drifts unless every step is computed in the local frame captured when the drag began. Crop is stored as fractions of the natural size, so it composes with rotation and scale for free.
• Shelf packing was ugly; skyline is not. The first "pack" justified each row and left holes in sparse rows. The replacement is bottom-left skyline packing tried at eight candidate widths, scoring fill against the window's aspect. 150 items in 4 ms.
• display: grid beats hidden. The "Drop images here" hint stayed on top of a full board because its CSS display overrode the attribute. One global [hidden]{display:none!important}.
• A keystroke that opens a text field types into it. Pressing N created a note, focused its editor, and the "n" landed in the note. preventDefault on the keydown.
• Fit has to know about the toolbar. Fit-to-screen padded evenly, so a zoomed-to image's rotate knob sat under the floating bar and could not be grabbed. The top inset is now 100px.
• Big walls stay smooth with one mip. Every image over 1500px gets a ≤1024px ImageBitmap alongside the full one; the renderer picks whichever is closest to the on-screen size. 150 photos at 1800–3400px: 16 ms a frame while panning.
• Honest about CORS. An image URL from a site that forbids cross-origin fetches cannot be stored. Rather than a tainted canvas that breaks PNG export later, Tack says so and asks for the file.

What it is

A deck of cards to think with. Each card is a question to sit with, a mantra to carry, or a line from someone long dead. Swipe right to keep it, left to pass, tap to write a thought on it. 156 cards in eleven packs — Morning, Evening, Gratitude, People, Work & Craft, Body, Fears, Joy, Big Questions, Mantras, Quotes — any mix switched on.

Discovery deals cards you have never seen first, shuffled fresh each day; Routine deals the ones you kept, so the same few questions come round every morning. A quote opens every session. What you write lands in a journal by day; a JSON backup restores on any device and a Markdown export reads like a diary. Nothing leaves the phone.

The note said "sleek ass design" and "minimal color and silhouette design", so every card is one solid colour with a partner ink, one flat shape, and a serif. That is the whole visual system.

Web build of the Expo app · on the phone through Expo Go · all private always

Notes from the build

• The card sprang back after four pixels. On the web, a PanResponder drag was being terminated by a parent view asking for the responder, so every swipe snapped home. The harness traced the card's transform frame by frame to see it. onPanResponderTerminationRequest: () => false, and a 240px drag reads 240px.
• Swipes tested with a real mouse drag, not by calling the handler: mouse down, eight moves, up — the same path a person's thumb takes. Both directions, then the buttons, then the keyboard.
• A saved thought moves the deck on. The write sheet is a modal; when it closes the deck screen regains focus, sees which card was written on, and deals the next — without the sheet ever knowing about the deck.
• Discovery order is seeded by the date. A fresh shuffle every day, but the same order all day, so putting the phone down and picking it up does not reshuffle the cards under you.
• Tests wait for the debounce. Every write to storage is coalesced 250ms after the last change; a check that read storage 200ms after a tap read stale data. The harness now waits longer than the app does.
• Where the reload lands matters. Reloading a tabbed Expo web app returns to the tab in the URL, not the first tab. The persistence check now navigates to the deck explicitly.

What it is

You type what is on your mind. You get one to three short questions back, built on what you just wrote — never advice, never a summary, never a compliment. "Just tell me what to do" gets a question. Ten questions in, most people have said the thing they were avoiding, and it was them who said it. Socrates called it maieutics.

The rule is code, not a prompt: the server splits every reply into sentences and drops any that does not end in a question mark; one rewrite, then a fallback. Gemini flash-lite answers in under a second. The conversation lives in the tab; the only thing written to disk is a per-visitor daily counter so one person cannot drain the key. Four lenses — stuck, deciding, understanding, feeling — change only the first question. It replies in German if you write German.

This is the first project with a stage after publishing. Following introdote-2: a written concept with "the line", a researched neighbourhood with evidence from actually opening each page, a queue of three drafted comments that nothing can post without a human approving, and a ?stats=1 endpoint so "ten users" is a number, not a feeling.

~300 lines of JS · one PHP file · no account · nothing stored

Notes from the build

• The model will not stay in character; the filter does. Asked to "only ask questions", flash-lite drifts into a clause about itself within a few turns ("when I am only carrying your questions?"). The prompt now forbids self-reference, and the server keeps only sentences ending in "?" regardless. Zero statements reached the page in the walkthrough.
• Model roulette, again. gemini-2.5-flash-lite is gone for new keys; gemini-3.7-flash hung for two minutes; 3.6-flash spent its token budget thinking and returned half a sentence. 3.5-flash-lite answers in 900 ms. The endpoint tries three models in order.
• The neighbour that proves the point. The nearest existing tool ("Don't Ask Me", Show HN, 2 points) puts the chat behind a sign-in, charges for "no answers ever", and penalises giving up with reputation points. Only Questions has no account and no game; that is the positioning, found by opening the page.
• HN threads close. The best on-topic thread ("How do you learn with LLMs? e.g. socratic method") is 18 days old and past the comment window. Seeding has a clock; the plan says so.
• Reddit is a wall to scripts and fresh browsers alike. Every search returned the "Welcome to Reddit" page. Those two searches are handed to the human, with the exact queries.
• No PHP on the dev machine, so the walkthrough runs against the live endpoint: a real four-turn conversation including "just tell me" and a German turn, reload, copy, start over, the key gate.

What it is

A name comes up — Maya — with a question. Everyone except Maya says out loud what they think she will answer. Then Maya answers, and Maya taps whoever came closest. That person scores 1. If nobody came close Maya scores 2, so a safe, boring answer is not a winning move.

Three rounds, and they get deeper: Warm (top three sweets), Real (what money meant in the house you grew up in), Deep (what you feel guilty for even thinking). Between rounds the game stops and offers to end there. Whoever is on a card can skip it — no reason, no penalty — and that is rule four on the screen everyone reads before the first question.

The trick is where the exposure sits. Every other version of this points at one person and asks for a confession, which is an interrogation, and an interrogation gets you the shortest true-ish answer available. Here the four people guessing are the ones on the line and the subject is the answer key — with the last word on who actually knows them.

284 hand-written questions · 2 taps a card · works offline · no server

Notes from the build

• The deck is the product, so it was written by hand. The rule for every card: the answer has to be short, specific and guessable. "What is the meaning of life" is unguessable and therefore a dead card; "which of your parents are you more like, and in what specific way" is a game.
• Colleagues get two rounds, not three. There are 99 warm and 69 real cards tagged for work and zero deep ones, because none of those questions should be asked on a Tuesday by someone who writes your review. Rather than invent filler, the app counts what exists and says so on the setup screen.
• Winning by being unreadable is a different achievement. The first scoreboard crowned someone "Closest tonight" who had scored almost entirely from nobody guessing her. It now tracks both and the header says Nobody could read when that is what happened.
• Two players never see a "who here" card. 42 of the questions ask the subject to name someone at the table; with a couple there is only one candidate, so the pool filters them out before the deal.
• The deploy was lying. A 21 KB module landed on the server as 0 bytes while curl exited 0 and the script printed "all uploaded". deploy.mjs now re-downloads every file it sends and compares it — folding CRLF, and allowing for the cookie script lima-city injects into every HTML response — then re-sends anything wrong. It repairs one or two files on every run.
• Bakeoff, dropped. A model-vs-model arena got as far as a written concept before being cut in favour of this one. The costing survives it: a game-sized prompt bills about 20k output tokens once thinking is counted, so a flagship head-to-head is roughly 85¢ a go and Gemini-against-Gemini is free.

What it is

A library of questions instead of answers. Pick the situation you are actually in and get sixteen questions written for exactly that, in four movements of four: where you actually are, what you actually want, what is in the way, what happens next.

The order is the product. The thirteenth question only works because you answered the first twelve, and the last four are all dated and concrete on purpose, because the point of asking is to end up doing something. A flat pile of three hundred deep questions is worth nothing — which is why the ones you can already find are free.

The title is the navigation: Questions for ______, and the blank is the search box. Read a stack whole or run it one question at a time with nothing else on the page; star what bit and copy it out; send someone questions for when it went wrong instead of advice. A stack prints as sixteen cut-out cards, because the physical version of this is a box of categorised card stacks.

19 stacks · 304 questions · no account · works offline

Notes from the build

• Search has to bridge topic and situation. Nobody types "getting the first ten users" — they type marketing. Each stack carries the words people would actually reach for, so the topic finds the situation the stack is named after.
• The four movements are enforced, not suggested. Every stack is exactly 4 × 4, and the walkthrough asserts the movement of each card as it runs, so a stack cannot quietly become a list.
• Naming a view after a button. The run screen rendered as one enormous rust-coloured pill: <main class="view run"> was picking up the styling of .run, the "Run these one at a time" button. Caught in a screenshot, not by a test.
• The shelves are four because they are how you arrive. Making things, work, people, yourself. You do not come here browsing a taxonomy — you come with a specific bad afternoon.

What it is

The one-to-one version of Closest: no game, no scoring, just a deck. Say who is with you, draw a card, swipe for the next. It is installable and works with no signal, which is the only way a thing like this survives an actual dinner.

The ramp is the whole idea. The first four cards are light. Then the real ones come into play. After ten, the deep ones do — and the whole screen changes colour with the depth, cream to sage to night, so a conversation getting more serious is something you can see rather than something anybody has to announce. It is the only progress bar the app has.

242 of Closest's cards carried over, keeping only the ones that work without a table of people. Someone at work gets no deep pile at all — 81 light and 57 real cards exist for that column and zero deep ones, so the app greys the tile out and says none for this rather than putting something regrettable on the screen.

242 cards · 3 depths · installable · nothing recorded

Notes from the build

• A transform that zooms the phone out. The card is dealt by sliding it to translateX(115%). That widened the document, and a mobile browser answers a wider document by zooming the layout out — innerWidth went from 390 to 809 mid-deal. The stage clips now, and the walkthrough samples scrollWidth every 30 ms during a deal so it cannot come back.
• The ramp only counts if you can see it. The first version picked at random from the newly widened pool, so the card at the moment it was meant to deepen was often still a light one and the colour never changed. The card that crosses a boundary is now forced to come from the deeper pile.
• "Getting real" twice is worse than never. The announcement re-fired every time a shallower card came round again. Each depth is now announced once, remembered across reloads, and the shallow mix dropped from 35% to 15% so the field stops flickering.
• Three products, one bank. Closest, Tell Me and Questions For. all came out of idea #219 in a single sitting, and they are three different things: a game for a table, a deck for two people, and a reference for one person with a problem.

What it is

The note is not a feature list, it is a coordinate system, so that is what got built. Twelve axes — warmth, light, contrast, colourfulness, hue range, woodness, brassness, greenery, coziness, stuff, cleanness, weight — and a room drawn live from them in one-point perspective. Nothing is a photograph and nothing is a preset.

Two more inputs are deliberately not axes, because they are constraints rather than taste: how big the room is and what it is for. Size is what decides how much of the frame the back wall fills, so a small room reads as small — the two pictures above are the same coordinates and the same furniture at 7.8 m² and 34 m².

Five of the rulesets are not sliders. 60:30:10, negative space, palette consistency, value contrast and practicality are measured off the room after it is drawn — the colour rules from every fill in the SVG weighted by its area, the rest from the floor plan in centimetres. A rule you can dial to 100 tells you nothing. These are allowed to disagree with you.

12 axes · 4 purposes · 15 styles · 5 measured rules · no server

Notes from the build

• "Practical" is not one thing. A living room is wrong if you cannot reach a table from the sofa; a bedroom is wrong if somebody has to climb over somebody to get out; a study is wrong if the window is straight in front of the screen. So each purpose brings its own checks — 60 cm on both sides of a double bed, 90 cm behind a desk chair to stand up, 90 cm to pull a dining chair out and walk behind it — and the reading names the distance that is wrong.
• Half the failures were the planner's fault, not the room's. The armchair failed its own "something within reach" check in every room, because a sofa centred on the wall with a chair bolted to one end leaves nowhere between them for a table. The desk landed in front of the window and then complained about glare. Both are fixed where they belong — in the layout, not in the check.
• A measure that moves the wrong way is worse than none. Value contrast was read off colour families, and which family a surface lands in flips as its lightness crosses a bucket edge — so turning contrast down could push the number up. It is now area-weighted straight off the shapes: the darkest quarter of the picture against the lightest.
• Styles are coordinates, not categories. Which means the app can say you are 71% of the way to Japandi, and it can put you halfway between Brutalist and Cottage — a real room you can look at. A list of styles has no halfway.
• Warmth is not a rotation of the colour wheel. Interpolating blue to red the short way runs through green at the midpoint, so every "warm" room came out olive. It is anchored now through the range interiors actually use: cold blue, blue-grey, sage, oat, tan, terracotta.

Same numbers, different rooms

What it is

The note asks for models. None of it needs one — paddings, margins, sizes, colours, areas are all things you can measure, and the reason nobody measures them is that the screenshot has thrown away the DOM, not that the problem is hard. So: drop in a screenshot, and Squint takes it apart in about a fifth of a second, in the browser, with the image never leaving the tab.

Nine layers drawn over the picture — blocks, spacing, padding, alignment, type, contrast, colour, and a squint test that blurs the screen until only the hierarchy is left. Every number is in the CSS pixels of the original interface, which is the number in somebody's stylesheet, not the number in the file. A phone screenshot is three device pixels to one, so getting that wrong makes an 8 px grid look like a 24 px one.

Two fixture pages, not one. One has mistakes planted in it — an off-grid gap, a 3 px misalignment, two card colours ΔE 1.6 apart, a footer at 2.19:1 — and the walkthrough asserts each one is found. The other is built strictly on eights and has nothing wrong with it at all. Half the work went into the second, because it is very easy to build something that finds faults everywhere.

9 layers · 46 assertions · 0 dependencies · 0 bytes uploaded

Notes from the build

• The most common colour is not the background. Cover more than half a screen in cards and the cards become "the page", white becomes content, and every reading after that is inside out — margins of zero, no gaps between anything. The page is whatever the frame is resting on, so it is taken from the border ring instead.
• Ink-to-ink is not a gap. The same 12 px margin measures 16, 17 or 18 depending on whether the heading above it happens to contain a descender. Line boxes have to be rebuilt: baseline from where the x-height band ends, leading from the tightest baseline-to-baseline step, box from the em box centred in it. Without that pass a design built strictly on eights measures as noise.
• A tolerance that cannot fail is not a measurement. Gaps come out good to about two pixels, and at ±2 a 3 px grid matches nearly every integer there is — so it would always "fit". The headline is not the unit at all now. It is whether the numbers repeat: four values across ten gaps is a scale, ten values across ten gaps is ten separate decisions.
• Ragged text has no right edge. Measuring padding-right from the longest line is how you end up telling somebody their card is padded 229 px on one side. Only something that is not a line of type can certify that side; without one the honest answer is that it cannot be measured, and that is what it says.
• Lossy screenshots invent colours. A ΔE of 1.3 between two darks in a WebP is the encoder's opinion, not the designer's. Squint counts how many colours hold real area; past a few hundred it says the file has been compressed and downgrades those findings rather than blaming the person who made the screen.

The control, and the patient