An 8-bit live gamecast turns every MLB pitch into pixel art in real time

No camera feed, no audio — just a live baseball game rebuilt pitch by pitch as a retro pixel broadcast. People left it running on the TV and compared it to the real game.

In brief

Ribbie reimagines a live MLB game as an 8-bit broadcast: scores, counts, baserunners, every play animated as it happens, with between-innings around-the-league stats. One viewer who doesn't watch sports put a real game on next to it just to compare.

The thread's quiet asterisk came from a commenter wondering what live data feed it leans on, and whether 'small-scale hobby' fair use survives contact with the MLB, which is famously protective of exactly this.

A baseball broadcast with no broadcast

Ribbie 8-bit baseball gamecast
Ribbie 8-bit baseball gamecast

Ribbie does something deliberately strange: it covers a live Major League Baseball game without showing the game. No camera feed, no commentary audio — instead the score, the count, the baserunners and every play are rendered as an 8-bit pixel-art animation that updates in real time as the at-bats happen. Between innings it cycles around-the-league scores and stats, the way a real broadcast cuts to the studio.

The recurring wish across the thread was sound: with a synced audio feed of balls, strikes and hits, you could leave it running while you did something else. The aesthetic, for most, was the draw — the look of a calm, low-stakes broadcast you keep on a second screen.

▶ Watch a live gamecast on ribbie.tv

What the thread argued about: the data, and the bit-depth

The most interesting question wasn't about the art — it was about where the live game state comes from. A high-karma commenter pointed at the legal third rail directly:

"We know the MLB is famously understanding with creative repurposing of their data, so I wonder what live data you are using and if the rationale for use is something like small scale hobby/fair use?… projects like the Sean Lahman Database have to go through quite a bit of trouble to reproduce 'clean room' versions of historical data." — a commenter who tracks baseball-data licensing

That 'famously understanding' is sarcasm: the league is aggressive about exactly this kind of reuse, and live data carries far more risk than the historical stats hobby projects already fight to clean-room.

The aesthetics drew the other split. A blunter take questioned the pixels themselves:

"fun idea and gj execution, but the art looks like bad ai pixel art, at least on my screen. gives it that uncanny youtube music stream look." — a commenter judging it on his own display

And the obligatory pedant arrived on schedule:

"PEDANT ALERT: This is clearly 16 bit." — a commenter correcting the bit-depth

Why a play-by-play looks better than a highlight reel

One comment caught why the format works at all. Baseball is discrete (pitch, swing, outcome), so a recreation can be faithful in a way a fluid sport can't:

"Something about the way baseball itself is played seems to make recreations really satisfying — like, more accurate? — and fun compared to say, soccer hilights of matches on Youtube made with what looks like an EA soccer video game." — a viewer struck by how well the discrete sport maps to pixels

That is the quiet thesis under the toy. A camera shows you what happened; a state-driven pixel cast shows you only the structure of what happened. For a sport built from countable events, the structure is most of the fun. The open question is the one the data comment raised: a tool this good at repackaging the live game state is exactly the kind of thing a league's lawyers notice once it stops looking like a hobby.

Get breakdowns like this every day

The top Hacker News stories, unpacked — by email, Telegram, or RSS.

Next story · 22 of 24 Read more
🚀Tech

MicroUI is a complete GUI library in ~1100 lines of C that draws nothing itself

rxi's MicroUI fits an immediate-mode UI toolkit — windows, sliders, scrollable panels, word-wrapped text — into about 1100 lines of ANSI C with zero heap allocation. The trick to staying tiny: it never touches the screen. You wire up the rendering.

★ 191 · 💬 71 · github.com · 4 min