u/xDaftTurtle

They normally live in different rooms. Grouped them together so you can see what each one does.

Right: the house. Doors, presence, and whether I've been at the desk today, as a 24h timeline out of Home Assistant.

Middle: the Pi that runs the house, via Glances. CPU, memory, core temp, containers, plus indoor climate and the litter robot.

Left: my GitHub streak, quietly reminding me I could be doing something useful instead of building more panels.

Hardware is a Seeed reTerminal E1001, a TRMNL X and a reTerminal E1002. All three run off Tesserae, a self-hosted dashboard server I have been building. HA App or Docker, pulls over the REST API, sends each panel a frame every few minutes so they can go back to sleep.

Ask me anything about the panels or the layouts.

My TRMNL X pointed at a self-hosted BYOS instead of the cloud. The dashboard is system stats for the box that hosts everything, pulled from Glances: CPU, memory, disk, temp, per-core load, and every container ranked by resident memory. GitHub commit activity down the right.

The server is something I built called Tesserae. You compose dashboards in a browser, it renders the frame headless and pushes the image to the panel, so the TRMNL just paints a bitmap as usual. Point the device's BYOS URL at it and you're done.

The other two panels are running off the same server: an Xteink X4 showing a Pokedex, and a 4.2" PicPak showing a picture of my cat Ada. Three different panel families, three resolutions, and the PicPak is four-colour while the TRMNL X is grayscale. That was the reason I wrote it rather than using an existing BYOS. One place to build dashboards, whatever the panel is.

AGPL-3.0, Docker Compose or a Home Assistant app.

https://github.com/dmellok/tesserae

Panel is a Seeed reTerminal E1004, 13.3" Spectra 6 at 1200x1600. It refreshes every 15 minutes and rotates through a few different dashboards. Departures from PTV's API, weather from Open-Meteo, map from OpenStreetMap data via OpenFreeMap and OpenMapTiles. The page is built in Tesserae, a self-hosted dashboard companion I've been building for e-ink panels: compose in a browser, a headless renderer produces the frame, the panel fetches it over REST. Source at github.com/dmellok/tesserae, website at tesserae.ink.

I used i3 on Linux for years. Windows tile themselves, you move between them with the keyboard, and you never touch the mouse to arrange anything. Then I moved to macOS, where windows pile up wherever they feel like it, and none of that muscle memory works.

There are tiling window managers for macOS. The one I settled on, AeroSpace, is genuinely good and gets you most of the way. But a few specific i3 habits kept hitting walls, so I forked it and put them back.

Tabs. i3 lets you collapse a group of windows into one slot with a tab bar across the top: five terminals in the space of one, titles visible, arrow keys to cycle. AeroSpace approximates this by offsetting the windows slightly so a sliver of each peeks out, which tells you nothing about what's behind what. I built the real thing, with one tab per window, app icon and title, click to switch.

split that works. In i3 you press a key and the next window opens in a new split at that spot. AeroSpace has the command but refuses to run it under its own default settings, because the container gets cleaned up before anything can join it. Mine creates the container and holds it open, the way i3 does.

Floating windows you can still drive from the keyboard. i3 lets you float a window and keep nudging and resizing it with the same bindings. On AeroSpace, floating a window meant losing keyboard control of it entirely.

Dragging a window somewhere sensible. i3 has done this since 4.21: drag a tiled window and indicators show you what the layout will become, near the centre to move into a container, near an edge to become its sibling. AeroSpace's drag just swapped the window with whatever happened to be underneath. So I built the drop targets, and since I was in there anyway, went past what i3 offers: dropping onto a tab bar inserts at the caret between two tabs, you can tear a tab out into its own tile the way a browser does, and middle-dragging a tab bar picks up the whole group and moves it as one thing.

So the whole thing is really i3 parity plus a few macOS-shaped extras. Two things I didn't expect to spend time on:

Windows don't agree on their own corner radius. I wanted the focus ring to hug each window's corners. On macOS 26 a Safari window is rounded 26pt and a VS Code window 16pt, so any single value is wrong for something. There's an undocumented system call that reports the real number. I found it by reading JankyBorders' source, and credited it in my README. It's a private API, so it's loaded defensively: if Apple removes it, the app falls back to a configured value rather than failing to launch.

Theming from the wallpaper. The decorations sample your desktop picture and pick their colours from it. My first attempt filtered candidate colours by brightness, which quietly did nothing on a pale photo because there were no dark tones to find. Rewrote it to pick by hue and then shade each colour to fit its role.

