littleMesh addendum: readable handles and replaceable relays

Yesterday's post left one thing unsolved. Your littleMesh identity is your Ed25519 public key, which is great for security and terrible for a handle: nobody wants to type @alice@a1b2c3...52-characters....mesh.littlefedi.social, let alone read it out loud. And the lighthouse we mentioned, the relay that introduces you to the world, was baked into that identity too. Change relay, and you'd look like a different node.

We've been studying how to fix both, and we think we see a path.

The idea is a small signed directory sitting next to the mesh itself. You'd reserve a friendly alias, something like red-house.mesh.littlefedi.social, and your node would publish a signed record binding that alias to your node ID and to up to three lighthouses. Signed with the same mesh key you already have, no new identity, no new PKI. The record would carry a sequence number and an expiry, so nobody, not even the directory operator, could roll it back to an older version or serve a stale one past its time.

What we like about it is what it wouldn't change. Your handle would stay @alice@red-house.mesh.littlefedi.social, readable. Underneath, WebFinger would still resolve to your real actor ID, the one built from your node ID, exactly as today. And switching lighthouses, would just mean publishing an updated signed record. Same handle. Same actor ID. Nobody following you would notice anything happened.

The directory itself would stay deliberately weak in what it's trusted with. It couldn't produce a valid record for your node ID without your key, and every connection would still authenticate the node ID end to end, so even a malicious or compromised directory could deny service but never impersonate you.

We're building this over the next few days, opt-in, as an experiment. Once it's up, we want to see it survive a real follow exchange with stock Mastodon, snac and GoToSocial, and a lighthouse swap that doesn't touch the handle, before deciding whether it earns a permanent place in littleMesh or gets reworked. Worth trying, not yet worth trusting.

#littleFedi #littleMesh #Fediverse #OwnYourData

littleFedi introducing littleMesh

We've been buried in littleFedi work lately, and there's one piece I want to talk about because it's the one I'm genuinely excited about: littleMesh.

The problem is an old one. Federation assumes you have a domain, a public IP, an open port, a TLS certificate. Fine if you're renting a VPS somewhere. Not fine if your instance lives on a Raspberry Pi in your house, behind CGNAT, with an ISP that will never hand you a real IP address no matter how nicely you ask. Until now, that simply meant no federation for you. Full stop.

littleMesh gets rid of that requirement entirely, without asking you to build any of the infrastructure above.

On first run, your instance generates its own Ed25519 keypair. That key becomes your identity, no domain required, because your instance's address is derived straight from your public key, in the form .mesh.. Then your node opens an outbound connection to a "lighthouse", a small, publicly reachable relay, and registers itself there. Since the connection is outbound, it works from behind any NAT, any CGNAT, with zero port forwarding. The ISP never even notices.

When someone wants to reach you, they ask the lighthouse to open a circuit. The lighthouse introduces both sides, you call back, and it splices the connection together, but it only ever sees encrypted bytes, never your actual traffic.
Once the introduction is made, if you happen to have a reachable address after all, both sides skip the relay and talk directly. If not, the relay just keeps carrying you, quietly, in the background.

And if you already run an instance with a real domain, you can still turn on littleMesh, purely to reach mesh-only instances. Your own identity doesn't change at all.

There will be a default pair of community lighthouses, so you don't even need to find or run your own relay to get started, just say yes during littleFedi init and you're on the mesh.

The fediverse shouldn't require you to be reachable. It should reach you.

#littleFedi #littleMesh #Fediverse #OwnYourData

The Blog Option in littleFedi

littleFedi, like many social platforms, had both a strength and a limit. Posts, by their nature, are ephemeral. They get published, federated (unless local-only, which littleFedi handles) and then, over time, lost. Partly through self-deletion, partly through their normal blending in with the thousands of other posts that pile up over time. Sometimes, though, we want something to stay. And not just stay as a social post, but as an actual blog. A bit like with BSSG, I had thought it would be convenient to have a minimal system. Not to compete with WordPress or other solutions, but to have a small blog, integrated into littleFedi, that would produce and serve a blog updated every now and then, whenever the person writing felt like doing it.

And that's why the blog option was born.

The idea is simple: when you write a post, from the web UI or from the CLI, there's a checkbox, "blog post". If you check it, that post stops being just a status that will scroll past and disappear. littleFedi renders it into a real static site. No JavaScript, just HTML and CSS, an Atom feed, tag pages, a chronological archive. Nothing exotic, nothing that needs maintenance five years from now.

The blog isn't a parallel system you have to feed separately. It's not an export, not an import, not a bridge to some other CMS. The post you wrote is the blog post. Same database, same act of writing, still boostable, still repliable, still part of the conversation on the fediverse side. The blog is just a second representation of the same content, generated automatically. Every time you create, edit, or delete a blog post, the whole static site for your account gets rebuilt from scratch, and the new version replaces the old one atomically, so nobody ever lands on a half-built page. If the build fails, the previous version stays in place. Simple, but it has to work reliably, or the whole idea is pointless.

That's the core of it: two representations of the same post. As a status, it lives in the fediverse, interactive, part of the conversation, subject to replies and boosts like anything else. As a static page, it lives on the web, durable, indexable, with a permalink, something an RSS reader can hold onto. You don't have to decide in advance which posts deserve to last. You write normally, and if something turns out to be worth keeping, you flag it, and it gets its own page.

