CraftyMasterman Built a Working RGB TV in Minecraft

There's a long tradition in Minecraft of people doing things the game was never supposed to allow. Functional calculators. Working hard drives. Entire CPUs built block by block. Redstone engineers treat the game's logic system the way jazz musicians treat chord changes: as a constraint that exists to be pushed until something beautiful falls out the other side.

CraftyMasterman's latest video is one of those moments. It documents the construction of what he's calling Minecraft's most realistic RGB screen, built entirely in vanilla redstone using a mechanic that only entered the game recently: cushions inside lamps.

The engineering is genuinely impressive. What makes it worth unpacking is not just the end product but the design decisions along the way, because each one reveals something interesting about how redstone logic works and where Minecraft's creative community is choosing to push it.

The Problem with Every Previous Method

CraftyMasterman opens by cataloguing the history of color screens in Minecraft, and it's a useful framing. He counts roughly a dozen methods, noting that most of them carry a serious compromise. Glowstone lamps are binary: on or off, light or dark. Map displays can produce rich color but require enormous physical footprints and complex setups. Entity-based approaches hit lag and scalability walls fast. Resource pack solutions can look great but import external assets, which the redstone community tends to view as cheating because it sidesteps the puzzle.

The tension he's identifying is real and not unique to Minecraft. Any display technology has to solve three interrelated problems: color range, resolution, and scalability. Most previous Minecraft screen methods solved one and botched the other two.

When Mojang added cushions, the community spotted an opening. Placing a colored cushion inside a lamp creates what functions like an LED: a controllable colored light source. The community quickly built dance floors and seven-segment displays with them. But as CraftyMasterman notes, any serious attempt at an actual screen was being done with data packs rather than redstone. Functional, yes. But not a redstone solution.

This distinction matters to the community. A data pack hands control to code running outside the game's block-logic system. A redstone build has to encode every behavior physically, in blocks. The constraints are much tighter, and so is the satisfaction when it works.

The Pixel Architecture: Oxidation as a Brightness Dial

Here's where the engineering gets clever. A real RGB screen doesn't just switch colors on and off. It adjusts the brightness of each color channel to mix a full spectrum. On your monitor right now, yellow isn't a separate color: it's red and green subpixels both running at high brightness. Dim the red, and it shifts toward green. That granular brightness control is what makes the color space deep.

CraftyMasterman's solution uses copper bulbs, which come in four oxidation states in Minecraft, each emitting a different light level. By combining standard copper bulbs, weathered bulbs, and oxidized bulbs in a 3x3 pixel grid, the design gets eight distinct brightness levels per color channel. That yields 512 possible color combinations per pixel, according to his breakdown in the video.

The reasoning for using oxidation states rather than stacking identical bulbs is demonstrated directly in the video. A collaborator generated a color gradient comparison: one version using mixed oxidation levels, one using only full-brightness bulbs. The mixed version shows noticeably more color nuance. The single-brightness version looks washed out by comparison. The physical property of the block, how its oxidation state changes its light emission, becomes the mechanism for tonal control. That's elegant.

The pixel layout itself also went through iterations. The initial design used a checkerboard arrangement to mimic the look of a CRT display. Later versions switched to a stripe pattern for a more filled-out appearance. CraftyMasterman actually asks viewers to weigh in on which pattern they prefer, which is a small thing but tells you something about how this community works: the aesthetic choices are collaborative, not unilateral.

Redstone at Scale: Where It Gets Messy

Getting the pixel design right was the easier part. Scaling it up into a working display required solving a different class of problems, and this is where the video is most candid about failure.

Version one of the screen was, by CraftyMasterman's own description, a disaster. It lagged the game severely, used an observer chain to carry signals upward (slow and inefficient), and the image storage circuit didn't work at all.

The fixes came from collaboration. His redstone "besties," credited in the video description as Sloimay, TheaMC-1, SacredRedstone, and MythicalPingu, helped redesign the core systems. The observer chain got replaced by a bubble column mechanic: soul sand pushed into water creates an upward bubble flow, and an observer at the top detects the state change instantly. Signal propagation went from slow to immediate.

The image storage problem got solved with a ROM (read-only memory) design. An image ROM in this context is a physical encoder: a circuit where each image is represented by a specific pattern of observers and doors that, when triggered, send the right on/off signals to the right pixels. As CraftyMasterman explains it: "Imagine we shrunk the screen to just be three pixels, and we want to store five different pictures. We need a circuit that can encode an input into the pixels that we want on or off." Scale that concept to a full display and you have an image library built entirely from blocks.

For context on how far this field has come, a Minecraft Forum showcase from the Java Edition era documents earlier color TV builds that required built-in FX panels and dedicated Row, Column, and Fill buttons just to manage image input. The workflow CraftyMasterman's team built, using a script to convert images into schematics and autoplace cushions from a command, represents a meaningful leap in how these screens are actually loaded with content.

Version two brought the ROM to both sides of the build to cut the overall height, added 64-image storage capacity, and landed on a resolution of 112x63 pixels. The performance impact on a standard machine running vanilla Minecraft was significant: the video reports it pulling frame rates down to around 20fps. The even larger version two doubled the resolution further and reportedly dropped a modded client with performance mods installed to around 1fps.

That performance wall is worth sitting with. It's not a knock on the build so much as a reminder that Minecraft's engine was never designed to process this many block state changes simultaneously. Every cushion is a separate block. Every copper bulb state is tracked. At a quarter million cushions, you're asking the game to do something genuinely unreasonable, and it mostly complies.

The Reaction, as Proof of Concept

The video's most entertaining stretch is also its clearest proof that the screen actually works. CraftyMasterman DMs several Twitch streamers, tells them they're on a redstone TV, and captures their live reactions.

The responses are unscripted and pretty telling. One streamer, seeing the image for the first time: "I can't even perceive this. These are all individual cushions." Another: "Bro created a TV in Minecraft. You built this with like your brain." The genuine confusion and then genuine excitement track exactly what you'd expect from someone watching a physical display material resolve into a recognizable face.

The fact that the images were "surprisingly legible even with images with text," as CraftyMasterman notes afterward, is the technical benchmark that matters most. Legibility at this resolution, in a voxel game, using oxidation states as brightness values, is not a given. It worked.

What CraftyMasterman built is not a curiosity. It's a proof that Minecraft's redstone system, given the right new primitive from Mojang, can close a gap that the community has been trying to close for years. Cushions were the missing piece, and this build demonstrates exactly why: they brought controllable, colorful light sources into a system that could already handle the logic, just not the color depth.

The question now is what the community does with 512 colors per pixel and a ROM that can store dozens of images. Dance floors and segment displays were the first wave. This is probably not the last.

Derek "D-Block" Washington covers gaming and interactive media for Buzzrag.