There's a download if you want to try it, with two honest caveats. It isn't notarized, because I don't have an Apple developer certificate, so you have to clear the quarantine flag by hand before macOS will open it. And it uses the same bundle id as the original, so it replaces AeroSpace rather than installing alongside it.

The original is MIT. I put the fork under GPL-3.0, keeping the original's notice intact. Copyleft felt right for something this derivative, though it does mean my additions can't flow back upstream without me separately relicensing them.

Source: https://github.com/dmellok/aerospace-glass

Hey folks! I've been rewriting the firmware for my SCTV Scope Clock, which is an
X-Y oscilloscope-tube clock kit where the display MCU does nothing but steer the
electron beam and keep time. Anything that blocks its main loop shows up as
flicker on the tube, so networking really doesn't belong on it.

Happily, the kit already has a USB-A host jack on the back for plugging in a GPS
receiver to sync the time. I retired the GPS and plugged an AtomS3U (ESP32-S3)
into that same socket, where it enumerates as a plain CDC-ACM device. No
soldering, no case surgery, just a USB plug, and the S3 ended up doing a whole
lot more than the GPS ever could:

- NTP over Wi-Fi to discipline the clock's DS3232 RTC. The ESP32 owns timezone
and DST, so there are no tz tables on the display MCU at all.
- MQTT with Home Assistant discovery: face selection, brightness, diagnostics,
and the clock's knob and button show up as device triggers.
- Notifications drawn on the tube as text cards, straight from an HA notify
service.
- Vector scenes and face templates pushed over the link, so the host can define a
brand new clock face that keeps telling the time on its own after the bridge is
unplugged.
- A web config page for Wi-Fi, MQTT and timezone, plus OTA, so the bridge never
has to come back out of the clock.

The clock still runs completely fine standalone off its RTC if the Wi-Fi is down,
which was the main thing I wanted to preserve. Video attached.

Firmware is GPL-2.0-or-later, derivative of David Forbes' original SCTVcode:
https://github.com/dmellok/scope-clock

I made a set of Pokédex sleep screens for the Paperwhite. All 151 original Kanto Pokémon, one screen each.

They work nicely with KOReader's sleep screen, which can pick a random image from a folder:

>

Each one is a full dex entry, not just a picture: sprite, types, base stats, evolution chain with how it evolves, the Red/Blue move list, egg groups and breeding info, habitat, height and weight, and a type matchup panel showing what it's weak and resistant to.

The type matchups use the original Gen I rules rather than the modern ones, since the whole set is Kanto. Ghost does nothing to Psychic, the way it did on the Game Boy.

Sized 1236×1648 for the 6.8" Paperwhite. Free, and the repo also has versions for a couple of other e-ink readers.

Download: https://github.com/dmellok/eink-screens/releases/tag/pokedex-kindle-v1.0

Made with data from PokéAPI. Fan project, not affiliated with Nintendo.

Update: added 600×800, 758×1024 and 1264×1680, plus a colour version for the Kobo Libra Colour. Also fixed a bug where later-gen Pokémon were showing up in the evolution chains (thanks u/actuarial_defender). Everything's in one release now: https://github.com/dmellok/eink-screens/releases/tag/pokedex-v2.0

I made a star-chart sleep screen for every constellation and put them up for anyone who wants them. 88 plates, one per IAU constellation, sized for both panels.

Download: https://github.com/dmellok/xteink-screens/releases/tag/constellations-v1.0

• constellations-x4.zip — 480×800 (X4)
• constellations-x3.zip — 528×792 (X3)

Repo, if you'd rather browse them first: https://github.com/dmellok/xteink-screens

What's on each plate

A stereographic chart centred on the constellation, north up and east left the way charts normally run, with every star down to magnitude 6.5 sized by brightness, the stick figure, the IAU boundary, and any Messier objects with the usual symbols. Then a data block: area in square degrees and where that ranks among the 88, star count, the brightest star with its Bayer letter, magnitude, spectral class and distance.

Two things I put some thought into. The oval top-right is an all-sky Hammer projection with a crosshair on where you're looking — the solid line is the celestial equator, the dashed one is the ecliptic, so the zodiac constellations sit right on it. The globe bottom-right shades the band of Earth latitudes from which the whole figure clears the horizon at some point in the year, so you can tell at a glance whether it's visible from where you are. Crux is bottom-heavy, Lyra top-heavy, Orion is a fat belt with thin caps. Nothing on these is tied to my own latitude.

Format

4-bit indexed BMPs, palette exactly #000/#555/#AAA/#FFF, top-down rows. That's the native-palette path in CrossInk's Bitmap.cpp, so the firmware maps each index straight to a panel state — no re-quantising, no dithering on top of the dithering. Floyd–Steinberg against the nominal levels 0/85/170/255. Drop them on over USB, open one in Browse Files, set as sleep screen cover.