One detail I cared about while thinking this through: the generated site has to be self-contained. When littleFedi builds it, media gets copied or hard-linked into the generated directory - images, audio, video. If it's stored on S3, it keeps its public URL directly. Either way, the point is that the site on disk doesn't depend on the instance staying up. If the server goes down tomorrow, the blog files are still a complete, working website. That wasn't an afterthought, it was one of the requirements from the start.

Not every account gets a blog, and that's intentional. The instance admin has to enable the feature globally ([blog] enabled = true), and then grant it per account. It's not meant to be a CMS, and I didn't want it to become one. Blog posts can't be replies, can't be boosts, have to be public and top-level. These are constraints, not missing features: the blog is for your own writing, not for threads or reshared content.

There's no JavaScript anywhere in the generated site. That was deliberate too. It loads fast, it works offline if you cache it, and it will still render correctly in ten years without anyone having to update a dependency.

In the end, the blog option doesn't ask you to choose between writing socially and writing something permanent. You keep writing the way you always do, on littleFedi, and if a post is worth keeping, you check a box. No separate platform, no migration, no vendor lock-in. Just your own posts, some of them rendered into a small static site you can host anywhere, built out of something that already existed on the open web.

Remember: all this is being currently served by a Raspberry PI Zero W powered by NetBSD

Here's the result: https://rpi0w.stefanomarinelli.it/@stefano/blog/691cb62e-e7a1-434b-ba65-d059ee58ac41/

#littleFedi #SSG #BSSG #OwnYourData #Blogging #Fediverse #NetBSD

@packet@bsd.cafe it will be released and will compile (it already does) for all the GO supported architectures.

At the moment littleFedi is able to pre-build binaries for 43 platform variants (all CGO_ENABLED=0, statically linked). ARM targets include both armv6 and armv7 variants.

AIX

• littlefedi-aix-ppc64

Android

• littlefedi-android-arm64

Darwin (macOS)

• littlefedi-darwin-amd64
• littlefedi-darwin-arm64

DragonFly BSD

• littlefedi-dragonfly-amd64

FreeBSD

• littlefedi-freebsd-386
• littlefedi-freebsd-amd64
• littlefedi-armv6-freebsd-arm
• littlefedi-armv7-freebsd-arm
• littlefedi-freebsd-arm64

Illumos

• littlefedi-illumos-amd64

Linux

• littlefedi-linux-386
• littlefedi-linux-amd64
• littlefedi-armv6-linux-arm
• littlefedi-armv7-linux-arm
• littlefedi-linux-arm64
• littlefedi-linux-loong64
• littlefedi-linux-mips
• littlefedi-linux-mips64
• littlefedi-linux-mips64le
• littlefedi-linux-mipsle
• littlefedi-linux-ppc64
• littlefedi-linux-ppc64le
• littlefedi-linux-riscv64
• littlefedi-linux-s390x

NetBSD

• littlefedi-netbsd-386
• littlefedi-netbsd-amd64
• littlefedi-armv6-netbsd-arm
• littlefedi-armv7-netbsd-arm
• littlefedi-netbsd-arm64

OpenBSD

• littlefedi-openbsd-386
• littlefedi-openbsd-amd64
• littlefedi-armv7-openbsd-arm
• littlefedi-openbsd-arm64
• littlefedi-openbsd-ppc64
• littlefedi-openbsd-riscv64

Plan 9

• littlefedi-plan9-386
• littlefedi-plan9-amd64
• littlefedi-armv6-plan9-arm
• littlefedi-armv7-plan9-arm

Solaris

• littlefedi-solaris-amd64

Windows

• littlefedi-windows-386.exe
• littlefedi-windows-amd64.exe
• littlefedi-windows-arm64.exe

#littleFedi

Today I successfully tested a migration from my 'historic' Akkoma instance to littleFedi, without changing the domain name and without breaking the federation.

The procedure involves extracting the keys, so federated instances will accept this without any issues. In their eyes, there will be no particular differences, and they will gladly digest it without breaking the federation.
I have documented the procedure and kept the tool. I'm probably going to create something similar for Mastodon, though it will be a bit more complex.

#littleFedi #Akkoma #Fediverse

The littleFedi caching system is configurable and adaptable. Caching helps immensely, and for this very reason, you can choose to keep the cache "warm."

By default, if enabled (which makes a lot of sense on slow hardware), the system tracks user activity over the last n minutes (15 by default). For those minutes following the last interaction with the system, the cache will be kept warm.

Does a new post arrive in the timeline? It gets processed and cached, immediately (and partially) re-processing the timeline cache. The user will see it immediately in the timeline.

On a Raspberry Pi Zero W running NetBSD on an SD card, this means dropping the timeline generation time from about 5 seconds down to roughly 0.20 seconds.

After 15 minutes of inactivity from the user, the system will stop keeping the cache warm, reducing the CPU load to nearly zero (provided you aren't doing local processing of remote images, of course - which is also configurable). Upon the user's first visit, it will take a few extra seconds (cold cache), but from that moment on, everything will be almost instantaneous.

There's also a cache for the federation activities (a boost won't cause constant reprocessing of that post), but this isn't that different from other implementations' approach.

#littleFedi #Fediverse #OwnYourData