You probably don’t think about file sizes anymore. Nobody does. We live in an era where a Slack update eats 200 megabytes and nobody blinks. Where a simple to-do app ships with a Node_modules folder that could house a small civilization. We’ve stopped asking whether all that bloat is necessary — we just accept it as the cost of modern software.
But once a year, a group of developers gathers to remind everyone that we’ve been lying to ourselves.
The Js13kGames competition started its fifteenth edition this week. The rules are brutally simple: build a web game. The entire game — code, assets, everything — must fit in 13 kilobytes. Not 13 megabytes. 13 kilobytes. That’s smaller than a single high-resolution photo. That’s smaller than the HTML on most landing pages. That’s roughly the size of this paragraph repeated four times.
Constraints don’t kill creativity. They’re the only thing that ever actually sparked it.
Want to see what’s possible? Look at Q1K3, a game from a previous edition. It’s a full first-person shooter — levels, enemies, weapons, sound effects — packed into a footprint smaller than a single frame of a 4K video. Not a prototype. Not a tech demo. A genuinely playable, genuinely fun game.
How? By doing what most developers have forgotten how to do: caring about every single byte.
There’s a particular kind of nostalgia at work here. If you cut your teeth on computing in the 1980s or 1990s, you remember when 64 kilobytes felt like an ocean of possibility. You wrote tight loops. You reused variables. You understood what your code actually compiled to. Every byte was a decision, not an afterthought.
Somewhere along the way, we traded craftsmanship for convenience. We started importing libraries to avoid writing ten lines of code. We started shipping frameworks to avoid understanding the problem. And slowly, imperceptibly, we started believing that abundance was the same thing as progress.
The moment you stop asking ‘can I afford this byte’ is the moment you stop being an engineer and start being a consumer of other people’s abstractions.
This year’s theme is ‘Unicorns and Rainbows’ — which sounds absurd until you realize that absurdity under pressure is exactly where breakthroughs happen. When you can’t rely on assets, you rely on mechanics. When you can’t lean on graphics, you lean on gameplay. When you can’t throw budget at a problem, you throw ingenuity.
And here’s the uncomfortable truth that Js13kGames exposes every single year: most AAA games with multi-million-dollar budgets are less memorable than a 13KB game built by one person in a month. Not because the small games are technically superior. Because they’re designed with intention. Every element exists for a reason. Nothing is filler.
Scarcity forces you to decide what actually matters. Abundance lets you avoid the question entirely.
For developers, this competition is a gym for your brain. It’s a chance to relearn what your code actually costs. To feel the satisfaction of shaving 50 bytes off a function. To rediscover the pride of technical mastery that got most of us into this field in the first place — before standup meetings and Jira tickets and dependency hell drained all the joy out of it.
For everyone else, it’s a window into a different way of thinking. Not just about code — about anything. Because the principle extends far beyond game development. The best writing comes from word limits. The best design comes from constraint. The best ideas come from people who didn’t have enough resources to do it the ‘normal’ way and had to invent a better one.
We’ve been sold a story that more is better. More features. More options. More storage. More everything. But the Js13kGames competition keeps proving, year after year, that the opposite is true. The most creative, most memorable, most genuinely innovative work happens when someone draws a line and says: this is all you get. Now make something that matters.
The best games this competition has ever produced weren’t built despite the 13KB limit. They were built because of it.
So maybe the question isn’t what you’d build with unlimited resources. Maybe the question is what you’d build if someone took most of them away — and whether you’d finally discover what you’re actually capable of.
FAQ
Q: Isn't 13KB just a gimmick? Nobody ships real software that small.
A: Q1K3 is a full first-person shooter with levels, enemies, weapons, and sound — all in 13KB. It's not a gimmick. It's a proof that most of what we ship is unnecessary. The constraint exposes how much of modern software is dead weight we never questioned.
Q: What does this mean for everyday developers who aren't in a competition?
A: It means every dependency you add, every asset you bundle, every abstraction layer you stack has a cost — even if storage is cheap. The cost isn't in bytes. It's in complexity, maintainability, and the distance between you and your own code. Tighter constraints produce engineers who actually understand what they're building.
Q: Are you seriously saying small indie games are better than AAA titles?
A: Not better — more intentional. A 13KB game can't hide behind graphics or budget. It either has compelling mechanics or it doesn't. AAA games can mask weak design with production value. The competition proves that constraint strips away the crutches and forces you to build something that actually holds up on its own merits.