PICO-8 is a fantasy console. That means it's a make-believe game machine that only exists as software — there's no plastic box, no cartridge slot you can touch. You download it, and inside is a little computer with a tiny screen, a handful of colors, and just enough room to make a small game from start to finish.
Lexaloffle Games, run by Joseph "Zep" White, put it out in 2015. It didn't invent the idea of a deliberately limited virtual machine, but it's the one that made "fantasy console" a thing people actually say. Most newcomers to the whole genre start here.
The pitch is easy to miss because it sounds like a downside: PICO-8 is small on purpose. The screen is 128×128 pixels. You get 16 colors and that's it. Your code can only get so long before the console tells you to stop. None of that is a limitation it's apologizing for — it's the entire point, and once you sit with it for an afternoon, you start to get why.
| Spec | Value |
|---|---|
| Display | 128×128 px |
| Palette | 16 fixed colors |
| Language | Lua |
| Cartridge | .p8 text or .p8.png image |
| Built-in editors | code, sprites, map, sfx, music |
| Sharing | Lexaloffle BBS + in-app browser (Splore) |
| Runs on | Windows, macOS, Linux, Raspberry Pi |
| Try in browser | PICO-8 Education Edition (pico-8-edu.com) |
Boot PICO-8 and you don't land in a launcher or a project wizard. You get a blinking command prompt, like an old home computer. Type a couple of lines, hit a key, and your code runs right there. No build step. No importing assets. No second app open on the other monitor.
Everything you need is in that one window. Press a function key and you flip from the code editor to the sprite editor. Press another and you're drawing a tilemap, or laying down a chiptune in the sound editor. The art you draw, the music you write, and the code that ties them together all live in the same place, and you switch between them in a heartbeat. That sounds like a small thing. It changes how making a game feels — less like assembling a project, more like sketching.
Here's the part nobody tells you up front: people finish things in PICO-8. Game development is famously a graveyard of half-built projects, and a lot of that is scope. A blank engine will happily let you dream up a game ten times bigger than you'll ever ship. PICO-8 won't. The screen is small, the cartridge holds only so much code, and that ceiling quietly keeps your idea down to a size you can actually carry across the finish line. Constraints like these are usually treated as the price of admission. On PICO-8 they're the feature you end up grateful for.
The palette deserves its own paragraph. PICO-8 gives you 16 colors, fixed, and you don't get to pick different ones (the defaults are what nearly every cart uses). At first that feels stingy. Then you notice something: it's hard to make a PICO-8 game look bad. Every cart shares the same coral pinks, that particular dark blue, the off-white. The colors were chosen to sit together, so even rough programmer art comes out looking like it belongs to a family. You spend your energy on shapes and readability instead of agonizing over hex codes. Pixel artists who've spent years fighting infinite color pickers tend to find this genuinely freeing.
When you save a game, you can save it as a plain .p8 text file — handy, readable, friendly to version control. But the format people love is the .p8.png: an actual PNG image of your game's label screen, with the whole cartridge — code, sprites, sound, everything — tucked invisibly into the pixels.
So a PICO-8 game is a picture. You can post that picture anywhere images go, and anyone can drag it back into PICO-8 to play it. Browse the Lexaloffle BBS and you'll see walls of these little cart labels, each one a complete game you can grab in one click. Inside the console, a browser called Splore lets you scroll through community carts and play them without ever leaving PICO-8. The machine and its library of games are the same screen.
If you want the quickest possible sense of the thing, this is a good intro:
This is a complete PICO-8 program. Not a snippet — the whole thing. Paste it in, hit run, and you've got a white square you can move around.
-- a tiny complete game
local px, py = 64, 64
function _update()
if btn(0) then px -= 2 end -- left
if btn(1) then px += 2 end -- right
if btn(2) then py -= 2 end -- up
if btn(3) then py += 2 end -- down
end
function _draw()
cls(0) -- clear to black
rectfill(px-4, py-4, px+4, py+4, 7) -- white square
print("arrows to move", 4, 4, 7)
end
PICO-8 calls _update() and _draw() for you, 60 times a second. You put your game logic in one and your drawing in the other, and that's the rhythm of basically every PICO-8 game ever made. There's a third function, _init(), that runs once at the start if you need it.
That's the appeal in miniature: a real, running, interactive thing in a dozen lines, and you can see every single piece of how it works. There's nothing hidden. When you're ready, swap the rectfill for a sprite you drew, add a btnp(4) check to jump, drop in a sound with sfx(0). The shape of the program never changes — you just keep filling it in.
A whole subculture has grown up around squeezing things into PICO-8's code budget. Tweetcarts are tiny programs short enough to fit in a single social-media post — usually a swirling, animated little visual made of pure math, no sprites at all. People treat the constraint as a puzzle and a sport. It's the demoscene spirit living inside a game console, and it's a big part of why creative coders, not just game makers, are drawn here.
And to be clear, the ceiling isn't that low. The original Celeste — yes, that Celeste — started life as a PICO-8 cart made for a game jam, before it grew into the full commercial release. So the same little machine hosts throwaway one-tweet experiments and the seed of an award-winning platformer. Here's the original cart being played start to finish:
PICO-8 has cousins, and they're worth knowing about. TIC-80 is the closest in spirit — another tiny virtual machine, free and open source, with a slightly bigger screen and a pick of programming languages. WASM-4, LIKO-12, PixelVision8, and Lexaloffle's own bigger sibling Picotron each stake out nearby ground. None of them is "the winner." They're different trade-offs, and the honest way to choose is to try the one whose editor and language feel good in your hands.
What keeps PICO-8 the usual first stop isn't that it's the most capable — by design it isn't. It's that the whole package is so coherent and so easy to peek inside. Years of community carts sit on the BBS waiting to be opened in the editor and taken apart, which is the best way anyone learns this stuff: load a finished game, see how it was built, change something, run it again.
PICO-8 is a paid desktop download from Lexaloffle (around the price of a cheap lunch, but check the official site for the current figure, since that sort of thing changes). If you'd rather poke at it first, the free, browser-based PICO-8 Education Edition lets you write and run code without buying anything.
Reach for PICO-8 if you want to make small games and actually finish them, if you like the idea of seeing every layer of how a game works, or if you just want a cozy, self-contained place to mess around with pixels and chiptunes after work. Reach for something else if you're after big assets, modern rendering, and a full production engine — PICO-8 will frustrate you, and it's supposed to. The limits aren't in your way. They're the lesson.
The source code is closed (PICO-8 is a commercial product), so there's no public repo — but everything you need starts here:
Getting started: open the Education Edition or install PICO-8, type a few lines at the prompt, browse a couple of carts in Splore, and crack one open in the editor. The fastest way to get it is to make something tiny and finish it.