Why 8-Bit Is Back: Retro Gaming, Pixel Art and Building Your Own Console

Something odd happened while games got photorealistic: kids started choosing to play things that look like 1989. Minecraft is blocks. Stardew Valley is pixels. Undertale, Celeste, Terraria, half of Roblox - all deliberately low-fidelity, all enormous with children who have a 4K console in the next room.

That’s not nostalgia on their part; they weren’t there. It’s something more useful. Low-fidelity games are legible. A kid can look at a pixel-art sprite and think I could make that, in a way nobody looks at a modern AAA game and thinks anything of the sort. Which is why retro is the best on-ramp into actually making games - and why building the console yourself is the version of this hobby with the longest legs.

The Case for Constraints

Ask a kid to make a modern-looking game and they’ll quit in a week - the art alone is a career. Ask them to make an 8-bit game and the whole thing is suddenly the size of an actual afternoon.

Constraints do three helpful things:

They make finishing possible. A 16×16 sprite takes ten minutes, not ten hours. A finished bad game teaches more than an unfinished ambitious one.

They force design decisions. With four buttons and a small screen, you can’t solve a problem by adding a feature. You have to make the core loop good. That’s the same discipline that separates good games from bloated ones at any budget.

They make the machine visible. At this scale a kid can hold the whole system in their head: the screen is a grid of pixels, the sprite is a small array, the game loop runs sixty times a second. Modern engines hide all of that behind abstractions. Retro hardware doesn’t hide anything, which is exactly why it teaches.

From Playing Retro to Making Retro

There’s a natural four-step path here, and most kids stall because nobody shows them step two.

• Play: Discover pixel-art games and get hooked on the aesthetic - Already happening
• Build the hardware: Assemble a handheld console themselves - 1-2 hours
• Make sprites: Draw characters and tiles on a pixel grid - An evening
• Code the game: Movement, collisions, score, game over - Weeks to years

Step two matters more than it looks. A kid who has assembled the device holds a completely different relationship to it: they know there’s a microcontroller in there, a display, a speaker, a battery, and that the game they write runs on hardware they screwed together. It converts a console from a magic box into a machine.

The CircuitMess ByteBoi 2.0 ($159) is designed for exactly this arc - a retro handheld with a microcontroller, display, speaker, micro SD card and rechargeable battery, shipping with pre-loaded games and programmable in CircuitBlocks, whose drag-and-drop blocks convert to real Arduino-compatible code. Neat detail for later: it also works as a controller for the Wheelson robot car, so the console has a second life if the kid’s interest drifts toward robotics.

For younger kids or a smaller budget, Bit 2.0 ($89, ages 7+) is the simpler version - an 8-bit DIY console with pre-loaded arcade-style games and the same coding path. It also has the most collectible ecosystem in the range: Bit Expansions at $8.99 each, each unlocking a unique game plus 14 tradable cards, with all nine available together as the Complete Wacky Expansion ($80.91) or bundled with the console as the Wacky Collector’s Bundle ($169.91).

Pixel Art Is the Sneaky Part

Everyone focuses on the code. The art is where a lot of kids - particularly ones who don’t think of themselves as “techy” - get pulled in.

Pixel art at 16×16 is a genuine design discipline with rules a child can learn in an evening: silhouettes read before details, a limited palette looks better than a big one, one pixel of highlight suggests a light source, animation is four frames not forty. It’s drawing with severe constraints, which is why it’s so satisfying and why the results look good fast.

It also produces the moment that hooks kids for good: a character they drew, moving on a screen, on a device they built. That’s three kinds of ownership stacked on top of each other, and nothing in a store-bought game comes close.

A first-evening project: draw a sprite, get it on screen, make it move with the buttons. That’s it. Score, enemies and levels come later - the goal of night one is seeing your own drawing respond to your own thumbs.

The Parent Angle Nobody Mentions

You are, in this scenario, unusually useful.

If you grew up with a Game Boy, a Mega Drive, an NES or a C64, you have direct experience of the constraints your kid is now designing within - and that’s rare. Most of the time parents are the ones catching up on their child’s technology. Here, for once, the arrows point the other way.

Two things worth doing with that:

