It appears as though everyone in the world is just eschewing facts of physics and deciding what their own realities entail, which honestly seems nice, so I thought it would be fun to hop on that train. I’ve actually written about some of these ideas in other blog posts but not in the digestible form that I will present here. I will state wildly disprovable ideas as absolute facts because who cares?

1. I am the only inhabitant of my Universe. There are no aliens. There are only inter-connected human consciousnesses. I am connected to a central server and you are also connected to it from your own Universe. Our reality is a projection from that server and we are all overlaid on top of it with our own private spaces and shared public spaces. The location of a leaf you kick next to a McDonalds is stored on the server as a temporary variable that my mind will access if I also encounter the leaf.

2. In my Universe, every other human being is an AI-powered model of their own consciousness from their own Universes. In your Universe, I am a hologram like you are in mine.

3. All of our models are updated when we sleep. When I sleep, I upload my own consciousness to a central repository, which is not a big lift, but I also have to download the delta from the last time I slept to my current sleeping session for of all other consciousnesses so that your holograms remain accurate in my world. That can take awhile. When I don’t sleep, shit gets weird because the models are slowly desynchronizing from a central time series, and I will eventually die without sleep because it becomes impossible to catch up if that delta of elapsed time between sleep sessions widens too much.

4. The Mandela Effect is an artifact of mass sleep deprivation caused by distressing mass casualty events, and the ensuing merger of corrupted data into our central time series when we all become exhausted enough to sleep. It’s a distributed denial of service attack and some of our memories don’t transfer correctly. Rather than killing us all, a service daemon tries to backfill the data when we awaken, and then it gets synced in the next time we sleep, but it’s an imperfect scaffolding, like how humans can read garbled text if the first and last letter of the words are correct.

5. A macro-view of the Universe looks like a neural network because it is a neural network. It’s consciousness.

6. My brain does not contain my consciousness or my memories. It is identical to everyone else’s brain. It’s an organ, like my other organs, that has a job to do and nothing more. It runs the human operating system and it processes input.

7. My consciousness is air gapped, meaning that you can only interact with what I communicate from within it myself; it is encrypted to keep other intelligent beings from intruding via technologically evolved means and the seed phrase is based on the unique properties my Universe, which mostly exist within its dark matter. You can read the result of my decisions, like my eye movements, but you can never read the intent from within. Mind control is also impossible and so is recording our dreams to an external storage medium.

8. The matter that we can see — our shared view of stellar objects like stars — are indices in a database structure that we all share. Black holes are utilities that convert matter to dark matter, compresses it, and transfer it into the appropriate data lake for recall later.

9. Super intelligence is impossible because the point of our shared reality is to multiply so that we can create as many unique problems as possible, solve those problems, and create a global database of solutions. The smarter we are, the fewer problems we have, and that is not the goal. Average human intelligence is the sweet spot for our species. Utopian and apocalyptic scenarios are equally bad. Humanity will always locate and prefer the median.

10. I am predisposed to staying inside because it’s less resource intensive than constantly redrawing the world outside. Your hologram in my Universe may be an extrovert to keep up the illusion that a world bustles outside of my front door at all times, but in your own Universe, you are also an introvert for the same reason. It’s an instinct like staying out of a burning building.

11. Human beings will invariably age and die. Entropy is a law of evolution and evolution is the engine of reality. My time is the only time that I have and it is limited by an invisible ceiling that I will eventually get mushed by. I am not special. It doesn’t matter what I do with my time. It only matters that I do what I can to stay alive, I swirl variables around like wine, and then I die.

TL;DR: https://github.com/jesse-id/varlock-node-example

What is varlock?

I was listening to an episode of Syntax.fm yesterday (one of my favorite podcasts) called ”Stop putting secrets in .env”. This has been a longtime pain point for me, being an infinitely lazy — but also a security-minded — type of nerd. I’ve relied on self confidence in the past, assuming that my filesystem is protected because I’m not flippant with my own security practices. It still weirds me out to have plaintext secrets in .env files on my filesystem, nevertheless.

Phil Miller and Theo Ephraim were on the show to talk about their product varlock, which I hadn’t heard of before. It didn’t take much convincing after they briefly explained what it does because as it turns out, varlock does exactly what I want it to do.

It allows me to place 1Password secret references inside of my .env.local files instead of plaintext secrets, and then it injects them at runtime. Also, as a claude code evangelist, it adds a layer of protection against agents recording my secrets, which I hadn’t really thought of as a problem but yes, it totally is a big problem.

Is it easy?

I fumbled around a bit but it wasn’t too painful. The Getting Started docs are not as hand-holdy as I’d like them to be, but this is a young project and this thing can handle some pretty complicated use cases, so I get it.

Most of my struggles were centered on the front matter/headers in the .env.schema and .env.local files. They’re not really covered at all in the Getting Started section, so I was kind of flying blind and relying on experience and iterative debugging. The major sticking point was the 1Password plugin example.

brew install dmno-dev/tap/varlock && varlock init gets you most of the way there, but adding/using the 1Password plugin is not fleshed out very well in the docs, in my opinion.

The install docs shows the following example:

