19
Personal software blog series

2026-09-19 · 1193 words

Short post today. I have a little bit of free time as classes are still ramping up. I’ve done a lot of writing, and I’ve worked on a few of fun projects in the past couple of weeks, that I’d like to publish. If anything catches your attention let me know and I’ll prioritize it. The projects I’ve worked on include:

• Real-time physically-based rendering for skeumorphic UI. I’ve implemented a physical sky renderer, the principled material model (with emissive surfaces too), radiance cascades for GI, and jump-flooding for cheap directional shadows. UI frames are RGBD + materials, upon which lighting is cheaply calculated in screenspace. The renderer is implemented as a handful of WGSL shader passes, and runs at 120hz+ at 4k. Here’s an small example of a wax seal, with sky set to noon (each pixel is “wax material or paper material, +depth”):

• Desktop bridge, a CLI for macOS that exposes a small set of unix-like utilities for capturing screenshots, transcribing text on screen, inspecting accessibility trees, clicking objects and coordinates, scrolling, selecting, dragging, pressing keys, and typing.

• Homefront, a home server for collaborative personal software, with instances at home.isaac.sh and demo.isaac.sh. Source code is not up yet. If you’d like a test account, reach out.

I am currently working on a series of blog posts describing the homefront protocol from first principles. I plan to cover:

At a high level, homefront works as follows:

1. Everyone has a distributed identity, which is a public/secret keypair.

2. You can register an identity at a homeserver like home.isaac.sh, with a username like isaac, creating a handle like isaac~home.isaac.sh.

3. Registered identities can request to store and relay data through a homeserver, E2E encrypted, even at rest.

4. People can create groups of identities, with read and write access to different spaces. Spaces can be public or private by default, and spaces are E2E encrypted.

5. Using conflict-free replicated datatypes, spaces can be folded into coherent documents.

6. Anyone can host homefront-compatible apps on the web. Apps are signed static bundles of HTML, CSS, JS, WASM, static assets, etc. that can request resources from your homeserver.

7. When you encounter a compatible app, you can sign into it with your homeserver. When you add an app, you can specify how much storage, compute, etc. it may use, if any. You can also choose to mirror a pinned version of the app from your homeserver.

8. Because everything is distributed, and homeservers function as relays, you can easily share and collaborate in apps with people on different homeservers, and move your identity and data between homeservers.

The core protocol is pretty simple. Unlike the fediverse, homeservers function as relays with optional authority. Unlike the atmosphere, data is private by default and spaces support multiple writers out of the box. Unlike matrix/synapse, which is complex, a homeserver is a minimal relay for generic sync state. Unlike nostr, signing permissions are scoped, and homefront is transport agnostic.

You can register an identity on multiple homeservers, so it is trivial to move between them. The homefront protocol is designed in a way that homeservers and apps never need to see or store your public key, and applications have scoped access to resources.

I plan to outline the entire protocol from scratch in a series of blog posts that anyone with a little engineering experience could understand and use to implement a compatible homefront homeserver or homefront application client. I hope this is not too ambitious.

The protocol is agnostic to the application platform and transport layer. I have both web apps and cli apps; I have transport working over https, webtransport, and iroh.

A homeserver is deployed as a single static Rust binary with a single SQLite database and a single static config.toml file. I’ve also written a nix flake.

Coda

If you’re curious, here are some more PBR UI screenshots. (I apologize for the AI-generated layouts, they weren’t the interesting part of this project.) If you’re on your phone, I suggest you zoom in to see the textures in detail. It’s hard to communicate this, but because the UI is calculated in screenspace at the resolution of your display, it looks really clean in practice.

Above I’m testing derived screenspace normals (from depth) vs explicit analytic normals. You can see the reflection is a little smoother on the right.

Above I’m testing night rendering of the UI. You can see the moon and a lamp reflected in the sphere in the top-left. Note the emissive lamp coloring surrounding objects. This is an early development screenshot, I fixed the light leakage you can see with e.g. the pyramid and cone.

Above is a mock UI made of brushed metal. The text is literally just indented lighter-colored metal. All the lighting is computed on the fly. This is noon but it glows golden at sunset. (Note were I to deploy this as an actual UI I’d focus on text legibility and accessibility.)

Above is a ghostty-based terminal emulator, compiled to a wasm component, rendering to a curved emissive glass screen in the evening.

Coda II

Here are screenshots of a couple apps I’ve written against my homeserver. All apps are static bundles, and I’ve tested collaboration across my two homeserver deployments.

Above is my personal clone of Google Docs, which I use to draft blog posts. It supports real-time collaborative editing! Across accounts on multiple homeservers!! It’s so metal. Homefront is like email if email was real-time, always E2E encrypted, and a general protocol you could build any client app on top of.

Above is a website I made to track my readings for a philosophy class about ethics I’m taking this semester (24.130). Using homefront, my progress is synchronized live between my phone and my computer.

Above is a discord/slack clone I made for fun. You can chat live, upload media and files, react to messages, see who’s online, etc.

I also have a todo app, a personal microblog app, a notes app, and a multiplayer game. I’m working on a calendar app, a code forge, and a video meeting app. Digital sovereignty, man.

Well, that’s all for now. Wish me luck!