Building a Self-Hosted Tronbyt LED Matrix Clock

Why build instead of buy?

I’d been eyeing the Tidbyt for a while. It’s a charming little wood-framed LED matrix display that shows the time, weather, sports scores, and whatever else you throw at it. But two things stopped me from buying one. First, Tidbyt (the company) was acquired by Modal in 2024, and the long-term future of their cloud service is anyone’s guess. Second, and more fundamentally: the Tidbyt depends on someone else’s cloud to render and push apps to a display sitting on my nightstand. If you’ve read my other posts, you already know how I feel about that.

Enter Tronbyt. It checks every box the Tidbyt does, plus the ones I actually care about:

• Self-hosted. The rendering server runs on my own hardware, in Docker, right next to everything else in my homelab.
• Local network only. No cloud dependency, no phoning home. If my internet goes out, my clock keeps ticking.
• Full control. Over the apps, the data, the update cadence, all of it.

What is Tronbyt?

Tronbyt is an open source ecosystem replacement for Tidbyt. Instead of pointing your display at Tidbyt’s cloud, you run a local Tronbyt server that renders apps and pushes the resulting images to your display over your own network. Crucially, it supports the full Tidbyt app library through a hard fork of the community apps repo, so all those clocks, weather widgets, and transit trackers people have written over the years work out of the box.

The reference Tronbyt hardware is an ESP32-based display, but the project also supports driving a standard HUB75 LED matrix panel from a Raspberry Pi via a daemon called Tronberry. I had a Pi 4 collecting dust, so that’s the route I took.

Parts List

Total: ~$158

Not bad, considering a Tidbyt ran $199 before they stopped selling them, and this version answers to no one but me.

Architecture

The display itself is intentionally dumb. Here’s how the pieces fit together:

• The Tronbyt server runs in Docker on my Minisforum home server, alongside the rest of my homelab stack (Jellyfin, Pi-hole, Actual Budget, and friends).
• The server renders app images and pushes them to the display every minute.
• The Raspberry Pi 4 behind the LED panel runs Tronberry, a daemon that connects to the Tronbyt server over a WebSocket and paints whatever it receives onto the matrix.

If you’ve read my post on containerizing home network services, the server side of this will look very familiar. It’s just one more compose stack.

Hardware Assembly

The build is mostly straightforward: the RGB Matrix Bonnet sits on the Pi’s GPIO header, an IDC ribbon cable runs from the bonnet to the panel, and the 5V 4A supply feeds the panel through the bonnet’s screw terminal block. A few things worth calling out:

• The Pi 4’s PoE header gets in the way. The PoE pins sit right where the bonnet wants to be, so a GPIO riser header is required to give the bonnet enough clearance. Cheap fix, but you need to know about it before assembly day.
• The power cable’s spade connectors didn’t fit the terminal block. I had to strip the spade connectors off and screw the bare wires down directly.
• The IDC ribbon cable goes to INPUT, not OUTPUT. These panels are designed to be daisy-chained, so there are two identical-looking IDC connectors on the back. I plugged into OUTPUT first and spent a while staring at a dark panel before figuring it out. Learn from my mistake.
• The Pi is back-powered through the bonnet. The bonnet feeds 5V back through the GPIO header, so no separate USB-C power supply is needed for the Pi. One wall wart runs the whole thing. I stress tested this configuration under load before trusting it, and it held up fine.

The enclosure is a 3D printed modular case from Thingiverse (dlongley’s Adafruit 64x32 design). I glued 10x2mm neodymium magnets into the frame with E6000 so the front panel snaps on and off cleanly, which makes getting back inside painless.

Software Setup

The software side breaks into two halves, the server and the display.

On the server, Tronbyt deploys via Docker Compose. The only wrinkle in my setup was that the default port 8000 was already claimed by Portainer, so I moved Tronbyt to 8001:

services:
  tronbyt-server:
    image: ghcr.io/tronbyt/server:latest
    ports:
      - "8001:8000"
    volumes:
      - ./data:/app/data
    restart: unless-stopped

On the Pi, the Tronberry install is refreshingly simple. A one-liner installer handles everything, including registering a systemd service so the daemon survives reboots. A couple of configuration notes:

• In the Tronbyt Manager UI, the device type must be set to “Raspberry Pi”, not “Raspberry Pi Wide”. The Wide profile targets 128x64 panels, and picking it on a 64x32 panel gets you a scrambled display.
• WiFi is managed through NetworkManager, with a static IP reservation on my router so the Pi always comes up at the same address.

The og-clock App

The app I actually wanted out of all this is og-clock: time, temperature, humidity, and a weather icon on one clean screen. It pulls conditions from the OpenWeather API, and since I already had an API key from my Home Assistant setup, that part took thirty seconds.

One design detail I appreciated: the Tronbyt server caches weather data server-side. The display refreshes every minute, but that doesn’t translate into an API call every minute, so the free OpenWeather tier is in no danger. It’s a small thing, but it’s the kind of consideration that tells you the project is built by people who actually run it.

What I’d Do Differently

• Pre-drill the cable holes before assembly. I put the enclosure together first and then had to work out cable routing with everything already mounted. Drilling the pass-throughs first would have saved real time and some frustration.
• Connect the IDC cable to INPUT the first time. See above. The connectors are labeled; I just didn’t read them.

What’s Next

• A second app in the rotation for the nightstand. The Tidbyt app library is huge, and now all of it runs on my hardware.
• Home Assistant integration for automations: dim the display at night, flash alerts when something in the homelab needs attention.
• Possibly a second display built around the Matrix Portal S3, which would skip the Pi entirely and run the display side on a microcontroller.

For about $158 and an afternoon of assembly, I have a nightstand clock that renders on my own server, runs apps from a huge community library, and will keep working no matter what happens to anyone’s cloud. That’s the whole homelab thesis in one little glowing box.