memorydial

The artwork came first. Lemmy Kilmister at a medieval loom, threading glowing data streams through wooden warp and weft, the Motorhead Snaggletooth materializing in the weave. I commissioned it before I'd written a line of code. Sometimes you name the thing before you build it, and the name tells you what it wants to be.

The name is a triple pun. Lemmy the software: a federated Reddit alternative. Lemmy the man: the Motorhead frontman who never compromised. And a loom: a machine that weaves raw threads into something you can use. I wanted to weave my own feed. On my own hardware. No algorithm deciding what I'd see.

I was spending too much time on Reddit. Not learning. Not connecting. Scrolling. The thumb moves, the feed refreshes, the dopamine drips. You close the app and can't name a single thing you read. This is the product working as designed. Reddit wants time on site. I wanted my time back.

The usual advice is discipline. Screen time limits. App blockers. Willpower. I've tried all of them. They treat the symptom. The problem is the feed itself: someone else decides what's in it, and their incentives aren't yours.

So I decided to build my own.

Lemmy is open source, federated, self-hostable. You can run your own instance, create your own communities, populate them however you want. My plan was simple. Spin up Lemmy on my Raspberry Pi. Write a Django bot that monitors RSS feeds, checks for new items, and auto-posts them to my communities. Lex Fridman drops a new episode, it appears in `/c/podcasts`. A blog I follow publishes, it lands in `/c/reading`. The feed fills itself. I scroll my own instance instead of Reddit, and everything in it is something I chose.

The bot was the easy part. Python, RSS parsing, the Lemmy API, a SQLite database to track what's been posted. Fifty lines of real logic. Django admin for managing feeds. The architecture fit on a napkin.

The infrastructure was the hard part.

I tried the Asustor NAS first. ARM-based, 824 megabytes of RAM per container. I got all six Lemmy containers running: nginx, lemmy-ui, the Lemmy backend, Postgres, pictrs for images, postfix for email. Docker reported them all healthy. Green lights across the board.

Then I opened a browser. Connection timed out.

The nginx container was listening on port 8536 internally. Docker mapped it to 10633. The lemmy-ui was configured to talk to `lemmy.ml` with HTTPS enabled. I was running on `localhost` with no certificate. Three layers of misconfiguration, each one invisible until you traced the whole chain.

I tried port 80. Already in use. I tried 8080. Connection timed out. I ran `docker logs` on every container. All healthy. All running. All unreachable.

The NAS was BusyBox-based. Half the diagnostic tools I needed didn't exist. `free -h` threw a syntax error. I was debugging container networking on a system where I couldn't check memory usage. I didn't know how to edit the nginx config because I didn't know where Docker had mounted it. I didn't know vi commands. I was learning infrastructure in production, on hardware that wasn't designed for it.

Then I tried the Raspberry Pi. Fresh start. Pi 4, 8 gigs of RAM, Debian underneath. Installed Docker, installed Tailscale, installed byobu. Got Docker Compose running. Downloaded the official Lemmy docker-compose from GitHub.

The config file URL returned 404. The repo had restructured since the docs were written. The lemmy.hjson I needed didn't exist at the path the documentation specified.

I rebuilt the configs from the official install guide, cross-referencing three different sources. Got the containers up. Got nginx configured. Got the ports mapped. And then it was midnight and I had work in the morning and the browser still wasn't loading the login page.

The RSS bot, by contrast, took an afternoon.

Monitor feeds on a schedule. Parse new items. Check the database for duplicates. Post to the Lemmy API. Track what's been posted. Django admin to add and remove feeds. The workflow was four steps: monitor, compare, post, track.

I had the posting mechanism working before I had a Lemmy instance to post to. The irony wasn't lost on me. The application logic was trivial. The platform it needed to run on was the entire problem.

The vision went beyond RSS. I wanted to run Fabric prompts against incoming content. Daniel Miessler's library of 200+ AI analysis patterns, applied to every article that landed in my feed. Extract the wisdom from a long essay. Summarize a paper. Analyze the claims in an opinion piece. The feed wouldn't just collect content. It would process it.

A personal Lemmy instance, populated by bots, analyzed by AI, running on a Pi under my desk. My own social network for an audience of one. No ads, no algorithm, no engagement metrics. Just the things I chose to follow, filtered through the lenses I chose to apply.

The gap between “I'll just self-host it” and a working system is where most projects like this die. Not because the idea is wrong. Because the infrastructure asks more of you than the application does. Docker networking, reverse proxies, port mapping, ARM compatibility, config file archaeology. None of this is the thing you set out to build. All of it stands between you and the thing working.

I learned more about nginx in three nights than in ten years of professional work. I learned that Docker containers can all report healthy while nothing is reachable. I learned that documentation rots faster than code. I learned that vi starts in normal mode and you press `i` to type.

The loom isn't finished. The threads are there: the bot works, the containers run, the vision is clear. What's missing is the last stretch of infrastructure that turns six healthy containers into a page that loads in a browser. It's close. It's been close for a while.

Lemmy would approve. He never did anything the easy way either.