One caveat: the plates are about 95% pure black and white, with the greys only in the faint coordinate graticule and the boundary dashes. So if you're on a build where the 4bpp grey composite isn't running (the two middle bands come out black — crosspoint-reader#2879), these still read fine. The graticule just comes out heavier than intended.

Where the data comes from

Stars are the HYG database v4.1, Messier objects its deep-sky companion catalogue, stick figures and IAU boundaries from d3-celestial. The derived numbers — areas, culmination months, visibility limits — are computed from that geometry rather than copied off a table, and the spherical-polygon areas come out matching the published IAU values (Orion 594.1, Crux 68.5, Hydra 1302.5 deg²), which is how I convinced myself the projection wasn't lying to me.

Same repo also has the 151 Kanto Pokémon set from a while back, and some test cards for checking whether your unit's grey pipeline is working.

Happy to take requests if there's another closed set people want — periodic table and world flags are the obvious next ones.

Seeed reTerminal E1002 (7.3" Spectra 6) running my self-hosted dashboard project, Tesserae. The dashboard rotates through Pokédex entries and lays out the sprite, base stats and dex text in a Game Boy style, dithered down to the six-colour palette. The saturated red and yellow come out well on this panel.

The software is open source: https://tesserae.ink (code at https://github.com/dmellok/tesserae)

My Xteink X4 running a Pokédex card as its sleep screen, with a new random encounter each wake. Stats, sprite, and dex text come live from PokéAPI.

It's rendered by Tesserae, a self-hosted dashboard server for e-ink displays I've been building (AGPL). The X4 runs CrossInk with the Tesserae client enabled; the server renders at 480x800 and packs the exact 2-bpp buffer the firmware paints, so the grayscale sprite shading comes through and the radio only comes up on the sleep transition.

Just FYI, I didn't hand-write this screen. Tesserae has an MCP server, so I described the layout to my AI assistant and it built the widget against the API, sized for the X4's panel.

Tesserae Server: https://github.com/dmellok/tesserae

Crossink Fork: https://github.com/dmellok/CrossInk/tree/tesserae-client

My X4's sleep screen is now a dashboard.

It's a fork of CrossInk that pulls a frame from Tesserae (self-hosted dashboard server) and paints it as the sleep image. CrossInk is uxjulia's, and that's itself a fork of CrossPoint Reader. All I did was hang a network fetch off the sleep-screen plumbing they'd already built.

It doesn't wake on a timer. It's a reader, not a dashboard panel, and the battery is shared with actual reading, so a polling loop would kill it. The radio only comes up when you put the reader down. Refresh rate is however often you close it.

Server does all the rendering. Dithers to 4 grey levels and packs the panel's native buffer, so the firmware just unpacks two bit planes and pushes them at the screen. No decoding on device.

Still rough:

• fork only, not upstream
• X4 only. X3 and X4 Pro are untested
• battery impact over weeks of real use, no idea yet

What I really want is touch. Tesserae already handles it server-side, where the client just sends a raw stroke and the server does all the gesture work. But there's no digitiser in an X4.

Firmware: https://github.com/dmellok/CrossInk/tree/tesserae-client
Tesserae: https://github.com/dmellok/tesserae

I've been building a self-hosted hobby project called Tesserae that pushes dashboards to e-ink displays, and at some point I realised my house generates exactly the kind of data Aperture would want on a status board. So I made a theme.

Three screens so far:

• Facility Systems: lights and HVAC. 2 of 9 fixtures illuminated. The Emergency Intelligence Incinerator is not an approved light source.
• Test Subject Observation: the cats. Subject #001 is a Weighted Companion Cat (threatens no physical harm, nor in fact can talk). Subject #002 is an Aerial Faith Subject with an unsanctioned trajectory. The Litter-Robot reports in as the Material Emancipation Apparatus, complete with weigh-ins and drawer status.
• Atmospheric Conditions: weather. The weather is not part of any officially sanctioned test. Please do not attempt to solve it.

Cake dispenser has been out of order since 1998. Reward status: promised, ETA never.

Everything updates live from real data (Home Assistant and the Litter-Robot, which weighs the cats every time they visit). The software is open source if anyone wants to build their own facility signage: https://github.com/dmellok/tesserae

Hardware is a Seeed reTerminal E1003 (13.3", 1872×1404, grayscale). The panel refreshes on a schedule, and everything on it is live data:

- FELINE OPS: Litter-Robot 4 via the Home Assistant integration. Per-cat weight trends, daily visit counts, litter level, and waste drawer capacity. Ada and Tux are unaware they have KPIs now.

- Spotify: now playing with album art, falls back to my top artists/albums when nothing's on

- Weather: Open-Meteo, 24h temp/rain curve + 7-day outlook

- Calendar: today's schedule on a 24h timeline rail (dummy events for the post)

- GitHub: 22-week activity heatmap and totals

- HABITAT//SYS: lights, locks, presence, and the five saddest device batteries in the house

Built with Tesserae, a self-hosted dashboard server for e-ink panels I've been working on. You compose pages from live widgets and data sources, and it handles the rendering and pushing to devices. It plugs straight into Home Assistant.

Repo: https://github.com/dmellok/tesserae

Site: https://tesserae.ink

Happy to answer questions about the E1003 or how the litter box graphs work (the answer is: with complete seriousness).

Three PicPaks running Tesserae, my self-hosted e-ink dashboard server: now-playing, weather, and a litter-robot status board.

PicPak support is thanks to varanu5, who wrote the custom firmware (picpak-tesserae-client) and built the support for it in Tesserae! Huge thanks.

Self-hosted, open source (AGPL), no cloud. Repo: https://github.com/dmellok/tesserae
Website: tesserae.ink

I wanted one self-hosted dashboard that could drive lots of different e-paper hardware without a cloud service or a Pi per screen, so I've been building Tesserae. You compose a dashboard from tile-shaped widgets (weather, calendar, Home Assistant sensors, Spotify, image slideshow, GitHub stats, and a growing catalog), assign pages to panels, and the server renders each page headless in Chromium and pushes the frame to whatever panel is bound to it. No accounts, everything stays on the LAN.

The Seeed reTerminal E Series is the quickest way to try it, and it's supported end-to-end:

• Tesserae-native firmware for every SKU: E1001 (7.5" mono), E1002 (7.3" Spectra 6), E1003 (10.3" 16-level greyscale), E1004 (13.3" Spectra 6)
• A browser flasher at https://tesserae.ink/flash: plug in over USB-C, flash from your browser, pair with your server, and you're rendering
• Front-panel buttons mapped in firmware, plus battery and RSSI reporting
• Panel-specific rendering so each device gets exactly the byte format its controller expects (4-bpp Spectra 6 for the colour panels, 4-bpp IT8951 for the 10.3" greyscale, and so on), not a lowest-common-denominator pipeline

Widgets are drop-a-folder plugins with a community marketplace, so writing your own is a small server-side data-fetch plus a client-side render function. There's a Home Assistant app too. Everything (server, renderers, device firmware, widget marketplace) is open source under AGPL-3.0.

For transparency: Seeed supplied the E1001, E1002, and E1004 samples used for development. No money changed hands, and I bought the E1003 and other panels myself.

Happy to talk rendering pipeline, plugin system, firmware, or hardware you'd like to see supported.

• Repo: https://github.com/dmellok/tesserae
• Site: https://tesserae.ink

I wanted one self-hosted dashboard that could drive lots of different e-paper hardware without relying on a cloud service or requiring a Pi for each screen. So over the last few weeks I've been building Tesserae. You compose a dashboard from tile-shaped widgets (weather, calendar, Home Assistant sensors, Spotify, image slideshow, GitHub stats, and a growing catalog of more), assign pages to panels, and the server renders each page headless in Chromium and pushes the frame to whatever panel is bound to it. No accounts, everything stays on the LAN.

Hardware shown in the photo:

• Seeed reTerminal E Series: E1001 (7.5" mono), E1002 (7.3" Spectra 6), E1003 (10.3" 16-level greyscale), E1004 (13.3" Spectra 6)
• Seeed XIAO 7.5": TRMNL DIY OG Kit
• TRMNL X
• Pimoroni Inky Impression 13.3": driven by a Pi Pico Plus 2W
• Pimoroni Inky Impression 4": driven by a Pi 4
• Waveshare PhotoPainter: 7.3" Spectra 6 on ESP32-S3
• Jailbroken Kindle Paperwhite 2: via a KOReader plugin

The goal isn't just broad hardware support, it's making each device feel native. Panels all speak the same REST device API (MQTT is still there for existing setups), but every renderer produces exactly the byte format that panel's controller expects. 1-bit dithered for the Kindle, 4-bpp Spectra 6 for the colour panels, 4-bpp IT8951 for the greyscale 10.3", 2-bpp BWRY where relevant. Nothing gets forced through a lowest-common-denominator pipeline.

If you just want to try it, the Seeed reTerminal E Series is the quickest way to get a self-hosted e-paper dashboard up and running with Tesserae. The whole lineup is supported end-to-end: Tesserae-native firmware for every SKU, a browser flasher at https://tesserae.ink/flash, front-panel buttons mapped in firmware, battery and RSSI reporting, and the panel-specific rendering above. Plug it in over USB-C, flash it from your browser, pair it with your server, and you're rendering.

Widgets are just drop-a-folder plugins with a community marketplace, so writing your own is a matter of a small server-side data-fetch and a client-side render function. There's a Home Assistant app too if you're already living in Home Assistant. Everything (server, renderers, device firmware, widget marketplace) is open source under AGPL-3.0.

The community side is still small and it's honestly the part I'm most excited about. @varanu5 wrote firmware and Tesserae compatibility notes for the PicPak 4.2" BWRY frame, opening up a panel I don't own myself. @bablokb is building a generic CircuitPython client driver so any Pico, Feather, or similar CircuitPython board can talk to Tesserae, and has been massively helpful stress-testing the server side (gamut discovery, install fixes, and a steady stream of bug reports). @charmmmz caught a calendar timezone bug that had been quietly wrong for weeks. Small numbers, but every contribution has meaningfully widened what Tesserae supports, and I appreciate the hell out of it.

For transparency: Seeed Studio supplied the E1001, E1002, and E1004 sample hardware used for development. No money changed hands. (I bought the E1003 and other panels myself for development)

If you're running any of these panels, curious about the architecture, or have hardware you'd like to see supported, I'd love to chat. Questions about the rendering pipeline, plugin system, firmware, documentation, feature ideas, or anything else are all fair game.

Repo: https://github.com/dmellok/tesserae

Site: https://tesserae.ink

Please don't judge my music taste (too harshly)

The panel is a 13.3" color Inky Impression in a custom frame from Framefox, with a matte board cut to the active area. A Pi Zero 2 W tucks behind the back board, small enough that the whole thing stays mountable without sticking out. The Pi runs a small daemon that subscribes to MQTT and tells the panel to refresh whenever a new frame arrives.

The dashboard cycles through a few pages. The one in the photo has weather, what's playing on Spotify, a to-do list, a word clock, and a 5-day forecast. The others are a GitHub stats page, a full-bleed photo page, and a Home Assistant overview. The Spectra 6 palette is only seven colors, so I spent a while tuning the Floyd-Steinberg dither so dashboards look intentional rather than randomly halftoned. Once that was working, the results are striking up close.

The software side is something I've been building called Tesserae. It runs on a Pi 4 alongside Home Assistant, composes dashboards in a web UI renders them headlessly via Playwright and pushes the PNG over MQTT to the Pi Zero 2 W behind the panel. Plugin-architected, so adding a new widget is dropping a folder with three files. Open source if anyone wants to give it a go: https://github.com/dmellok/tesserae

Took a few weeks of evenings to get from "Pi on a desk wired up with loose wires" to "framed piece on the wall". Happy to answer any questions about the build.

A self-hosted dashboard server for color e-ink panels (Pi Inky Impression, Waveshare Spectra 6, PhotoPainter). You compose tile-based dashboards in a web UI. The host renders them headlessly via Playwright and pushes the resulting PNG or 4-bpp .bin frames to your devices over MQTT. Themes use a custom design system (Spectra). This system quantizes to the 7-color e-ink palette with Floyd-Steinberg dither. Dashboards look intentional rather than randomly halftoned.

The core uses a plugin setup. Widgets go in plugins/, renderers in renderers/, and devices in devices/. Each type is added by simply placing a folder that follows a set structure (manifest, server part, and optional client). This lets contributors add widgets, renderers, or device groups without changing the main system.

The bit I'm most pleased with is the community widget marketplace. The catalog index is a separate repo, with every release pinned by sha256. Widget tarballs go through audit-only review, not a free-for-all upload. Network egress is gated at the socket layer. Each widget's manifest declares which hosts it can reach (network:api.github.com, etc.). A socket hook on the host raises CapabilityDenied if it attempts to reach any other host. There are 30 bundled widgets plus 28 community-catalog entries today, including theme packs as a catalog kind. We just got our first widget submission from outside my account, a Belgian public-transport widget. This felt like a real proof point that the marketplace can attract contributors beyond me.

Built in Python/Flask with vanilla web components for cell rendering, MQTT push to multiple panels, Home Assistant App integration, Docker + bare-metal installers. 926 tests.

https://github.com/dmellok/tesserae

(Built with Claude Code in the loop for codegen and review. Architecture and direction are mine.)