If you got here from a search, a friend's link, or social media, here's what you've found.
Crash The Stack is a collection of cyberpunk takes on classic casual games, and it's early. Two games are in: STACK, which is Mahjongg solitaire under a trace, and DEFRAG, which is Klondike as a memory dump. The hub between them is where the runs happen. More modes are on the way, and I'm building the whole thing in public, with every commit in the source and the reasoning in this devlog.
JACK IN opens the game in your browser. On a phone, the browser's own menu will offer to install it; do that and it runs fullscreen. There's no account and there are no ads.
JACK IN from the menu is the run itself. You walk a sector of Gibson's system, and the world moves on the beat of the music: one step a beat, whether or not you touch anything, and the daemons patrol on the same clock. The framed tiles are nodes. Stand on one, press Enter, and it opens a board: STACK on the odd layers, DEFRAG on the even ones. Clear it and the node crashes, which pays its bounty in credits and hands you its key; you come back to the sector standing where you left. Enough keys open the way down, and there are six layers, each wider and busier than the last. The bar at the bottom left is the trace, and it fills while you stand there thinking.
STACK: match free tiles in pairs. A tile is free when nothing sits on top of it and at least one of its long sides is open. If you know Mahjongg solitaire, that's the rule and there's no other. Play it clean, the way GNOME plays it, or with the trace on: three minutes until you're traced, then the counter-hacks come (locks, a forced shuffle, scrambled faces) while a forty second countdown runs to the severed connection. A hint mode lights the pairs you can play; a cursor is there if you'd rather use the keyboard.
DEFRAG: it's Klondike. Build down the table alternating hot and cold, build the four foundations up from BOOT to ROOT, PULL from the feed one or three at a time. PROBE shows you the next move of a winning line from where you are, and refuses when there isn't one.
FREE PLAY gives you either game on its own. Pick STACK or DEFRAG and you get a new board, that day's daily (the same layout for everyone), and the version to play it in: HACKER with the trace, or CLASSIC without. Every board has a share code, so you can send someone the exact layout you just played.
It's a 0.1. The classics' rules are the settled part: a free tile is a free tile, and Klondike builds the way Klondike builds. Everything I've put around them is still moving, and some of it has moved already: the trace numbers came down twice in the first week. Expect more of that, plus new modes as drops (SCAN, a Minesweeper with a hacking angle, is first), the sector growing past its six layers, and Gibson getting more to say. When something you saved stops working across a version, that's a bug, and I'd like to hear about it.
The music is twenty tunes written in the game's own tracker, and you can hear the album on the soundtrack page. The tracker is part of the game and has its own page at /tracker/: load a tune, change a note, and hear it at the next tick. The manual is here on the site.
I designed this game and I direct every part of how it's built. AI agents write most of the code from my direction; I direct every decision, I play every build, I review the art and the music, and I decide what stays. The design, the art direction and the opinions are mine. If the use of AI is dealbreaker for you, I understand! The source and the commit history are public, so you can see exactly how it was made.
The About page has the licences and the rest, and the earlier posts here tell the story of how it got to this point, starting with the version I wrote by hand in 2020. Thanks for playing.
", "summary": "What Crash The Stack is right now, how to play it, and what to expect from a game being built in public." }, { "id": "https://crashthestack.com/devlog/the-trace-has-phases/", "url": "https://crashthestack.com/devlog/the-trace-has-phases/", "title": "The trace has phases", "date_published": "2026-09-18T12:00:00Z", "content_html": "The first build with a trace meter did almost nothing with it. I filled the meter, it told me a pair was locked and drew the two tiles red, and then I picked the pair anyway and kept playing. If that had been the last possible pair, the game should have ended. Instead nothing happened at all, and I sent that note back: being traced has to mean something, and it has to be clear what.
The proposal that came back was a cycling bar with escalating locks and a rule that the last legal match could never be locked, so Mahjongg would keep its no-fail-state feel. I overruled it the same day, because I already knew what I wanted the trace to be: phases.
The first phase is being traced. Once you're traced, you're vulnerable to counter-hacking measures. And when the real timer runs out, your connection gets severed. TRACE, COUNTER-HACK, SEVERED. The twist mode gained a fail state that day; the clean mode keeps GNOME's rule. The counter-hacks are a set you can add to (a lock, a forced shuffle, a scrambled face), and the numbers (five minutes to the trace, another minute to the sever) were a starting point to tune from my own clear times. They came down to three minutes and forty seconds over the next few days of playing.
Locks came out of playing the installed app on the phone a few hours later. Should a lock be breakable? Only if the locked pair is the last one; then it's a weak lock, a different color, and one tap breaks it. Strong locks are unbreakable. A strong lock decays into a weak one after 45 seconds, or the moment it blocks your last legal match. That's the whole system, and I like how small it is.
DEFRAG started as a question: is there any way to make this feel like Klondike but more cyberpunk? What if we weren't talking about cards, or at least not in the playing-card sense?
The answer was a memory dump. Packets instead of cards. Hot and cold instead of red and black. Four subsystems instead of four suits: PWR, TX, MEM, DSK. BOOT at the bottom of a run and ROOT at the top, with DAEMON and SYSOP where the jack and queen would be. You PULL from the feed, COMMIT to the foundations, ROLLBACK a move, PROBE for a hint. Clear the table and the system comes back online. I loved that reading the moment I saw it, and after playing it on the phone the only change was the colors: hot is orange, cold is blue.
The same day I wrote down what the game is actually about. It's 2030, and the rapid pace of AI self-improvement has produced a superintelligence named Gibson that now threatens to take control of human civilization. You are Crash, a member of a hacker collective on a mission to destroy Gibson. Gibson's defenses are layers, so Crash crashes the Stack. Gibson taunts you, and he's clever about it; think of how Plague talked in Hackers. The system speaks in flat all-caps; Gibson speaks in sentences, first person, and only once he's noticed you.
I'm aware of what it means to make a game about destroying a runaway AI in the open, with AI agents writing most of the code. I've decided to let that sit exactly where it is.
Two modes at the top level came out of this: JACK IN is the real game, with the overworld; FREE PLAY is just the games, in their classic form or the hacker one, outside the world. And a site with an About page and this devlog, so nobody who plays the fullscreen app has to miss a post. That last decision is why the game lives at /jack-in/ and not at the root: an installed app that opens a link outside its own path opens it in the browser, the way a link should.
Next: what this is right now, and how to play it.
", "summary": "The first real play test, the counter-hack, Klondike without playing cards, and the year 2030." }, { "id": "https://crashthestack.com/devlog/the-classics-are-sacred/", "url": "https://crashthestack.com/devlog/the-classics-are-sacred/", "title": "The classics are sacred", "date_published": "2026-09-16T18:00:00Z", "content_html": "The brief I wrote on the morning of September 16th was short. I wanted cyberpunk Mahjongg and Solitaire, with GNOME Mahjongg and Windows Klondike as the references, maybe one game with modes, maybe a story mode, and I wanted to finally make progress now that Sigil could build the same game for the desktop and the web. I've been working with AI agents (Claude, and Codex for some of it) on Sigil itself for a while, so I asked one to write a design document and stop there. No code.
The first draft came back with a collection of modes and a lot of sensible defaults. I read it with about forty inline comments, and my own thinking shifted while I was reading. Three of those comments changed the shape of the game.
The first was the name. Crash The Stack stays. It's a nod to my favorite movie, Hackers, and I want the whole thing to draw on that: the theme, the visual style, the way the computers talk to you.
The second was the shape. Where the draft had a "collection with modes," I asked: what if the collection was the overworld of the game, the thing that ties everything together, and the stack games were the actual hacking mechanics? You're a hacker. The games are the hacks. That one sentence turned a bundle into a game, and everything since has been built on it.
The third was about me. I'd written this rules code three times already, and writing it a fourth time by hand was exactly the slog that killed the first three tries. So I chose not to. The agents type; I direct. I decide what the game is, I play every build, and I review all of the art and music myself. That became the rule for every phase of the project, and it's the reason the About page says what it says about how this was made.
The classics are sacred. Every mode keeps its classic's core rules exactly. If you know Mahjongg solitaire, you already know how to play STACK: a free tile has a free side and nothing on top, and you match pairs. If you know Klondike, you know DEFRAG. The theme sits around the rules, never inside them. That was true in the 2020 version and it's true now.
Some smaller rulings from the same day that I still like: tap, not drag. Keep the keyboard-first play from Cybersol alongside touch. Draw one preferred, draw three offered. Vegas scoring is fine. And a banked, costly scramble for Klondike: a way to shuffle what's left on the table when you're stuck, that has to cost something to get or to use.
The afternoon was the plan: phases, each with a gate the build has to pass before I look at it, and a review before anything counts as done. Two decisions from that afternoon shaped everything after.
We went web first. Not because the web is the only target (it is one of them), but because a hosted build meant I could easily test on my phone whenever I was away from the computer. Every phase since has ended with me playing it on the phone and sending notes back.
The keyboard was the one thing I refused to decide on paper. Three models for moving around a 2D tile layout: a cursor, typed coordinates, and typing the glyph on the tile you want. All three got built and I played them. Typing the glyph felt like cheating. Coordinates were too hard to scan. What survived is a hint mode that lights the pairs you can play, with a cursor as the backup. Played, not argued.
Next: the day the trace meter turned into a game.
", "summary": "The plan for the fourth try, what changed in the first day of comments, and why I chose to review everything instead of writing it." }, { "id": "https://crashthestack.com/devlog/three-tries/", "url": "https://crashthestack.com/devlog/three-tries/", "title": "Three tries at the same game", "date_published": "2026-09-16T10:00:00Z", "content_html": "I've wanted to make a cyberpunk Mahjongg solitaire for a long time. Long enough that I've written it three different times.
The first Crash The Stack was in May 2020, in Gambit Scheme on Substratic, an engine I was building at the time. Sixty-four commits, all written by hand. It had a complete Mahjongg core in about 480 lines: the occlusion map, the "is this tile free" rule, matching, the shuffle, and a layout format where I'd transcribed the GNOME Turtle by hand, all 144 tiles. It had a stack editor with vim keys and a title screen that said "Flux Harmonic Presents / A game by David Wilson." It never had a hint, a timer, a score, a win screen, or a single cyberpunk mechanic. The source is still up on GitHub.
The second try was March 2022, in Mesche, the Scheme-derived language I wrote before Sigil. Forty-four commits, and thirty of them were purely engine work, a lot of it written on Flux Harmonic streams. It rendered twenty tiles from a faces atlas, and the playability check was a stub. The engine work ate the game.
The third was a cousin: *Cybersol*, October 2023, for the Autumn Lisp Game Jam, written in Guile Hoot. Twenty-four commits in eight days. A working Klondike in 437 lines, keyboard-only so it would feel like a hacker game (asdf and jkl for the piles), SVG card art I drew myself and have since called "pretty awful." The TODO list ended with "implement new game mechanics to introduce the cyberpunk theme." I never started that task.
Here's the pattern I only saw when I lined them up: every time, the classic's core rule was working in under 500 lines, and every time the project stalled at the platform step. The engine, the build, the web export. The game was never the hard part. Getting it in front of someone was.
By this year that had changed. Sigil, the successor to Mesche, had grown a graphics library, a web build and audio tools, and two other projects had proven them: a rhythm game and a small Sokoban called blackICE that I'd mostly let an AI agent build as a test of the web bridge. blackICE taught me something too, mostly by being the thing I didn't want: it was a one-shot project, I had almost no input on it, and it plays like that. But its rules module (a grid, daemons on routes, a trace timer, undo) turned out to be the skeleton of the overworld, the part of this game I've wanted for six years and never built.
So in September I started the fourth try, and this time the platform was the solved part, after ten months of Sigil. The twists on the classic game mechanics were the next thing to build. That's the whole reason this project exists now, and the reason it's the one you can play.
The next post is about the plan, and about the first decision I reversed on myself before any code existed.
", "summary": "Crash The Stack in 2020, again in 2022, a cousin in 2023, and why the fourth try is the one that shipped." } ] }