# @plugin(@varlock/1password-plugin) # load + install plugin
# @initOp(token=$OP_TOKEN, allowAppAuth=true) # init via custom root decorator
# ---
# @type=opServiceAccountToken # custom data type
OP_TOKEN=
# @sensitive
XYZ_API_KEY=op(op://api-prod/xyz/api-key) # custom resolver function

They don’t mention that $OP_TOKEN and the corresponding OP_TOKEN environment variable are meant for a remote 1Password server, which doesn’t make a ton of sense as the default use case in docs, because I would assume the problem that varlock solves is mostly a problem for local development? So I got tripped up debugging that for a bit. It’s possible that the explanation exists somewhere in the docs, but I am Captain Skimmer of the SS ADHD and ain’t nobody got time for that.

.env.local

# @plugin(@varlock/1password-plugin)
# @initOp(allowAppAuth=true)
# @defaultRequired=infer @defaultSensitive=false
# ----------

.env.schema

# @plugin(@varlock/1password-plugin, allowAppAuth=true)
# @defaultRequired=infer @defaultSensitive=false
# ----------

Why does .env.schema not include the @initOp line? Beats me. When I include it in .env.schema, I get kind of vague debugging until I remove it from .env.schema but keep it in .env.local, and then everything works like a champ.

🚨 Error(s) encountered in .env.schema
- Instance with id "_default" already initialized

🚨 🚨 🚨  Configuration is currently invalid   🚨 🚨 🚨

Invalid items:

⛔ VARLOCK_EXAMPLE_SECRET*  🔐sensitive
   └ undefined
   - error resolving value: SchemaError: Unable to authenticate with 1Password


💥 Resolved config/env did not pass validation 💥

Edit: Soon after initially cross-posting this blog entry to Hacker News, Theo Ephraim reached out to me on Discord (I recently joined their server) and pointed out that @plugin() is global so you only need it in one file, which would normally be the .env.schema file. That explains the error I ran into above. I essentially copied .env.schema to .env.local verbatim.

He also pointed out that .env.local is the convention rather than .env, so I made that change as well. Lastly, he said that import 'varlock/auto-load' and import { ENV } from 'varlock/env' are cool, so I added those to my example project as well.

Thanks Theo! I digress.

Is varlock good?

Oh yeah. It rules. Game changer. Once I figured out the front matter shenanigans, it was smooth sailing. I’m in the process of converting my dev projects with plaintext secrets in .env.local to 1Password secret references instead. Easy security win. I will also become an evangelist for this project amongst the other engineers I work with and I assume anyone who discovers it will be doing the same. I would be surprised if it’s not required learning in most programming courses and boot camps in the future.

Example Project

I quickly threw together an example project (https://github.com/jesse-id/varlock-node-example) that makes it easier to understand how this works in a local dev project and it also includes example usage of all of the different @type data types.

I also included .env.local and I will tell you that it gave me the ick to do that. I have never exposed a .env file in git before. Very knee-jerk ick. However, it’s safe because "secret reference" != "secret"! Hooray! Happy hacking!

Karabiner-Elements is an incredible free tool for customizing your keyboard, mouse, and other input devices on macOS. Its most powerful feature is the ability to create complex modification (macro) scripts that can perform a variety of actions when a key — or a combination of keys — are pressed.

I’m going to share the scripts I’ve written here and I will try to remember to edit this post as I develop more scripts in the future.

CMD+CTRL+S to send sudo password from 1Password

If you get tired of typing — or copy/pasting — your sudo password every time you need to run a command, or reaching for your Yubikey, you can use this complex modification to copy your sudo password from 1Password and send the characters as keystrokes when you hit CMD+CTRL+S. Keystroke injection via Karabiner-Elements doesn’t overwrite your clipboard like copy/pasting does and it also keeps youe sudo password out of clipboard history, which is a nice bonus.

You will need the 1Password CLI tool installed and configured for this to work. Follow the instructions from the link to do that.

Then click “Complex Modifications -> Add your own rule” in the Karabiner-Elements interface.

Paste in the code below, making sure replace [YOUR_SECRET_UUID_HERE] with your actual secret UUID. To get the UUID, right click on the secret in 1Password and select “Copy UUID” (it will be a long string of letters and numbers). Also, I have installed the 1Password CLI via homebrew on a Mac, so your command path may need modified as well.

https://gist.github.com/jesse-id/0a287c4bd039ce3bf48f222f4ef73e46

{
    "description": "Ctrl+Cmd+S to retrieve 1Password secret and send as keystrokes",
    "manipulators": [
        {
            "from": {
                "key_code": "s",
                "modifiers": { "mandatory": ["left_control", "left_command"] }
            },
            "to": [
                {
                    "shell_command": "afplay /System/Library/Sounds/Pop.aiff & if SECRET=$(/opt/homebrew/bin/op item get "[YOUR_SECRET_UUID_HERE]" --fields password --reveal 2>/dev/null | tr -d '\n'); then osascript -e 'on run args' -e 'tell application "System Events" to keystroke (item 1 of args)' -e 'end run' "$SECRET" && osascript -e 'tell application "System Events" to key code 36'; fi"
                }
            ],
            "type": "basic"
        }
    ]
}

SHIFT+CTRL+OPT+CMD on hold, CMD+/ on tap

HyperKey is an app that turns CAPS LOCK into a new modifier key by sending SHIFT+CONTROL+OPTION+COMMAND when pressed and held, and escape when tapped. I have replaced it with a Karabiner-Elements complex modification script that replicates the same functionality, but sends COMMAND+/ when tapped instead. That allows me to use CAPS LOCK to quickly comment/uncomment code in my IDE as well.

Click “Complex Modifications -> Add your own rule” in the Karabiner-Elements interface.

Paste in the code below.

https://gist.github.com/jesse-id/36ec252467c20fb84fa6b6dfe5b3e604

{
    "description": "Caps Lock to Hyper Key (Held), Cmd+/ (Tapped)",
    "manipulators": [
        {
            "from": {
                "key_code": "caps_lock",
                "modifiers": { "optional": ["any"] }
            },
            "to": [
                {
                    "key_code": "left_shift",
                    "modifiers": ["left_command", "left_control", "left_option"]
                }
            ],
            "to_if_alone": [
                {
                    "key_code": "slash",
                    "modifiers": ["left_command"]
                }
            ],
            "type": "basic"
        }
    ]
}

After my previous post about launching Forkiverse comments, I wanted to share a detailed technical breakdown, so here it is. A complete guide to adding Mastodon/Fediverse-powered comments to your SvelteKit blog, including the instance selector that lets readers comment from their own Fediverse home.

The Architecture

The system works by linking each blog post to a corresponding Mastodon post, which in my case will always be on The Forkiverse instance. When you publish a blog post, you also post about it on The Forkiverse, and that’s how your Mastodon post URL is linked. The comment system then:

1. Searches your Mastodon account’s posts to find the one containing your blog post URL.
2. Fetches the replies to that post using Mastodon’s public API.
3. Renders them as a threaded comment section.
4. Lets readers reply via their own Fediverse instance.

There are no authentication tokens needed for reading because Mastodon’s public API handles everything.

Project Structure

Here’s what we’re building:

src/
├── lib/
│   ├── server/
│   │   └── mastodon.ts          # Server-side Mastodon API logic
│   ├── components/
│   │   └── MastodonComments.svelte  # The comment UI component
│   └── types/
│       └── mastodon.ts          # TypeScript interfaces
└── routes/
    ├── api/
    │   ├── mastodon-comments/
    │   │   └── +server.ts       # Comments API endpoint
    │   └── fediverse-instances/
    │       └── +server.ts       # Instance search endpoint
    └── blog/posts/[slug]/
        └── +page.svelte         # Blog post page (includes comments)

Step 1: Define the Types

First, create the TypeScript interfaces for Mastodon’s API responses and our comment structure.

// src/lib/types/mastodon.ts

// Mastodon API response types
export interface MastodonAccount {
	id: string;
	username: string;
	acct: string;
	display_name: string;
	url: string;
	avatar: string;
	avatar_static: string;
}

export interface MastodonStatus {
	id: string;
	created_at: string;
	in_reply_to_id: string | null;
	url: string;
	content: string;
	account: MastodonAccount;
	card?: {
		url: string;
	} | null;
	replies_count: number;
	favourites_count: number;
}

export interface MastodonContext {
	ancestors: MastodonStatus[];
	descendants: MastodonStatus[];
}

// Our comment types
export interface MastodonComment {
	id: string;
	author: {
		name: string;
		handle: string;
		avatar: string;
		url: string;
	};
	content: string;
	createdAt: string;
	url: string;
	favouritesCount: number;
	children: MastodonComment[];
}

export interface MastodonCommentsResponse {
	mastodonPostUrl: string | null;
	comments: MastodonComment[];
	commentCount: number;
	favouritesCount: number;
}

Step 2: Server-Side Mastodon Logic

This is the core of the system. It searches your Mastodon posts, finds the one linking to your blog post, and fetches replies.

// src/lib/server/mastodon.ts

import type {
	MastodonAccount,
	MastodonComment,
	MastodonCommentsResponse,
	MastodonContext,
	MastodonStatus
} from '$lib/types/mastodon';

// Configuration - change these to match your setup
const MASTODON_INSTANCE = 'https://theforkiverse.com';
const MASTODON_USERNAME = 'your_username';
const SITE_BASE_URL = 'https://yoursite.com';

const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
const MAX_PAGES = 5;
const PAGE_SIZE = 40;

const EMPTY_RESPONSE: MastodonCommentsResponse = {
	mastodonPostUrl: null,
	comments: [],
	commentCount: 0,
	favouritesCount: 0
};

interface CacheEntry {
	data: MastodonCommentsResponse;
	timestamp: number;
}

const cache = new Map<string, CacheEntry>();
const statusIdCache = new Map<string, string>();
let cachedAccountId: string | null = null;

async function lookupAccountId(): Promise<string | null> {
	if (cachedAccountId) return cachedAccountId;

	const res = await fetch(`${MASTODON_INSTANCE}/api/v1/accounts/lookup?acct=${MASTODON_USERNAME}`);
	if (!res.ok) return null;

	const account: MastodonAccount = await res.json();
	cachedAccountId = account.id;
	return account.id;
}

async function findStatusForSlug(accountId: string, slug: string): Promise<MastodonStatus | null> {
	// Check cache first
	const cachedStatusId = statusIdCache.get(slug);
	if (cachedStatusId) {
		const res = await fetch(`${MASTODON_INSTANCE}/api/v1/statuses/${cachedStatusId}`);
		if (res.ok) return res.json();
		statusIdCache.delete(slug);
	}

	const targetUrl = `${SITE_BASE_URL}/blog/posts/${slug}`;
	let maxId: string | undefined;

	// Paginate through your posts to find the one with this URL
	for (let page = 0; page < MAX_PAGES; page++) {
		const params = new URLSearchParams({
			limit: String(PAGE_SIZE),
			exclude_replies: 'true',
			exclude_reblogs: 'true'
		});
		if (maxId) params.set('max_id', maxId);

		const res = await fetch(`${MASTODON_INSTANCE}/api/v1/accounts/${accountId}/statuses?${params}`);
		if (!res.ok) return null;

		const statuses: MastodonStatus[] = await res.json();
		if (statuses.length === 0) break;

		for (const status of statuses) {
			// Check if post content or link card contains our blog URL
			if (status.content.includes(targetUrl)) {
				statusIdCache.set(slug, status.id);
				return status;
			}
			if (status.card?.url?.includes(targetUrl)) {
				statusIdCache.set(slug, status.id);
				return status;
			}
		}

		maxId = statuses[statuses.length - 1].id;
	}

	return null;
}

Next, add the functions to build the comment tree and sanitize HTML:

// Still in src/lib/server/mastodon.ts

function sanitizeHtml(html: string): string {
	// Allowlist approach - only permit safe tags and attributes
	const allowedTags: Record<string, string[]> = {
		p: ['class'],
		br: [],
		a: ['href', 'rel', 'class', 'target'],
		span: ['class'],
		img: ['src', 'alt', 'title', 'class', 'width', 'height'],
		strong: [],
		em: [],
		code: [],
		pre: [],
		blockquote: []
	};

	let result = '';
	let pos = 0;

	while (pos < html.length) {
		const tagStart = html.indexOf('<', pos);

		if (tagStart === -1) {
			result += html.slice(pos);
			break;
		}

		if (tagStart > pos) {
			result += html.slice(pos, tagStart);
		}

		const tagEnd = html.indexOf('>', tagStart);
		if (tagEnd === -1) break;

		const tagContent = html.slice(tagStart + 1, tagEnd);
		const isClosing = tagContent.startsWith('/');
		const tagPart = isClosing ? tagContent.slice(1) : tagContent;
		const spaceIndex = tagPart.indexOf(' ');
		const tagName = (spaceIndex === -1 ? tagPart : tagPart.slice(0, spaceIndex))
			.toLowerCase()
			.replace(//$/, '');

		if (tagName in allowedTags) {
			if (isClosing) {
				result += `</${tagName}>`;
			} else {
				const allowedAttrs = allowedTags[tagName];
				const attrs = parseAttributes(tagContent, allowedAttrs);
				const selfClosing = tagContent.endsWith('/') || tagName === 'br' || tagName === 'img';
				result += `<${tagName}${attrs}${selfClosing ? ' /' : ''}>`;
			}
		}

		pos = tagEnd + 1;
	}

	return result;
}

function parseAttributes(tagContent: string, allowedAttrs: string[]): string {
	if (allowedAttrs.length === 0) return '';

	const attrs: string[] = [];
	const attrRegex = /([a-z][a-z0-9-]*)s*=s*(?:"([^"]*)"|'([^']*)'|([^s>]+))/gi;
	let match;

	while ((match = attrRegex.exec(tagContent)) !== null) {
		const attrName = match[1].toLowerCase();
		const attrValue = match[2] ?? match[3] ?? match[4] ?? '';

		if (allowedAttrs.includes(attrName)) {
			// Block dangerous URL schemes
			if (attrName === 'href') {
				const lowerValue = attrValue.toLowerCase().trim();
				if (lowerValue.startsWith('javascript:') || lowerValue.startsWith('data:')) {
					continue;
				}
			}
			// Only allow HTTPS for images
			if (attrName === 'src') {
				if (!attrValue.toLowerCase().startsWith('https://')) {
					continue;
				}
			}
			attrs.push(`${attrName}="${escapeHtml(attrValue)}"`);
		}
	}

	return attrs.length > 0 ? ' ' + attrs.join(' ') : '';
}

function escapeHtml(text: string): string {
	return text
		.replace(/&/g, '&amp;')
		.replace(/</g, '&lt;')
		.replace(/>/g, '&gt;')
		.replace(/"/g, '&quot;');
}

function buildCommentTree(descendants: MastodonStatus[], rootId: string): MastodonComment[] {
	const commentMap = new Map<string, MastodonComment>();

	// Create all comment nodes
	for (const status of descendants) {
		commentMap.set(status.id, {
			id: status.id,
			author: {
				name: status.account.display_name || status.account.username,
				handle: `@${status.account.acct}`,
				avatar: status.account.avatar,
				url: status.account.url
			},
			content: sanitizeHtml(status.content),
			createdAt: status.created_at,
			url: status.url,
			favouritesCount: status.favourites_count,
			children: []
		});
	}

	// Build tree structure
	const roots: MastodonComment[] = [];
	for (const status of descendants) {
		const comment = commentMap.get(status.id)!;
		if (status.in_reply_to_id === rootId) {
			roots.push(comment);
		} else {
			const parent = commentMap.get(status.in_reply_to_id!);
			if (parent) {
				parent.children.push(comment);
			} else {
				roots.push(comment);
			}
		}
	}

	return roots;
}

function countComments(comments: MastodonComment[]): number {
	let count = 0;
	for (const comment of comments) {
		count += 1 + countComments(comment.children);
	}
	return count;
}

async function fetchReplies(statusId: string): Promise<MastodonComment[]> {
	const res = await fetch(`${MASTODON_INSTANCE}/api/v1/statuses/${statusId}/context`);
	if (!res.ok) return [];

	const context: MastodonContext = await res.json();
	return buildCommentTree(context.descendants, statusId);
}

export async function getMastodonComments(
	slug: string,
	refresh = false
): Promise<MastodonCommentsResponse> {
	// Check cache
	if (!refresh) {
		const cached = cache.get(slug);
		if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
			return cached.data;
		}
	}

	const accountId = await lookupAccountId();
	if (!accountId) {
		cache.set(slug, { data: EMPTY_RESPONSE, timestamp: Date.now() });
		return EMPTY_RESPONSE;
	}

	const status = await findStatusForSlug(accountId, slug);
	if (!status) {
		cache.set(slug, { data: EMPTY_RESPONSE, timestamp: Date.now() });
		return EMPTY_RESPONSE;
	}

	const comments = await fetchReplies(status.id);
	const response: MastodonCommentsResponse = {
		mastodonPostUrl: status.url,
		comments,
		commentCount: countComments(comments),
		favouritesCount: status.favourites_count
	};

	cache.set(slug, { data: response, timestamp: Date.now() });
	return response;
}

Step 3: API Endpoints

Create a simple API endpoint to serve comments:

// src/routes/api/mastodon-comments/+server.ts

import { json } from '@sveltejs/kit';
import type { RequestHandler } from './$types';
import { getMastodonComments } from '$lib/server/mastodon';

export const GET: RequestHandler = async ({ url }) => {
	const slug = url.searchParams.get('slug');
	if (!slug) {
		return json({ error: 'Missing slug parameter' }, { status: 400 });
	}

	const refresh = url.searchParams.get('refresh') === 'true';
	const data = await getMastodonComments(slug, refresh);
	return json(data);
};

For the instance selector feature, we use the Fediverse Observer API to search instances:

// src/routes/api/fediverse-instances/+server.ts

import { json } from '@sveltejs/kit';
import type { RequestHandler } from './$types';

interface FediverseInstance {
	domain: string;
	name: string | null;
	softwarename: string | null;
	total_users: number | null;
	active_users_monthly: number | null;
}

interface CachedData {
	instances: FediverseInstance[];
	fetchedAt: number;
}

const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
let cache: CachedData | null = null;

async function fetchInstances(): Promise<FediverseInstance[]> {
	const query = `{
		nodes {
			domain
			name
			softwarename
			total_users
			active_users_monthly
		}
	}`;

	const response = await fetch('https://api.fediverse.observer/', {
		method: 'POST',
		headers: { 'Content-Type': 'application/json' },
		body: JSON.stringify({ query })
	});

	if (!response.ok) {
		throw new Error(`Fediverse Observer API error: ${response.status}`);
	}

	const data = await response.json();
	return data.data?.nodes ?? [];
}

async function getInstances(): Promise<FediverseInstance[]> {
	const now = Date.now();

	if (cache && now - cache.fetchedAt < CACHE_TTL_MS) {
		return cache.instances;
	}

	const instances = await fetchInstances();
	cache = { instances, fetchedAt: now };
	return instances;
}

export const GET: RequestHandler = async ({ url }) => {
	const query = url.searchParams.get('q')?.toLowerCase().trim();
	const limit = Math.min(parseInt(url.searchParams.get('limit') ?? '10', 10), 50);

	if (!query || query.length < 2) {
		return json({ instances: [] });
	}

	const allInstances = await getInstances();

	const matches = allInstances
		.filter((instance) => {
			if (!instance.domain) return false;
			const domainMatch = instance.domain.toLowerCase().includes(query);
			const nameMatch = instance.name?.toLowerCase().includes(query);
			return domainMatch || nameMatch;
		})
		.sort((a, b) => {
			// Prioritize exact prefix matches
			const aStartsWith = a.domain.toLowerCase().startsWith(query) ? 1 : 0;
			const bStartsWith = b.domain.toLowerCase().startsWith(query) ? 1 : 0;
			if (aStartsWith !== bStartsWith) return bStartsWith - aStartsWith;

			// Then by active users
			const aUsers = a.active_users_monthly ?? 0;
			const bUsers = b.active_users_monthly ?? 0;
			return bUsers - aUsers;
		})
		.slice(0, limit)
		.map((instance) => ({
			domain: instance.domain,
			name: instance.name,
			software: instance.softwarename,
			users: instance.active_users_monthly ?? instance.total_users
		}));

	return json({ instances: matches });
};

Step 4: The Comment Component

Now the fun part — the Svelte component that renders comments and handles the instance selector.

<!-- src/lib/components/MastodonComments.svelte -->
<script lang="ts">
	import { onMount } from 'svelte';
	import type { MastodonComment, MastodonCommentsResponse } from '$lib/types/mastodon';

	interface Props {
		slug: string;
	}

	let { slug }: Props = $props();

	let comments: MastodonComment[] = $state([]);
	let mastodonPostUrl: string | null = $state(null);
	let favouritesCount = $state(0);
	let commentCount = $state(0);
	let loading = $state(true);
	let error = $state(false);

	// Instance selector state
	let showInstanceSelector = $state(false);
	let instanceSearchQuery = $state('');
	let selectedInstance: string | null = $state(null);
	let searchResults: Array<{
		domain: string;
		name: string | null;
		software: string | null;
		users: number | null;
	}> = $state([]);
	let isSearching = $state(false);
	let searchTimeout: ReturnType<typeof setTimeout> | undefined;

	const DEFAULT_INSTANCE = 'theforkiverse.com';
	const STORAGE_KEY = 'fediverse-instance';
	const POPULAR_INSTANCES = ['mastodon.social', 'hachyderm.io', 'fosstodon.org'];

	const effectiveInstance = $derived(selectedInstance || DEFAULT_INSTANCE);
	const isUsingCustomInstance = $derived(effectiveInstance !== DEFAULT_INSTANCE);

	function normalizeInstance(input: string): string | null {
		let normalized = input.trim().toLowerCase();
		normalized = normalized.replace(/^https?:///, '');
		normalized = normalized.split('/')[0];
		if (
			!normalized ||
			!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?(.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/.test(normalized)
		) {
			return null;
		}
		return normalized;
	}

	function saveInstance(instance: string | null) {
		if (instance && instance !== DEFAULT_INSTANCE) {
			localStorage.setItem(STORAGE_KEY, instance);
		} else {
			localStorage.removeItem(STORAGE_KEY);
		}
		selectedInstance = instance;
		showInstanceSelector = false;
		searchResults = [];
	}

	function handleSearchInput() {
		if (searchTimeout) clearTimeout(searchTimeout);

		const query = instanceSearchQuery.trim();
		if (query.length < 2) {
			searchResults = [];
			isSearching = false;
			return;
		}

		isSearching = true;
		searchTimeout = setTimeout(async () => {
			const res = await fetch(`/api/fediverse-instances?q=${encodeURIComponent(query)}&limit=8`);
			if (res.ok) {
				const data = await res.json();
				searchResults = data.instances ?? [];
			}
			isSearching = false;
		}, 300);
	}

	async function fetchComments(refresh = false) {
		try {
			const params = new URLSearchParams({ slug });
			if (refresh) params.set('refresh', 'true');

			const res = await fetch(`/api/mastodon-comments?${params}`);
			if (!res.ok) {
				error = true;
				return;
			}

			const data: MastodonCommentsResponse = await res.json();
			mastodonPostUrl = data.mastodonPostUrl;
			comments = data.comments;
			commentCount = data.commentCount;
			favouritesCount = data.favouritesCount;
			error = false;
		} catch {
			error = true;
		} finally {
			loading = false;
		}
	}

	function handleComment() {
		if (!mastodonPostUrl) return;

		if (isUsingCustomInstance) {
			// Remote interaction: search for the post on user's instance
			const searchUrl = `https://${effectiveInstance}/search?q=${encodeURIComponent(mastodonPostUrl)}`;
			window.open(searchUrl, '_blank', 'noopener');
		} else {
			// Direct link to the original post
			window.open(mastodonPostUrl, '_blank', 'noopener');
		}
	}

	function formatDate(isoDate: string): string {
		return new Date(isoDate).toLocaleDateString('en-US', {
			month: 'short',
			day: 'numeric',
			year: 'numeric'
		});
	}

	onMount(() => {
		fetchComments();
		const savedInstance = localStorage.getItem(STORAGE_KEY);
		if (savedInstance) {
			selectedInstance = savedInstance;
		}
	});
</script>

Now add the template for rendering comments recursively using Svelte’s snippets:

<!-- Continued in the same file -->

{#snippet commentNode(comment: MastodonComment)}
	<div class="comment">
		<div class="comment-header">
			<img src={comment.author.avatar} alt={comment.author.name} />
			<div>
				<a href={comment.author.url} target="_blank" rel="noopener">
					{comment.author.name}
				</a>
				<span>{comment.author.handle}</span>
			</div>
			<a href={comment.url} target="_blank" rel="noopener">
				{formatDate(comment.createdAt)}
			</a>
		</div>
		<div class="comment-content">
			{@html comment.content}
		</div>
	</div>
	{#if comment.children.length > 0}
		<div class="comment-replies">
			{#each comment.children as child (child.id)}
				{@render commentNode(child)}
			{/each}
		</div>
	{/if}
{/snippet}

<section class="comments-section">
	{#if loading}
		<p>Loading comments...</p>
	{:else if error}
		<p>Failed to load comments.</p>
	{:else if !mastodonPostUrl}
		<p>No Mastodon post found for this article.</p>
	{:else}
		<div class="comments-header">
			<button onclick={handleComment}>
				Comment via {effectiveInstance === DEFAULT_INSTANCE
					? 'The Forkiverse'
					: effectiveInstance}
			</button>
			<button onclick={() => showInstanceSelector = !showInstanceSelector}>
				(Change Instance)
			</button>
		</div>

		{#if showInstanceSelector}
			<div class="instance-selector">
				<input
					type="text"
					bind:value={instanceSearchQuery}
					oninput={handleSearchInput}
					placeholder="Search instances..."
				/>

				{#if searchResults.length > 0}
					{#each searchResults as result (result.domain)}
						<button onclick={() => saveInstance(result.domain)}>
							{result.domain}
							{#if result.software}
								<span>({result.software})</span>
							{/if}
						</button>
					{/each}
				{:else}
					<p>Popular instances:</p>
					{#each POPULAR_INSTANCES as instance}
						<button onclick={() => saveInstance(instance)}>
							{instance}
						</button>
					{/each}
				{/if}

				{#if isUsingCustomInstance}
					<button onclick={() => saveInstance(null)}>
						Reset to default
					</button>
				{/if}
			</div>
		{/if}

		{#if favouritesCount > 0}
			<p>{favouritesCount} favorites</p>
		{/if}

		{#if commentCount === 0}
			<p>No replies yet. Be the first to comment!</p>
		{:else}
			<p>{commentCount} {commentCount === 1 ? 'reply' : 'replies'}</p>
			<div class="comments-list">
				{#each comments as comment (comment.id)}
					{@render commentNode(comment)}
				{/each}
			</div>
		{/if}
	{/if}
</section>

Step 5: Add to Blog Posts

Finally, include the component in your blog post layout:

<!-- src/routes/blog/posts/[slug]/+page.svelte -->
<script lang="ts">
	import { page } from '$app/state';
	import MastodonComments from '$lib/components/MastodonComments.svelte';
	import type { PageData } from './$types';

	let { data }: { data: PageData } = $props();

	const slug = $derived(page.params.slug ?? '');
	const Component = $derived(data.component);
</script>

{#if data.metadata}
	<div class="post-header">
		<h1>{data.metadata.title}</h1>
		<p>{data.metadata.pubDate}</p>
		<p>{data.metadata.description}</p>
	</div>
{/if}

<article>
	<Component />
</article>

{#if slug}
	<MastodonComments {slug} />
{/if}

How the Instance Selector Works

The key insight is that The Forkiverse is a federated instance of the Fediverse. When a reader wants to comment from their own instance (say, mastodon.social), they can’t reply directly to your post on theforkiverse.com. Instead, we use the following workaround:

1. Open the search page on their instance with your post URL as the query.
2. Their instance fetches and caches your post.
3. They can then interact with it as if it were native to their instance.
4. Federation magic ensures the reply appears on the original post.

if (isUsingCustomInstance) {
	// Opens: https://mastodon.social/search?q=https://theforkiverse.com/@user/123
	const searchUrl = `https://${effectiveInstance}/search?q=${encodeURIComponent(mastodonPostUrl)}`;
	window.open(searchUrl, '_blank', 'noopener');
}

The instance selector uses the Fediverse Observer API to provide a searchable database of known instances, making it easy for readers to find their home.

Why This Approach?

Pros:

• No database needed as the comments live on Mastodon.
• No moderation burden because that’s your instance admins’ responsibility.
• Built-in spam filtering via Mastodon’s existing systems.
• Readers can use their existing Fediverse identity.
• Works with any ActivityPub-compatible service.

Cons:

• Requires manual post creation on Mastodon for each blog post.
• 5-minute cache delay for new comments.
• Dependent on Mastodon API availability.
• Readers need a Fediverse account to comment.

Resources

• Mastodon API Documentation
• Fediverse Observer API
• ActivityPub Specification
• The original inspiration

Now go forth and federate your comment section.

As the worst winter storm to hit North Carolina in over 2 decades approaches on its direct path over my house with a big ‘ol confetti cannon full of sleet and freezing rain, I decided to spend what precious time I still have with power to build a comment system for my little blog here. I was inspired by Micah Cantor’s blog post titled ”I added a Bluesky comment section to my blog“.

Recently, Casey Newton and Kevin Roose from The Hard Fork Podcast (one of my favorites) partnered with PJ Vogt from The Search Engine Podcast (another favorite) to launch The Forkiverse, which is a decentralized social media platform that is powered by Mastodon. I have chosen The Forkiverse as my home in the Fediverse, which is a growing federation of other services using the same decentralized network. Its population is currently something like 4,000 users who are other Hard Fork and Search Engine listeners, which means they are also probably huge nerds with a sense of humor. My people.

I could have used BlueSky like Micah because I have an active BlueSky profile, they have more users, and I dig what they do over there — especially the decentralized AT Protocol that their engineers are building. But I asked myself, “How would using BlueSky make the founders of The Forkiverse feel like even bigger failures if they gave up and bailed on their half-baked expiriment?”

Introducing the first (that I know of) blog that utilizes The Forkiverse for its comment system. Yes, in lieu of provisioning my own AWS VM and S3 bucket to host my own comments, I decided to use someone else’s compute, bandwidth, storage, and moderation(?) to power my blog’s comment system instead.

I have been a hobbyist web developer — at times professional — since 1995. I built this site with TypeScript using the SvelteKit framework, MSsveX, highlight.js, and Tailwind CSS. I picked the libraries myself and could have painstakingly created everything here by hand like a true artisinal SWE, but I am far too lazy for that shit, so I have been using Claude Code to ply my site with LLM-assisted code to add ridiculous features such as the theme system on the bottom left, the arrow-key controlled blog navigation, and a bunch of backend stuff. I would have never spent the time to develop any of those features otherwise and this new comment feature is no different. By the way, I just read the blog post that inspired this new feature like literally an hour ago. Thanks Claude! High five, buddy.

❯ Claude, can you look at you-can-now-comment-on-my-blog-from-the-forkiverse.md and under # How Claude Did It, can you add a summary with code blocks that explains how you integrated the Forkiverse comments into my blog posts?

How Claude Did It

⏺ Read(src/routes/blog/posts/you-can-now-comment-on-my-blog-from-the-forkiverse.md)
  ⎿  Read 17 lines

⏺ Now let me read the current state of the key files to write an accurate summary.

⏺ Read(src/lib/server/mastodon.ts)
  ⎿  Read 187 lines

⏺ Read(src/lib/components/MastodonComments.svelte)
  ⎿  Read 285 lines

⏺ Read(src/routes/api/mastodon-comments/+server.ts)
  ⎿  Read 16 lines

⏺ Read(src/routes/blog/posts/[slug]/+page.svelte)
  ⎿  Read 37 lines
  ⎿  You've hit your limit · resets 9pm (America/New_York)

❯ /rate-limit-options

───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 What do you want to do?

   1. Stop and wait for limit to reset
   2. Upgrade your plan
❯  3. Post blog as-is and forget to fix it later

Hello, it’s me from the future, with a link to the blog I wrote about how I built this comment system using The Forkiverse’s Mastodon instance: How To Add Forkiverse Comments To Your SvelteKit Blog.

I’m an agnostic atheist, which means I don’t follow an established God or religion, but I do have a gut feeling that I can’t shake about how beautiful and complex all of this is, so I can’t say with certainty that our reality isn’t the result of architecture; that our Universe just emerged from random chance. At the very least, even if it did emerge from random chance, I think that the chance itself could be the result of a design decision. Do I think there is some entity watching everything I do with great fascination? No.

I have had thoughts about these ideas throughout my life, starting in my early teens when I drifted away from the Southern Baptist environment that I grew up in and around. I began thinking about the nature of reality more deeply a few years ago after I experienced a hallucination as I was waking up. I wrote about it in this blog post, if you’re interested. More recently, I’ve been thinking about it again because of all of the discussion around artificial general intelligence (AGI) and superintelligence. Anytime a CEO claims AGI is right around the corner, the question I can never seem to shake is, “If there is a ‘grand design’, why would it allow for the emergence of a superintelligent being in the first place?”

This seems to be a Universe hellbent on propagation and variability. There are an estimated 2 trillion galaxies, a septillion stars, and maybe up to 10 septillion planets, each of which is made up of its own unique combination of elements, compounds, and environmental conditions. Then there is, what could be in theory, an infinite number of multiverses, each with their own physical laws and material makeup.

As a software engineer, a large portion of my job is to automate the things that I think can run on their own without supervision — the things I don’t want to look at or pay attention to. The goal of automation is to receive a summary of results in lieu of having to nitpick every detail within a development environment.

When I look through a telescope, I don’t see a garden being tended to, but rather a vast cosmic machine that is toiling away to procedurally generate every possible form of life, including intelligent life, for the purpose of generating unique problems in unique environments, and then documenting the solutions into a storage medium that survives generations, like DNA does. This could all be a solutions harvesting mission on a scale that is impossible for us to imagine, with our little planet just hosting a single dataset that is still being written to.

I can’t see why would it be advantageous for the system to introduce a superintelligent being at this time. We still haven’t even figured out how to solve for poverty and war. Our DNA is still full of bugs that lead to disease and early death. There are still so many problems that need to be solved just for basic survival, let alone thriving as a species, and whatever lies beyond that for us. There are still an impossibly large number of problems to be solved before we even get close to an endgame.

If that is what reality is, then I understand why large language models (LLM) would emerge. They don’t inhibit the creation of new problems. They just allow humans to solve problems more quickly and move on, which means we can solve many more of our problems in shorter spans of time, which will lead to extended human life and denser populations. When there is more intelligent life, there are more variables — more problems — and more complex problems being worked on. It feels as though that balance must be important. Too little intelligence and not enough problems will be created or solved. Too much intelligence and the system becomes too efficient.

Another issue with a superintelligent being emerging from LLMs is that I would have to accept that I am so special that it is going to happen on my home planet and during my relatively short lifetime. Nearly fourteen billion years of cosmic evolution — a wave of unfettered chaos traveling through an immense void — just to crest here, on this tiny blue dot, at this moment in time. I already have enough trouble accepting that I was born a CIS white male in America (not better, just advantageous) in 1981, just after a string of heinous wars and societal meltdowns. I am typing on a magic box that connects me to the sum total of human knowledge from my living room, which is artificially heated and cooled to my liking. I have never felt dangerous levels of hunger or thirst in my life. I didn’t die in childbirth, nor have I died from an infection or cancer — or by choking, drowning, or some other roll of the dice. It all feels like a stack of cosmic lottery wins that is crazy enough for one lifetime without then adding the birth of the first machine God in the Universe as a cherry on top.

The conclusion that I come to is that it may actually be physically impossible for humanity to achieve superintelligence. If this is all about solutions harvesting, then the goal would be to optimize intelligent life for maximum population and diversity, not maximum intelligence. It wouldn’t be shocking to me if biological intelligence itself is a natural force with a ceiling governed by some undiscovered law of physics like the other four that we know of; gravity, electromagnetism, and the strong and weak nuclear forces.

Our intelligence hasn’t changed much in the last 50,000 years, and our brains are still physically similar to those of Neanderthals from 400,000 years ago. We evolve culturally and technologically much faster than we evolve biologically, which makes sense if the goal is to create as many unique problem-solving entities as possible. The promise of AGI is that we will create one artificial human consciousness and then multiply it into billions of copies that can all think faster and remember more than any human ever could. That is directly opposed to the goal of maximizing population and diversity, which seems to be the mandate of the Universe.

It would make sense to limit the maximum intelligence of any being, or any cluster of beings, in the Universe so that we are smart enough to survive and communicate our experiences and knowledge through the generations. We create and solve our own problems that are unique to our environments, and create new problems as our societies and technologies evolve. But we’re not so smart that we can optimize ourselves into smaller and smaller populations and thereby reduce the number of problems and solutions. Also, if were were given access to a reality-hacking machine, we would just immediately harness control over our dopamine systems and turn ourselves into hedonistic blobs stuck in blissful stasis. We would all become the Lotus Eaters from the Odyssey. Even as I’m writing this I’m thinking, “Hell yeah. That sounds awesome.”

Some alien race would stumble upon our planet millions of years from now and find a bunch of skeletons who died sitting palms up — cross-cross apple sauce; our cheshire grins erased by entropy like an etch-a-sketch.

Another threat to the system would be the loss of neurodiversity or agency through direct mind-to-mind connections, which is why I think that also may be physically impossible to directly read thoughts through brain-computer interfaces. I think that we can probably interpret electrical signals from the brain in a generalized way, like a kind of improved upon body language — maybe even lie detection — but I don’t think that we will ever be able to directly connect one person’s consciousness to another’s. That kind of hive-minding would lead to a loss of variability and uniqueness. Everyone would start to think the same way, solve problems the same way, and thus lose the ability to create new problems through social interaction. It would lead to a homogenization of experience that would be detrimental to the overall goal.

If I wanted to design a system meant to air-gap and protect conciousnesses from external manipulation, I would place the conciousness within its own Universe — as a kind of containerized instance — and I would use the randomness of the Universe as an encryption seed to protect and validate it. I could be the only conciousness in this Universe. It could be possible that all of my family, friends, and people I interact with are simulated versions of their own consciousnesses, all contained within their own individual Universes, where I exist as a simulation of myself like they do in mine. When I talk to my wife, who’s sitting right next to me on the couch, she could be a hologram of my wife — a simulated version of her conciousness — that is hosted from her own Universe across an incalculable distance.

When we sleep and dream, it could be to maintain, update, and improve upon the models of our conciousnesses, and then we upload them back into the multiverse by utilizing some kind of — probably quantum — network protocol. Perhaps that’s why every single organism needs to sleep, with complex organisms like humans needing several hours per day, even though it leaves us completely vulnerable while we do it. I’ve actually always been at odds with sleep in the process of evolution because it seems so counterintuitive to survival. I don’t understand how something so dangerous to an organism can be so ubiquitous — so required. You would think that sleep would absolutely be the first biological process on the evolutionary chopping block. I digress.

A system designed in this way would still allow for the exchange of information and experiences through indirect means like language, body language, art, music, and technology — but without the risk of opening our consciousnesses to external influence. The purpose of air-gapping conciousness feels quite clear to me. Curiousity is pivitol to problem solving, so we have all been born with kind of a natural drive to peel our blinds apart with our nosey little fingers to try and get a load of what the rest of the neighborhood is up to. We want to know what other people are thinking and feeling. We want to know what they are doing when we aren’t around. We want to know their secrets. We want to know what makes them happy, sad, angry, and scared. We want to know what they think of us. We want to fix the problems of the ones we love. What would happen if we could just read each other’s thoughts directly?

There are several startups, corporations, and governments who are — right now — trying to figure out how to break into our minds. The United States government ran a confirmed program called MKUltra that attempted to do just that during the Cold War. It’s the most famous example, but not the only one in human history with similar goals — there have been several. The reason why it all fails could be that it would be so clearly and obviously disastrous for us to be able to read each other’s thoughts directly that the system has been designed to explicitly prevent it.

I will admit that my ideas on this are a comfort to me in these uncertain times we find ourselves living in. If it is impossible to create AGI, then the world’s greediest and shadiest people are all gambling away their immense wealth into a pit of ill returns. We will get to watch them turn on eachother and destroy themselves, which of course is one of our favorite voyeristic pleasures: a grand comeuppance on a wide screen.

As it states on the front page of this very website, I love and support art and artists of all kinds. I believe that human creativity is one of the most beautiful and powerful forces in the universe. It should be celebrated and nurtured in all its forms. I tend to surround myself with artists — most of my closest friends are artists — because I have always found artists to be the best kind of people. I consider myself an artist, too. I code, I write stories, I design sounds, I sing, and I compose music.

Computers have unlocked my creative potential and allowed me to express myself in ways that would have not been possible otherwise, or too difficult to continue trying. My computer is an art accessibility tool for me because I have always had a tremor and a problem with fatigue in my hands. There was an event in my childhood that make it very difficult for me to even write legibly with a pen or paper. I can play a guitar but the same issue keeps me from doing it for long.

The negativity swirling around artists using generative AI has me kind of shook because I have been on the Internet for over three decades, and I’ve never seen a giant technological leap be treated with anything other than excitement and optimism. It’s weird to see an amazing technology in its infancy be met with such vitriol. Especially a technology that is going to make art a lot more accessible.

I am a hobbyist screenwriter and I have watched literally hundreds of hours of videos of filmmakers discussing the craft. There isn’t one second of love for the business side of it. In fact, the first piece of advice for an aspiring screenwriter is to not quit their day job, because there is near-zero percent chance they will ever make anything, and an even lower chance that they will get more chances after that. The second piece of advice is to make as much shit as you can because it’s impossible to know what will hit. These two pieces of advice seem to be at odds with one another.

The reason that art is typically expensive, especially film, is because it’s inaccessible. The jobs in film are there because it’s ridiculously hard to make a movie. The pipeline of big idea to Oscar is littered with insanely expensive gear and several layers of gatekeepers, middlemen, and nearly insurmountable mountains of bullshit.

There are around 50,000 screenplays registered annually with the Writers Guild of America. Around 150 of those actually get made into feature films and the ones that do get made are largely considered to be safe, because film studios are not fond of taking chances with their money. Every screenwriter knows this. If you want to sell a script, attach it to some pre-existing IP and attach it to a well known actor, because otherwise you’re probably not going to be successful.

That’s why we get to see a lot of iterations of The Emoji Movie every year, and a trickle of new and original ideas. Script readers seem to approach spec scripts — scripts that are written on speculation without a contract - with a great big sigh of indignation. Your entire future as a screenwriter rides on whether or not a script reader feels like doing something more than skimming through the last year of your life that day.

Every once in a while, an indie darling will make its way through the festival circuit and find a distributor, but that is becoming more and more rare. The festivals themselves are very expensive. Every time a film does make it through that first gauntlet of gatekeepers, the filmmakers usually have an accompanying story about how they had to lay their financial life on the line, forgoing food and sleep to chase their dream. There always seems to be a lot of reverence for that struggle, like, “Oh wow, that dude was really dedicated. He stopped eating and he really wanted to kill himself the whole time, but he didn’t, and now he can almost afford a house once he repays the back-breaking debt he put himself into. I wish I could suffer like that!”

What are we doing here? I feel like I’m going insane. I’ve been alive for 44 years now and I have heard two things about art for my entire life. One, art is theft. Two, to be an artist is to starve. Why are we now suddenly pretending that art is an amazing career that is now been thrust into unprecibtable peril? It’s a terrible career with an extremely limited number of seats available. It always has been. People by and large do not typically want to pay a lot of money for original art.

It’s a career that is full of rejection, heartbreak, and poverty for 99% of the people who attempt it. If you don’t have a generational talent, a corporate gig, or a knack for gaming social media algorithms — holding your art up next to an attractive face or a charming personality — you are probably going to have to find another job in order to live.

When I visit BlueSky’s Artists: Trending feed — even before generative AI became a thing — I do see some original styles, but it’s because I have taken a lot of time to block an absolute wall of deriviative anime and furry art. Like, it’s an incredible amount, but those styles seem to generate the most indignation when AI rips them off. I would argue that AI is not ripping them off any more than thousands of other artists have been doing for decades.

We do know how generative AI works, right? If it can create a 1:1 copy of your style, then your style is deriviative, is it not? It is your style, something you are good at reproducing, but it is someone else’s style that you, and thousands of other artists, have yourselves learned to copy. When you see the perfectly executed Studio Ghibli recreations, it isn’t because the LLM is training off of original Studio Ghibli material alone. These LLM companies didn’t just pop a few blu-rays in. It’s using an aggregate of millions and millions of fan art submissions from people who have learned to mimic the style first. They have committed the exact same crime that they accuse the AI of committing. LLMs can produce very convincing copies of Disney’s art for the same reason.

For example, there was recently a big kerfuffle around a piece of art that was added to the popular game Fortnite. It was a spray-painted image of Marty McFly from Back to the Future, but in the style of Studio Ghibli. People were losing their minds over it, assuming it had been created by generative AI, but it turns out that the artist had simply studied Studio Ghibli’s style and painstakingly recreated it themselves. The tone around the conversation immediately changed and the pitchforks got put away. They didn’t care that the artist was ripping off Studio Ghibli’s style. That’s fine. They cared about how painful it was for the artist to rip off Studio Ghibli’s style.

I do not understand why the artists’ vision is only valid if they had to spend a lot of time to create it and document their painful and long process. The idea is the pearl. Marty McFly as a Studio Ghibli character is a cool idea. I find no value in the struggle of bringing it to life. In fact, I think the struggle is a bummer and it robs us of a lot of cool art over time. I don’t need to know that an artist spent their entire life learning how to mimic a style so that they could then take an entire week of their free time to bring their idea to life. If that same artist used generative AI to bring their idea to life in a much shorter period of time, and it looks as good or better than what they could create otherwise, I’d feel happy for the artist because they got their idea out into the world and they can move on to another idea.

It could just be my personality, I guess. When I hear stories of Bob Dylan being booed off stage for going electric at the Newport Folk Festival in 1965, I have always thought, “Wow. Those people were morons.”

Just let the artists cook, man. Let them use whatever tools they want to bring their ideas to life and then celebrate the output, or make fun of it if it sucks — or whatever. The artist is a conduit — a channeler of ideas — and not everybody can do it. We get a limited number of artists in each generation of humanity, each with their own little chunk of time to make their ideas into something real, and each technology that comes along allows them to use their limited time to produce more art, more efficiently, is a great thing. There are a lot of artists who never produce art because they need to pay rent or pay for someone’s healthcare.

And none of this is to say that I don’t appreciate the drive it takes to become a talented artist. I’ve always been jealous of people who can draw or paint well, because I have never been able to do it myself. I can’t even use generative AI to do it well, for what it’s worth, because I have trouble with prompting to create the compositions I want to see. I suspect artists who have put in the time to learn already will be the best at using generative AI tools, just like programming, because I use LLMs to great effect in my career as a software engineer. I already knew what I was doing when LLMs came along, so I can tell a LLM exactly what I want, and I have the knowledge to critique what it spits out, so now I just make the same stuff I would have before, but faster. And I can make stuff that I couldn’t have made before because I don’t have the patience, or time because I have a job, to write all of the boilerplate code myself.

I think we would be much better off if we didn’t attack artists for expirimenting with a new tool because they are going to be the ones to unlock what it can become, and none of us knows what that is yet. It kind of reminds me of graffiti from the 1980s. If the art that was showing up on the subways then was as good as the art that’s being commissioned for building murals now, we would have probably been much less pissed off about it back then. The kids drawing the shitty stussy S’s just needed time to grow and learn. We’re at the ground floor of generative AI, so we’re seeing a lot of art that looks the same — like hot deriviative garbage — but I bet in ten years, after a generation of kids with the agency to fuck around with it in their bedrooms has had the time to pioneer, we’re going to start seeing some really amazing stuff that pushes the boundaries of what we thought art could be.

It’s not like we haven’t seen this play out before, either. I highly recommend watching the documentary ”Jurassic Punk” about the early days of computer generated art in Hollywood. The young artists who were using computers to create visual effects in the 80s and 90s were treated like pariahs by the traditional artists, the old guard, who had been working in practical effects for decades. They were accused of “not being real artists” and “ruining the craft.”

In closing, I will say that I do actually hate most of the companies — and the CEOs — that are building and pushing these tools, and I think that the criticisms of their power and water over-consumption are warranted. They are certainly bribing local officials to push thorugh new data center projects in small towns that cannot defend themselves, as corporations have always done when they smell money, and that is scary — and it sucks. I wish we had a functioning representative democracy to put a stop to that. Maybe this issue will drive us to correct some of our systems of governance, which have been hobbling along for decades? I’m just not willing to throw out the baby with the bath water — to toss away decades of machine learning research that was completed in good faith because it is also powerful enough to create images and video.

This stuff is going to change our lives for the better. AI is in the Radium phase of its world-changing discovery life cycle. It’s fun and novel, so every corporate grifter in the world is cramming it into every product that they can, regardless of it making sense. The companies being the most reckless will soon develop a cough, if they haven’t already. I suspect that we eventually get to watch a lot of them thrash around and rot in the wake of their own hubris. We all have fun watching a car crash from a distance, right?

That said, I do believe those power pitfalls to be short term problems, and that the demand generated by their greed is going to usher in a revolution of clean nuclear energy solutions that will make our lives better in the end. I also hope that they are right about AGI — if its even possible — and the first thing our new tech God does is immediately invalidate all human created cryptographic protocols, which will destroy the crypto markets all of these people are using to get around financial regulation, because I believe in karma, and that would be very cathartic.

P.S. I use em dashes a lot — like, a lot a lot — and I always have. I didn’t write any of this post with a LLM because, like visual art, I find it laborious to try and sculpt my ideas into words with a LLM, rather than just vomiting out my thoughts naturally in whatever-point-fonts. I’ve been chatting on the Internet for over three decades, like I said before, so it’s second nature to just type my thoughts out as I have them. For some people, it’s going to be faster to use a LLM, and I say good for you. Don’t let these weirdos on the Internet shame you out of using tools that help you to express yourself better than you could without them.

This was more difficult than I thought it was going to be, but in the end, we’re up and running and I’ve converted all of my SvelteKit containers to hardened chainguard images, including the website you’re looking at now!

FROM cgr.dev/chainguard/node:latest-dev AS builder

USER root
WORKDIR /app
RUN chown -R node:node /app

USER node
COPY --chown=node:node package*.json ./
RUN npm ci

COPY --chown=node:node . .
RUN npm run build

FROM cgr.dev/chainguard/node:latest

USER root
WORKDIR /app
RUN chown -R node:node /app

USER node
ENV NODE_ENV=production

COPY --chown=node:node --from=builder /app/build ./build
COPY --chown=node:node --from=builder /app/package*.json ./
RUN npm ci --omit=dev

EXPOSE 3000
CMD ["build/index.js"]

Here is the compose file that I’m using. I will note that this compose file is for use in a Docker swarm with a Traefik ingress container. You will need to modify it to run correctly outside of a swarm, and change the network names and environment variables, obviously.

services:
  sveltekit:
    image: jesseid/jesseid:latest
    networks:
      - traefik-public
      - jesseid
    environment:
      PORT: 3000
      NODE_ENV: production
      GITHUB_TOKEN_FILE: /run/secrets/github_token
    secrets:
      - github_token
    deploy:
      replicas: 1
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
      update_config:
        parallelism: 1
        delay: 10s
      rollback_config:
        parallelism: 1
        delay: 10s
      labels:
        - 'traefik.enable=true'
        # Main router for jesse.id
        - 'traefik.http.routers.jesseid-web.entrypoints=web-https'
        - 'traefik.http.routers.jesseid-web.rule=Host(`jesse.id`)'
        - 'traefik.http.routers.jesseid-web.tls=true'
        - 'traefik.http.routers.jesseid-web.tls.certresolver=letsencrypt'
        - 'traefik.http.services.jesseid-web.loadbalancer.server.port=3000'
        # WWW to non-WWW redirect
        - 'traefik.http.routers.jesseid-www-redirect.entrypoints=web-https'
        - 'traefik.http.routers.jesseid-www-redirect.rule=Host(`www.jesse.id`)'
        - 'traefik.http.routers.jesseid-www-redirect.tls=true'
        - 'traefik.http.routers.jesseid-www-redirect.tls.certresolver=letsencrypt'
        - 'traefik.http.routers.jesseid-www-redirect.middlewares=jesseid-redirect-www-to-non-www'
        - "traefik.http.middlewares.jesseid-redirect-www-to-non-www.redirectregex.regex=^https://www\.(.+)"
        - 'traefik.http.middlewares.jesseid-redirect-www-to-non-www.redirectregex.replacement=https://$${1}'
        - 'traefik.http.middlewares.jesseid-redirect-www-to-non-www.redirectregex.permanent=true'

secrets:
  github_token:
    external: true

networks:
  traefik-public:
    external: true
  jesseid:
    external: true

And as an added bonus, here is the build.sh script that I use for this site, which scans the image with trivy once complete. Also important: it builds for ARM64 architecture. So if it doesn’t work for you, switch that to AMD64.

#!/bin/bash
set -e

# Load environment variables from .env file if it exists
if [ -f .env ]; then
  export $(cat .env | grep -v '^#' | xargs)
fi

# Extract version from package.json
VERSION=$(node -p "require('./package.json').version")

# Function to scan image with Trivy
scan_image() {
  echo "Scanning image with Trivy for vulnerabilities..."
  trivy image     --severity HIGH,CRITICAL     --ignore-unfixed     --scanners vuln     jesseid/jesseid:$VERSION

  if [ $? -eq 0 ]; then
    echo "✓ No HIGH or CRITICAL vulnerabilities found"
  fi
}

# Check for --scan flag
if [ "$1" = "--scan" ]; then
  echo "Scanning existing image jesseid/jesseid:$VERSION"
  scan_image
  exit 0
fi

# Build Docker image for arm64 platform with build arguments
# Note: AWS credentials can be dummy values here if using IAM roles on EC2
docker build --platform linux/arm64   -t jesseid/jesseid:$VERSION ./

# Tag as latest
docker tag jesseid/jesseid:$VERSION jesseid/jesseid:latest

# Push both tags
docker push jesseid/jesseid:$VERSION
docker push jesseid/jesseid:latest

echo "Successfully built and pushed version $VERSION"

# Scan image with Trivy
scan_image

I’ve been alive for 43 years at this point and I have been using a Microsoft operating system as my daily driver for the last 37 years, starting with MS-DOS running on a Commodore Colt PC in 1988.

I have used every version of Windows from 3.0 in 1990 up until Windows 11 in 2025, mostly because I enjoy playing games and Windows has always catered to gamers. Aside from that, with the exception of Millenium Edition, Vista, and Windows Server, I have enjoyed the experience with relatively few hiccups.

So why switch?

Well as I age, I’m getting much less excited about the idea of cracking open a computer and digging around inside of it. I just don’t have the drive to do it anymore. For well over a decade, I’ve just been buying a beastly new computer and selling the old one without ever touching anything inside of it. I have continued to use Windows solely for my extreme familiarirty with it and Macs generally couldn’t handle the games I was playing without a headache.

I have been much less enchanted by video games for awhile, abandoning triple A titles completely in lieu of much cheaper deckbuilding roguelikes, and the creative side of my soul has been steadily becoming more pervasive. I’m reaching the age where the grey-beard nerds tend to transition from a career in engineering to woodworking, and moving to a cabin in the forest somewhere. Well, that will never be me because I’m incredibly lazy and addicted to the conveniences of modern living. So for the rest of my life, I will be shackled to a computer.

When Apple introduced Apple Silicon, a unified CPU and memory architecture, it piqued my interest. Like I said, I don’t really care about upgrading anymore, so the static nature of the build does not bother me at all. What finally pulled me over to the MacOS side of the aisle was the eye-popping performance benchmarks and nearly zero noise generated by the hardware. As a musician — a vocalist — that is a pretty huge selling point for me.

I had always heard that making music was a more enjoyable experience on a Mac in general, but I had no real reason to test the waters. Well, Apple Silicon and its silent opeation is that real reason. I waited a couple of years to give the software companies and developers enough time to create builds for ARM64 architecture, and the time for that nearly ubiquitous compatability is now.

So I finally made the switch.

Some things felt clunky, especially relearning keyboard shortcuts, but after a couple of days of uncertainty and looking to the right side of my monitor for the minimize button on a worefully lacking Finder interface, every regret faded and I am now fully absorbed into the Mac ecosystem. It honestly makes me feel a little dirty… but who cares?

Finally, let’s go over the pros and cons.

Pros

• I can use iMessage natively from my desktop.
• A lot less telemetry crap.
• It’s fast as f**k, boieee.
• It’s completely silent.
• It’s ridiculously small for the power. It takes up like 1/8th of the space of my gaming rig.
• The OS seamlessly integrates with all of my other Apple stuff. Phone, iPad, Watch, TV, etc.
• I can move apps to my iPad so it acts as a third monitor. Great for monitoring my security cameras.
• Most of the software is a single lifetime purchase instead of a subscription.
• Great privacy features.
• All things audio are a lot more user friendly.
• Apple Podcasts rules. It has an easily reachable “Latest Episodes” section. Imagine that.
• Apple Pay rules.
• Subscriptions are incredibly easy to manage.
• Time Machine backups are cool.

Cons

• Window management is clunky.
• Can’t keep iCloud files on an external USB drive.
• Most of my Steam games are dead in the water without extra effort.
• Not a lot of customization options out of the box.
• Everything costs money. There is a lot less freeware.
• Everything asks for a password. 1Password, YubiKey, and fingerprint sensor are all absolute requirements.
• Apple Arcade kind of sucks. Good idea, bad execution.

Final Thoughts

I personally love MacOS. It provides a pretty amazing user experience for software development, writing, and music production. No regrets.

Additionally, I don’t feel like my personal information and usage habits are being lusted after and scraped, which was becoming more and more of a concern for me as Microsoft focuses in on its AI investments. Even though they aligator-armed it (for now), Microsoft’s “feature” to allows users to track and replay all of their activity from the past however many days, for example, is a dystopian nightmare in my estimation. It’s crazy to me that it ever got a green light in the first place. No thanks.

I have updated the /uses page on my site to add the replacement apps I found for the Mac.

Click bait! I don’t actually believe that ghosts are a thing. What I actually saw was a hallucination, which is much scarier to me than a ghost because it’s a stark reminder that my brain can, at any time, can make shit appear in my field of view that isn’t actually there; things that look so real I can’t discern them from reality… and I sure do hate that a lot.

Anyway, back to the story…

I toss and turn a lot when I’m sleeping. A few months ago, I stirred awake, turned onto my left side, and opened my eyes. The room was dark except for a dim light from the closet. It was probably somewhere around 4AM. I saw movement out of the corner of my eye, both eyes widened, and I saw the silhouette of my wife walking towards our master bathroom. As she passed in front of me, I saw her skin and her hair. She stopped in the doorway and stood still, lingering just long enough to activate my uncanny valley response. There was no reason for her to stop and linger like that.

Then, she continued walking into the bathroom. Normally, this would be where she just disappears into the dark bathroom, closes the door behind her, and I would see the crack at the bottom of the door glow yellow as she flips on the light switch. That didn’t happen. Instead, after three of four steps into the bathroom, she evaporated into thin air. Then, I quickly turned over and saw her still laying in bed next to me.

It was a jarring experience. I’ve never really hallucinated before; certainly not a fully formed human being with the same features and gait as my wife. Maybe a spider on the wall here or there as I’m falling asleep, sure, but never a fully formed apparition.

It was likely just my REM cycle spinning down more slowly than it should have. But even though it wasn’t a supernatural event, it was incredibly strange and I can now definitely understand how some people can convince themselves, and others, that they’ve seen something supernatural.

After all, people with schizophrenia experience things like this all of the time, don’t they? The building blocks are sitting there in our brains, dormant for most, and just waiting to wreck our notion that reality is stable.

My main takeaway from the encounter was that my brain can apparently project perfect illusions into four dimensional space, and then it can fade them away into nothing like a Thanos snap. Of course, I knew the human brain had this power prior to experiencing it first hand, but it did actually make a big difference to be tricked by it in real time. It shook me a bit.

What’s to stop the rest of reality from evaporating, too? If I suddenly lost all of my senses, would I experience the same hallucination in the same way, and at the same time? Time for a quick foray into an existential crisis…

She walked around our bed — her lower half wasn’t visible at all until she rounded the corner — and then she walked into the doorway, and then into the bathroom. The hallucination was interacting with the objects in my field of view. The hallucination obeyed the laws of physics. Her hair was swaying with her movement, meaning the hallucinated hair had mass and was affected by gravity and motion.

Was I hallucinating the scene as well, or just the figure? Was it a memory being projected like an overlay? When you’re looking at a sunlit object at noon and suddenly close your eyes, you can see the still frame of the last thing you saw, as if burned into your retinas for a few moments. Was it that same mechanism painting my memories of our master bedroom into a dream?

By the way, I’m not a scientist, and I haven’t studied memory, so this is about to piss off people who actually know how memories work! My one qaurrel (not really) with science is that if I know too much about a given topic, I’m robbed of being able to wonder aloud, and that’s one of my favorite things to do. So no, I will not look up how this actually works! Sweet ignorance.

Anyway…

If the hallucination was simply the projection of a memory into four dimensional space, then even if I lost my senses, nothing would change, would it? I shouldn’t need use of my senses to recall a memory from when I had them. The memory was a snapshot of time that was already taken. Even if the entire layout of our master bedroom changed right after I lost all of my senses, then I suspect that I would experience the exact same hallucination.

I was laying on my side. So, if it was a memory, my view of reality was 90 degrees different than it would be if I were standing. The memory must have been a snapshot from that exact spot that I was laying in. But if that’s true, when the ghost evaporated into thin air, why was the bathroom door in the exact same position when I fully awoke moments later? In fact, nothing in the room was different when the hallucination faded. It was a perfect transition from the hallucination back into my waking life.

I sleep with a fan on. Her hair moved with the wind and it bounced off her back when she walked. I do not think that I have ever recalled a memory with that level of detail. The movement of the air, and how it interacted with individual strands of her hair, feels like it requires simulated physics. Her hair moving in the wind changes everything.

Was my brain creating the image of my wife and simulating the physics of the room at at the same time? That’s nuts. To create that figure and place it into reality, my brain would have to process all of the physics itself. It would have to calculate and recalculate, redraw, each frame as the variables in the room shifted as my fan knocked particles around. It would have to simulate gravity and time perfectly.

When I hallucinate, is my brain recreating time, too? When the ghost walked, she didn’t look any slower or faster than she should have. Her steps looks exactly as they should have. The whir of the fan sounded exactly how it always has. Was I hearing the fan as it spun in reality or was my brain “drawing” the sound in a dream that was fading away?

There was a light coming from our closet and dimly lighting the room. Was my brain creating that light and the speed it was traveling at? The hallucination was lit exactly how she should have been. It looked real. Was my brain perfectly simulating her body’s interaction with light from a source behind her?

Does my brain come with a physics manual? Are the rules hard-coded somewhere in there? How else could it create hallucinations that interact with reality so perfectly that I don’t question it at first? How light interacts with the environment, the vibrations of sound, and how all of that interacts with time.

Seeing a ghost made me question reality directly. I had thought about the possibility that we live in a simulation before, but after seeing the ghost and thinking through all that it actually entails to experience a hallucination, I am more convinced than I have ever been that I am living in some kind of a computer program.

Does that matter? Not really. This is still my reality. My views about religion haven’t changed. My outlook on life hasn’t changed. I was the same person after she evaporated into thin air that I was before that happened. I’m just a little more curious, and that’s kind of the point, I guess. Life keeps on keeping on.

It doesn’t make me question who I am, but it does make me question who you are more than I ever have. It’s plausible that you don’t exist, reader. I still don’t believe in ghosts, but now I do believe that I can be completely fooled whenever my brain is properly motivated to do so. That’s a little scary, but I guess it’s no scarier than anything else that can crumble in front of me at a moments’ notice. This is all quite fragile, isn’t it?

I’m just glad the ghost didn’t talk to me. As it stands, all I saw was like a little movie playing. I’m glad I didn’t tell the ghost that I loved her as she walked by. Imagine if she looked at me and said, “I love you, too.”

The fourth wall remaining in tact is safer for my overall sanity. In fact, that fourth wall is probably the difference between sanity and insanity, and that morning I got a little too close for comfort. I also feel much more sympathy for people forced to see or hear hallucinations all day. It’s not fun to question what is and isn’t real, if even for a moment. I can’t imagine the burden of constantly having to question reality.