Show them the originals. Not as a history lesson - as reference. Look at how Super Mario Bros. teaches you to jump without a tutorial. Look at how much personality a Pokémon sprite carries in 56×56 pixels. Kids study these properly once they’re trying to make something similar.

Build it with them, then get out of the way. The assembly is a good joint activity. The game design should be theirs entirely, including the bad ideas. Our guide on what to build after the first STEM kit covers reading which part they actually loved.

Where the Coding Goes From Here

A console is the friendliest possible reason to keep programming, because the feedback is immediate and visible and the ambition scales indefinitely.

The usual progression: blocks for the first few games, then reading the generated code, then writing text code directly - Python or C++ depending on the platform. Kids resist this jump when it’s framed as “learning to code” and accept it easily when it’s framed as “the blocks can’t do what you want any more.” We’ve written the detailed version in from block coding to real Python.

And if the kid’s ambition is specifically to make games rather than gadgets, our parent’s roadmap for kids who want to make video games maps the whole path from Scratch to real code to their own console.

What to Buy for Which Kid

The kid who plays constantly but has never made anything. Bit 2.0. Low commitment, quick build, pre-loaded games mean instant payoff, and the coding is there when they’re ready.

The kid who has already made Scratch games. ByteBoi 2.0. They have the concepts; what’s missing is hardware that makes their work feel real.

The kid who wants everything. The Coding Bundle 2.0 contains ByteBoi 2.0, Bit 2.0 and Codee 2.0 - three programmable devices, which also solves the sibling problem.

The kid who collects. Bit 2.0 plus expansions. The $8.99 price point turns pocket money into a hobby, and the tradable cards give the collection a physical dimension.

The teenager who’s serious. Skip ahead: console plus soldering plus text code, then let them loose on their own designs. At that point they don’t need kits so much as parts and time.

Frequently Asked Questions

Why do kids like retro-style games when modern graphics exist?

Because low-fidelity games are legible and modern ones aren’t. A pixel-art game looks makeable - a kid can imagine drawing that character and building that world - while a photorealistic game looks like it came from another planet. That’s why Minecraft, Terraria, Stardew Valley and much of Roblox all use deliberately simple visuals: they invite participation rather than just consumption.

Can a kid really build their own games console?

Yes, and it’s an afternoon rather than a project. Kits like CircuitMess ByteBoi 2.0 take around 90 minutes with a screwdriver and no soldering, producing a working handheld with a display, speaker, battery and SD card storage - pre-loaded with games and programmable afterwards. Bit 2.0 is the simpler under-an-hour version.

What age can kids start making their own games?

Sprite drawing and simple block-based game logic work from about 7-8. Building the hardware suits 7+ for the simplest kits and 9+ for a full handheld console. Text-based coding usually lands somewhere between 10 and 13, driven by readiness rather than birthday - typically when the child gets frustrated by what blocks can’t do.

Is pixel art a useful skill or just a style?

Both. It’s an actual discipline with rules - silhouette, limited palette, implied light, economical animation - and those constraints teach composition faster than open-ended drawing does. It’s also directly employable in indie game development, where the aesthetic is a deliberate choice rather than a limitation.

Do you need a computer to program these consoles?

Yes - you code on a computer and transfer the program to the console over USB. The editor for CircuitMess devices, CircuitBlocks, runs in a browser, so there’s no software to install and it works on most machines. Blocks convert to Arduino-compatible code, which is what makes the later jump to text programming a small step rather than a fresh start.

What if my kid just wants to play the games and never codes?

That’s a perfectly good outcome, and the build was still worth it. Assembling a working device teaches electronics, patience and how hardware fits together, regardless of what happens next. Plenty of kids play for six months and then get curious about changing something - the coding is there when they arrive at it rather than something they have to be pushed into.

The Bottom Line

8-bit came back because it’s the only kind of game that looks makeable to a ten-year-old - and that’s a gift if you want a kid making things rather than only playing them. Build the hardware first, draw a sprite second, code the game third, and don’t rush past the moment where their own character moves on their own device. A DIY handheld console from CircuitMess is where the whole arc starts - and yes, you’re allowed to play it too.