Andras Schmelczer

An Obsidian Sync Built Around the Merger I Already Had

Andras Schmelczer — Sat, 30 May 2026 00:00:00 GMT

I refuse to give up the editor. Obsidian on the phone, Vim on the laptop, VS Code at work, the occasional headless sed across the whole vault. None of them know about each other, none of them are going to learn to, and I’m not switching to whichever sync product picks a favourite. VaultLink is the architecture that falls out of that refusal: one Rust server, one TypeScript sync engine, an Obsidian plugin, a CLI, and two test harnesses. The merge primitive underneath it all is reconcile-text, which I wrote first. VaultLink is the question that made it worth writing, finally asked in earnest.

The constraint that picks the algorithm

The consequence of that refusal is that the server never sees keystrokes. It sees end states: a file as it stood when sync caught it. That kills CRDTs (which need every operation) and OT-as-it’s-usually-implemented (same). It leaves you with one primitive: 3-way merge given a parent, a left, and a right. Which is reconcile-text. Which I’d written exactly because no existing tool took three independently-edited file states and gave one back.

The other consequence is that the path placement is its own problem. Two clients might both move the same file. A file might land on a slot another file already occupies. A rename and a content edit might race. That’s the part I underestimated.

Two loops, separate invariants

The sync engine is two loops, deliberately disentangled:

Wire loop (syncer.ts). Drains the single-consumer FIFO of pending HTTP and WebSocket ops. Updates a document’s record fields (remoteRelativePath, parentVersionId, remoteHash) and writes content to whatever path the record currently holds. Never moves files for path placement.
Path reconciler (reconciler.ts). Runs after every drained event. Best-effort pass that moves files on disk so localPath === remoteRelativePath. The move graph is topologically sorted. Records with pending local events are skipped; the reconciler only operates on settled ones. Failures (slot occupied by something untracked) are silent skips; the next pass retries.

The split is the load-bearing decision. It used to be one loop with both responsibilities, and the bug catalogue was a parade of slot-collision stashes, “conflict-uuid” hacks, and MoveOnConflict.NEW/EXISTING policy choices. Separating wire transport from path placement made most of that vanish: the wire loop can freely write remoteRelativePath to whatever the server returned, even if it disagrees with the file on disk, because the reconciler won’t move anything out from under a queued user rename.

Cycles in the move graph (A→B, B→C, C→A) are resolved by reading every file in the cycle into memory and writing each back to its new slot; no tmp files. A write-ahead marker at .vaultlink/swap-<uuid>.json lists each leg. On startup the reconciler reads the marker, hashes each from to determine which legs ran, and replays the rest. .vaultlink/** is hardcoded into the internal ignore pattern so the swap markers never themselves get synced.

Pending creates are Promises, not strings

When the user creates a file locally and then immediately edits or renames it before the create has been acknowledged, the engine doesn’t know the document’s id yet; the server assigns it. So queued events for that doc carry a Promise<DocumentId> in their documentId slot, threaded back to the still-in-flight LocalCreate. When the server acks the create, resolveCreate fulfils the promise and replacePendingDocumentId walks the queue swapping the resolved string into every dependent event.

If you’re walking events[] and comparing docIds with ===, you’ll silently fail to match until the swap happens. There’s a comment in sync-event-queue.ts that warns about exactly that, in slightly more alarmed punctuation. The shape is unusual but the alternative (synchronously waiting for the create ack before letting the user type more) is the kind of thing that makes a notes app feel like a 1998 webform.

MinCovered: the watermark that doesn’t lie

The catch-up handshake says “give me everything newer than lastSeenUpdateId.” If the client advances that id as it receives a stream of RemoteChange ids out of order, it’ll publish a too-high cursor, and the next reconnect will request from a point past events it never actually applied. Permanent gap. Replay-forever bug, with extra steps.

The fix is a small data structure called MinCovered: a contiguous-prefix tracker over a stream of integers. It advances the public min only when the next consecutive id has been processed. Out-of-order arrivals stash without bumping the cursor. Five files of test, one screen of implementation, and an entire category of confusing data-loss bugs disappears.

reconcile-text on the server

The merge sits on the server. When two clients submit edits against the same parent_version_id, the second submission triggers a 3-way merge against the parent and the freshly-committed first edit. Three strings in, one out. No conflict markers. The engine commits the merged result, increments the version, and broadcasts the new state to every connected client.

Two restrictions, both honest:

Only .md and .txt. Markdown that fails UTF-8 validation gets treated as binary, same as PNGs and PDFs.
Last-write-wins for everything else. Concurrent edits to a .docx lose one of the writes. The right fix is “don’t edit binaries concurrently,” which is unsatisfying but true.

Merge quality is exactly what reconcile-text gives me. Word-level tokenisation turns most prose conflicts into two adjacent edits that coexist. If the merge looks slightly clumsy now and then, the alternative is a <<<<<<< HEAD block in my notes, and I’d take the clumsy sentence every time.

Two test harnesses, one workflow

Distributed-sync bugs are confusing the first time and impossible the second. The fix is two harnesses:

test-client (fuzz). N parallel processes hammering random ops against a shared server for minutes at a time. Catches bugs nobody thought to write a test for. Reproductions are noisy.
deterministic-tests. Scripted multi-client scenarios with a step grammar (pause-server, pause-websocket, barrier, assert-consistent) using an in-memory filesystem against a real server binary. Used to capture a fuzz-found bug as a minimal repro before fixing it.

The workflow: fuzz finds something, I sift logs for a root cause, write the minimal deterministic test that fails on it, fix until both that test and the fuzz pass. Without the deterministic harness, every bug fix would be vibes-based.

Smaller calls

TS types are generated from Rust via ts-rs. The HTTP/WS API has one source of truth: the Serde types in the server. scripts/update-api-types.sh re-emits frontend/sync-client/src/services/types/. Hand-edits to those files are explicitly banned.
sqlx::query! macros over a checked-in .sqlx cache. SQL is verified against the schema at compile time. Touching SQL means re-running cargo sqlx prepare --workspace; if you forget, CI catches it.
One sync engine, four consumers. sync-client is the engine. Obsidian plugin, standalone CLI, fuzz harness, and deterministic harness all depend on it via file:../sync-client. Bugs are fixed once and inherited everywhere.
record.localPath mutates in place across awaits. The watcher can rename a doc while a wire-loop handler is mid-HTTP. Snapshotting localPath into a local at function entry and reading it after the await reads a vacated slot. Read it live; only snapshot when you deliberately want to compare before and after the await.
Watermark advancement is load-bearing both ways. Branches that skip a remote event without advancing lastSeenUpdateId create permanent gaps that re-deliver forever. Branches that advance without applying the content lose data. The rule that survives review is: advance only if you applied the event or deliberately discarded it.

The race I haven’t structurally fixed

Pause-or-disable-sync mid-flight is the one left. An HTTP that committed server-side but whose response was dropped leaves the server holding a doc the client never recorded. On resume, the offline scan finds the file again, uploads it as a new create, and server-side dedupe merges the duplicate into the existing doc. If the merge produces a deconflict file (two real divergences), the user picks up an extra file in their vault. Not data loss, but a small ugliness.

The two-loop split doesn’t fix this and probably shouldn’t. The honest path is something like a persisted client-side “have I acked this op?” log, sitting in the same SQLite the engine already uses. It’s on my list, below several things I want more.

What I’d change

Move the merge to the client. Right now reconcile-text runs on the server. Putting it in the WASM build of reconcile-text on each client, and letting the server be a dumb commit log, would let the merge benefit from device-specific tokenisers (Markdown-aware on the desktop, word-level on mobile). It would also stop the server from needing to understand the file format at all.
Property tests for the move graph. The cycle resolver is the part I trust least under crash. Snapshot tests can’t go where proptest can; I should be generating arbitrary move-graph + interruption combinations.
A first-class “pause” with a write-ahead op log. See above.
More than .md and .txt. A canvas-aware merge for Obsidian’s .canvas files is one reconcile-text tokeniser away. Not because anyone asked, but because the asymmetry annoys me.

The way I think about VaultLink now: reconcile-text was the bet. VaultLink is what I built once the bet looked like it might pay off. The interesting part of the bet was always that three independently-edited files can become one without anyone telling the system about the keystrokes that produced them. The interesting part of the application is everything you have to do around that merge to stop the rest of the system from undoing it.

Backing Up Running Databases Without Stopping Them

Andras Schmelczer — Fri, 29 May 2026 00:00:00 GMT

Once you self-host a few services with live databases, the backup question stops being theoretical. A Postgres or SQLite file half-written when tar reads it goes into the archive in a state nothing on Earth will replay; you just don’t find out until the restore. Two years in, with multiple incidents I had to actually recover from (including the photos behind the e-ink frame), I trust this stack precisely because the correctness argument is short: BTRFS gives me an atomic snapshot, and everything above it can be a shell script. One Alpine container, ~75 lines of Bash, pushes that snapshot to one or more Borg repositories on a fixed interval. Multi-target is numeric env vars (BORG_REPO_0, BORG_REPO_1, …). No config format, no DSL; the env file is the configuration.

The problem the snapshot solves

I self-host several databases that are mid-write at every moment of the day. tar | borg create against the live volume is a race: a Postgres or SQLite file that’s half-written when borg reads it goes into the archive in a state nothing on Earth can replay. The “right” answer is to coordinate a quiesce with every database: a fan-out of pg_dump, SQLite .backup, Redis BGSAVE, and so on, all with retry, timeouts, and per-app credentials.

The cheaper answer, if you’ve put everything on one BTRFS volume, is btrfs subvolume snapshot. It returns instantly with a copy-on-write fork of the entire filesystem. Every file is now atomically consistent at exactly the same instant. Run borg against the snapshot, not against the live volume.

btrfs subvolume snapshot /btrfs-root /snapshot
cd "/snapshot/btrfs-root${BACKUP_RELATIVE_PATH:-}"
borg create ... ::"{hostname}-{now:%Y-%m-%dT%H:%M:%S}" .

The snapshot lives only for the duration of the borg run. A trap cleanup EXIT deletes the subvolume whether the backup succeeded, failed, or was killed. The next run snapshots fresh.

This shifts the entire correctness argument from “did I quiesce every database in time” to “does BTRFS give me a consistent snapshot.” It does. That’s why everything below it can be a shell script.

Multi-target as numeric env vars

The 3-2-1 backup rule wants three copies, two media, one offsite. My answer is a remote (rsync.net) and a local HDD, both fed from the same snapshot. The wire format for “multiple targets” is just numbered env vars:

BORG_PASSPHRASE_0=...
BORG_REMOTE_PATH_0=borg1
BORG_REPO_0=username@username.rsync.net:~/backup

BORG_PASSPHRASE_1=...
BORG_REPO_1=/local-backup

backup-wrapper.sh loops index=0 upward, exports BORG_PASSPHRASE / BORG_REPO / BORG_REMOTE_PATH from the indexed copies, runs backup.sh, unsets them, increments. Stops the first time the next index has no passphrase.

There’s also a no-index fallback (BORG_REPO=... with no number) for the single-target case. Same script, no extra config plane.

I keep coming back to this pattern for small-system orchestration. The env file is the data structure. There’s no YAML parsing, no JSON schema, no config-validation layer between you and the variable that actually matters.

The scheduler is a sleep, not cron

while true; do
    /src/backup-wrapper.sh 2>&1 | log_message
    sleep "$SLEEP_TIME"
done

A comment in the file says it out loud: “Using a simple sleep loop to schedule backups instead of cron to avoid concurrency issues.” Cron with a one-hour cadence and a backup that occasionally takes 70 minutes will eventually overlap itself. The sleep-loop can’t: the next run starts when the previous one is done, plus the interval. One process, one snapshot, one borg invocation. Concurrency bugs you can’t have are concurrency bugs you don’t have.

Healthcheck is a file mtime

borg create succeeded? Write date > /health/backup_completion_time.log. The Docker healthcheck shells out every 10 seconds and compares that mtime against MAX_BACKUP_AGE_SECONDS (default 86400). Older than that, container is unhealthy and whatever’s watching containers (in my case a notification hook) finds out.

Two subtleties worth naming:

First-boot grace period. If backup_completion_time.log doesn’t exist yet (fresh container, first backup still running), fall back to container_start_time.log so the container isn’t reported unhealthy during the first scheduled run.
Partial success is not success. In multi-target mode, the completion log is only written if every target succeeded. One repo failing means the healthcheck stays red even if the other two are fine. Stale-but-quiet was the failure mode I wanted to make impossible.

Smaller calls

borg break-lock at the start of every run. If the previous container was killed mid-backup, the repo is locked and the next borg create will hang. Just break it. There’s only ever one writer because of the sleep loop.
set -e after borg init, not before. The init line is the only one allowed to fail (first run on a fresh repo). Everything after halts on error.
BORG_RSH='ssh -oBatchMode=yes'. Fail fast if SSH would have prompted, instead of hanging forever inside a detached container.
ServerAliveInterval 30 in ssh_config. Long borg transfers across home-ISP NAT get killed if nothing flows for a few minutes. Keepalives keep the tunnel open.
--files-cache=ctime,size,inode. The default mtime,size,inode re-hashes files when their mtime changes; on BTRFS, ctime is the more honest signal of “this content actually changed.”
compression=zstd,12. The sweet spot for backup data on my hardware: substantially better than zlib, not so slow it dominates the run.
borg compact --threshold=5 --cleanup-commits. Reclaims space from pruned archives whenever the segment-file fragmentation crosses 5%.
IGNORE_GIT_UNTRACKED=true. Optional. Walks every .git dir under the snapshot, runs git ls-files --others --exclude-standard, and feeds the result into --exclude-from. Skips target/, node_modules/, build caches; anything the repo already knows isn’t worth keeping.
SYS_ADMIN capability on the container. Needed for btrfs subvolume snapshot and delete from inside the namespace. The narrower capability set didn’t have a way through.

What I’d change

A test rig that restores into an empty volume on a schedule. “Backups exist” is not the property I care about. “Backups restore” is. I have anecdotal evidence after every incident; I don’t have a green checkmark before one.
A failure notifier separate from the healthcheck. Docker healthcheck-unhealthy is one signal; I’d also want an explicit push (ntfy, email, Telegram) on first failure of a run, so I don’t have to be watching the container state.
Parallel targets when network and disk don’t compete. The current loop is strictly sequential: rsync.net then local HDD. They share neither bandwidth nor spindles; they could run in parallel and halve the wall-clock. Sequential made the wrapper trivial; the trade was knowable and I made it.

Two years in, the part I’d defend hardest is the snapshot. Everything above it is a wrapper that could be rewritten in an afternoon. The snapshot is what makes the wrapper allowed to be one.

A Physics Practice App for the Hungarian Érettségi

Andras Schmelczer — Thu, 28 May 2026 00:00:00 GMT

I needed it. In my last year of high school I was about to sit the emelt szintű (advanced-level) physics érettségi, and the practice material I could find online was either paywalled or scattered across PDFs that wouldn’t tell you whether your answer was right. So one evening I started typing past exam questions into a JSON file. A few weeks later I had something resembling a study tool, and a few weeks after that I had 659 questions covering more than a decade of past papers.

The site is intentionally small. A static frontend on jQuery, four CSS files, a JSON blob of questions, a folder of scanned diagrams from the original papers. You pick a topic (Mechanika, Hőtan, Elektromosság, Atomfizika) or hunt down a specific year’s exam, get a randomised quiz, answer, and the page colours each row green or red. Past results sit in localStorage, because the audience was high schoolers; account-less was the privacy answer.

It outgrew Firebase eventually. I moved the data to a small Express backend so I could keep editing questions without a paid plan, with a JSON file and an image folder as the storage layer. The admin routes have no auth; instead, the service stays off the public internet and I edit through an SSH-forwarded localhost. Fine for a one-person CMS, terrible advice for anything with multiple editors.

What I’d change if I were starting it now:

Astro instead of jQuery plus a Node server. The whole thing could be one static site that re-renders on push. No backend, no CSP fiddling, no Docker.
Markdown source, not a hand-edited JSON file. Editing questions in JSON is fine until you forget a comma at 1am and the site stops loading.
A real licence note on the question text. The papers are public exam material, but it’s worth saying so somewhere on the page.

It’s been online in some form for eight years. Every spring I get a few emails from students asking whether I’ll add the latest year’s paper. I usually do, eventually. The thing I made for myself in 2017 is still doing its job for someone else’s last year of high school, and that’s the only metric on it I actually care about.

25 Million UK Property Rows in a Single Rust Process

Andras Schmelczer — Thu, 28 May 2026 00:00:00 GMT

A user told me the map felt sluggish when they dragged it across Manchester with four filters on. They were right. The previous version round-tripped to a database, decoded floats, and lost the budget for a single pan inside the first filter. The rewrite is one Rust binary that holds the entire UK property history in RAM and treats every filter as three integer compares. Everything else in this post is the consequence of refusing to break that latency again.

The constraint that shapes everything

The answer to “what’s the median price in this hexagon, filtered to four-bedroom terraces under £450k with a 35-minute transit to Manchester” needs to come back inside a single map pan. Per visible cell, per request, every time the user moves anything. That’s the work.

At the resolution we want, the inputs are roughly 25M historical transactions, each with around 150 numeric features (price, EPC, deprivation deciles, school catchment metrics, POI proximities, noise, crime, …). Naively f32 per cell, that’s ~15 GB before you count anything else: postcodes, POIs, places, tiles, travel times. The rest of the architecture is the consequence of insisting it all lives in one process on one rentable box.

u16 quantisation in a row-major flat array

Every numeric feature is encoded as ((value - feature_min) / feature_range) * 65534. Dequant is raw * dequant_a + quant_min. u16::MAX is reserved as NAN_U16 (the explicit missing-value sentinel), so the live range is 65534, not 65535. Per feature we keep a (min, scale, p1, p99) tuple and a 100-bucket histogram for the UI sliders.

Storage is a single Vec<u16> laid out row-major: feature_data[row * num_features + feat_idx]. Sixteen features fit in one 64-byte cache line; a row scan stays in L1 for several rows at a time. With 25M rows × ~150 features × 2 bytes, the property matrix is around 7.5 GB, comfortably inside a 16 GB instance once the rest of the data joins it.

The precision loss is real but bounded: 0.01–0.1% per feature on the data we have, below the noise floor of any downstream statistic. The win is that the hot loop never touches an f32.

The hot loop is three integer compares

ParsedFilter carries min_u16 and max_u16: the user’s bounds requantised against the same per-feature (min, scale) at parse time. The row test is literal:

let raw = feature_data[base + filter.feat_idx];
raw != NAN_U16 && raw >= filter.min_u16 && raw <= filter.max_u16

No string keys. No f32 decoding. Enum features go through a pre-built FxHashSet<u16> of allowed raw values, same shape.

Two small parse-time choices made this fast in practice:

Sort filters by selectivity. numeric.sort_unstable_by_key(|f| f.max_u16.saturating_sub(f.min_u16)) puts the narrowest ranges first. A 50-filter request usually short-circuits on filter two or three.
Reject inverted ranges at parse time. min > max errors out, so saturating_sub can’t wrap a huge u16 into the sort key and silently reorder things.

Spatial: a CSR grid plus precomputed H3

Two indexes, used for different things.

A 0.01° (~1 km) regular grid in CSR layout (a single flat values: Vec<u32> of row indices and an offsets: Vec<u32> of per-cell starts) answers bbox queries. CSR avoids the 24-byte-per-cell Vec header you’d pay with Vec<Vec<u32>>, which is the difference between a few MB and a few hundred MB at UK scale. for_each_in_bounds is the variant that skips the result allocation; aggregators stream into it directly.

An H3 cell at resolution 12 is precomputed per property at boot, stored as Vec<u64>. Lower-resolution cells are derived via CellIndex::parent(); fast and exact. The hexagon endpoint thresholds at PARALLEL_THRESHOLD = 50_000: below, plain serial aggregation; above, rayon::par_chunks() with chunk = max(1000, rows / num_threads). Below the threshold, rayon’s per-chunk overhead dominates the work it’s parallelising; it’s worse than the obvious thing. Above, the slope flips.

A small per-thread FxHashMap<u64, u64> H3 cache inside each rayon chunk takes care of properties touched by multiple aggregations within the same chunk.

State is an Arc-clone away

AppState is large and immutable after the boot-time loads. SharedState = RwLock<Arc<AppState>> wraps it; every handler does shared.load_state(): a brief read lock, an Arc::clone, no further lock contention for the request.

The standard read-mostly pattern, but worth naming for one reason: it makes hot-reloading the parquet trivial later. Build a new AppState from disk, take the write lock, swap the Arc, drop the old one when the last in-flight request finishes. None of the handlers need to change.

On top of that there’s a per-endpoint ConcurrencyLimitLayer::new(N). The expensive endpoints (filter-counts, hexagon-stats, screenshot, export) get 3–5; the cheap ones get 20–30. It is the simplest backpressure you can write and it does most of the work.

PocketBase as the distributed lock

For mutations that need exclusion (subscription state transitions, redeem-invite races), there is no Redis. Instead, acquire_pocketbase_lock does an optimistic create against a locks collection. If create succeeds, we own it; if it fails on conflict, we fetch the existing lock, check expires_at_unix, and if it’s expired we delete and retry. Owner ID is a 24-char random string so stale-lock detection doesn’t rely on host identity or wall-clock skew.

Release is a Drop handler that spawns a tokio task to delete the record; async cleanup keeps the synchronous drop path free of I/O. 100 ms retry, 10-second acquire deadline. Coarse, but correct, audit-loggable in PocketBase, and adds zero new infrastructure to operate.

Cost-capping the LLM endpoint

The AI filter parser is a Gemini call. Two structural choices made it cheap enough to leave on:

One system prompt, computed once. build_system_prompt(features, mode_destinations) runs at boot. The feature catalogue, the enum of available travel modes, the few-shot examples: all concatenated once into a String on AppState. Every request reuses the same bytes, which Gemini’s input cache likes.
A search_destinations tool with a closed enum of modes. The LLM doesn’t get to invent place slugs. It can call the function; the server slugifies and resolves against the loaded travel-time directory using a word-overlap matcher tolerant of kings-cross vs King's Cross.

On top: a per-week token budget (AI_FILTERS_WEEKLY_TOKEN_LIMIT = 10_000_000) and a 2,000-token output cap. The budget is the actual cost guarantee; the per-call cap is belt-and-braces.

Smaller calls

mlockall(MCL_CURRENT | MCL_FUTURE) at startup. The hot dataset has to never page out. With CAP_IPC_LOCK it works; without it we log and continue.
malloc_trim(0) after each big load. Polars leaves a high allocator water-mark after parquet scans. Trimming after each major load gives back hundreds of MB of RSS before steady state.
Prometheus path normalisation. /api/tiles/5/16/10 becomes /api/tiles/:z/:x/:y before it becomes a label. Otherwise /.env, /wp-admin/..., and bot scans explode cardinality.
Median-half eviction over LRU. Token, share-bounds, and superuser-token caches evict the older half on overflow instead of one entry at a time. Cheap, and it spreads the re-validation cost instead of triggering a thundering herd.
spawn_blocking for Polars I/O. Parquet scans are CPU-bound. They block the tokio executor if you let them; they don’t if you don’t.
Box<[T]> instead of Vec<T> for aggregator accumulators. No capacity field, 8 bytes saved per slot. At hundreds of hexagons × six features per request it adds up.
String interning, three times. Postcodes (~2.5M unique from 25M rows) live in a lasso::RodeoReader; each row stores a Spur (~4 bytes). Address tokens are flattened into one buffer with per-row (offset, length) arrays. The same pattern for enum value strings.
Free-zone bbox check, not point check. Unlicensed queries must have their entire bbox inside FREE_ZONE_BOUNDS. Point-in-zone would be convenient and wrong; it would let users pan to anywhere from a free-zone centre.
Share-link bounds are server-computed. bounds_from_view(lat, lon, zoom) derives the bbox from a UK-aware longitude/latitude span (half_lat = half_lon * 0.6) and clamps it. Legacy short URLs without server-stored bounds grant nothing.

What I’d change

Pin the allocator. I rely on malloc_trim to keep RSS predictable. A jemalloc with explicit purge would behave better than glibc plus periodic trimming, especially under sustained load.
One bench for the hot loop. I trust the structure but I have no number for filter throughput per row per filter under typical load. That number would tell me when the u16 trick stops being enough.
Move free-zone bounds to PocketBase. FREE_ZONE_BOUNDS is a const. It’s been right for the demo region for a year. The next time it changes I’ll regret hardcoding it.
A typed query DSL instead of ;;-separated strings. The current filter wire format is name:min:max;;name:val1|val2. Cheap to parse, awful to evolve. A small JSON envelope would survive the next feature.

There’s something a little embarrassing about a binary that just memory-maps a country. But the architecture made the latencies trivial, and the latencies are most of what a user feels.

An E-Ink Photo Frame That Sleeps When the House Is Empty

Andras Schmelczer — Wed, 27 May 2026 00:00:00 GMT

In 2024, researchers found family-blog photos of Brazilian children inside the LAION training set. Self-hosting your photos used to be a preference; it’s a safeguarding decision now. Nixplay’s cloud-tied frames have bricked. Funimation deleted libraries people had paid for. I wanted a photo frame on the hallway wall, and I wasn’t going to hand the family album to a vendor who could close the doors on it.

So it’s a Raspberry Pi Zero 2W driving Waveshare’s PhotoPainter panel, pulling from my self-hosted Immich library, part of the same self-hosting setup I back up with btrfs and borg. A few hundred lines of stdlib Python on top of the reference driver.

Why a stupid amount of engineering for a picture on a wall

That’s the point. Albert Borgmann once distinguished devices (which efficiently deliver a commodity and disappear into the wall) from focal things, which gather a practice around them. A Nest Hub is a device; it shows you photos the way a microwave delivers heat. The frame is a focal thing. I curated the weights. I hung it where the light was right. I tweak it when something feels off. It doesn’t sell my attention back to me; it asks me to pay some.

The medium helps. E-ink doesn’t glow and doesn’t beep. From across the room it reads as image, not as screen, and that one perceptual difference changes how often I actually look at it.

The presence gate

The cron line does most of the work. Every 15 minutes, the script checks the time of day, then asks Home Assistant whether anyone in HA_PRESENCE is home. If not, it quits. The panel keeps showing the last photo, because e-ink, so you walk in to whatever was there when the house emptied.

The point isn’t power saving. John Berger drew a line between photographs kept inside a context of lived meaning (private), and ones severed and circulated (public). Google Photos hands you the public mode dressed as the private. A wall in the hallway, lit only when your people are home, restores the context. The same photograph means something different surfacing while you’re cooking dinner than it does in a feed at 11pm.

How a photo gets picked

The pool is biased the way memory is biased: four buckets, weighted ~30% “on this day” (dropping to ~10% if only the ±3-day fallback fires), ~18% favourites, ~36% the last 30 days, ~36% everything else. Within those buckets, orientation-match against the current frame gets 4x the weight of mismatch, because cropping landscape to portrait works less often than the reverse.

A 7-day rolling history filters repeats. Before accepting a candidate, the picker runs heads_fit_in_crop against Immich’s detected face boxes, extended upward to cover the skull and padded by HEAD_SAFETY_MARGIN: if the planned crop would slice into any visible head, that candidate is rejected and another is drawn. A wall photo with half a face in it is worse than the same photo not on the wall at all.

face_aware_crop does the actual cropping: resize-cropping to fill the frame while biasing the window around detected faces. A landscape shot with room around the subject usually crops cleanly to portrait this way; the guardrail above catches the ones that don’t.

Tuning the pipeline somewhere else

Iterating on the Pi means waiting 12+ seconds per refresh. Both the face-aware crop and the dither were tuned in Jupyter against a local pool of a few hundred photos, then frozen and shipped.

The dither is where the choice visibly matters. The panel can only show black, white, red, yellow, blue, green; no intensity control, every pixel is one of those six. I compared Floyd-Steinberg, Stucki, and a couple of ordered variants. Atkinson kept the highest perceived contrast on the 6-colour palette without smearing skin tones into the nearest yellow. Pure-Python Atkinson on the Pi Zero was unusably slow, so the inner loop runs through numba with perceptual-weighted nearest-colour matching (0.299/0.587/0.114). Roughly 100x faster after the JIT cache warms.

The weekend-reimplementable rule

Hundred Rabbits, a couple who live offshore on a sailboat doing permacomputing in practice, hold themselves to a rule: any system they depend on should be reimplementable in a weekend. The frame meets the bar. A few hundred lines of stdlib Python on a documented panel, reading from an HTTP endpoint that returns JPEGs. It came together over an afternoon with Claude Code plus a couple of weekends tuning the picker and the dither; the repo is public partly as a reference for anyone wanting to do something similar. If Immich disappears tomorrow the selection logic is eighty lines I can repoint at whatever replaces it.

Smaller calls

Capture age and EXIF location painted as text. White on a black stroke, written after dithering, so the labels stay sharp on the 6-colour palette.
Swap masked, journald volatile. The SD card is the most likely thing to die on this build. Don’t write to it unless you have to.
Wifi power-save reconnect job. The Pi Zero 2W’s wifi drops if power-save kicks in. A separate wifi-check.sh every five minutes brings it back.

What I’d change

Lower-power hardware. The Pi Zero 2W is overkill and idles 14 minutes out of every 15. The Waveshare board didn’t have an RTC interrupt pin soldered, and rather than hack one in, I’d reach for an ESP32 next time. Deep sleep has plenty of time to do the image work inside a 15-minute window.
A bigger panel and a small light. The Inky Impression 13” with a custom frame and integrated lighting would help most in the evenings, when the e-ink reads muddled under warm lamps.
A daytime cadence curve. 15 minutes is constant. It should slow at night and speed up around the times we’re actually in the hallway.

The frame is small, slow, and almost entirely silent. It does one thing for one household and doesn’t tell anyone about it. The smallness is the point. There should be more of this kind of thing.

A WebGPU Drawing Garden Where Agents Rewrite Your Strokes

Andras Schmelczer — Fri, 22 May 2026 00:00:00 GMT

Nine numbers in {-1, 0, 1} arranged in a 3×3 matrix decide an entire vibe’s personality. That constraint is what kept me up: proving simplicity can be expressive, that you don’t need a behaviour function per preset. A WebGPU drawing toy where you stroke a colour, agents spawn along it, and the garden slowly overwrites the patch you laid down. One static HTML file, six compute stages, none of them skippable.

Why physarum needed a knob

Physarum-style agent sims are everywhere and most of them stop being interesting after thirty seconds, because they converge to the same family of branching shapes no matter what you feed them. Seeding the initial condition isn’t enough; the input has to keep being a force inside the loop, otherwise you’re just watching the attractor settle.

My second self-imposed constraint was that one engine had to produce six visibly different presets without forking. The first prototype had a switch (preset) with one behaviour function per vibe and it was already painful at vibe two. I needed the personality to live in data, not code.

The reaction matrix

Each vibe is a 3×3 table of colour-to-colour affinities. When an agent of colour i looks at the trail in front of it, it weights the three channels of that sample by row i of the matrix, then uses the sign to pick left, right, or straight. That’s it. The whole behaviour rule.

Three examples of what nine numbers can do:

Aurora Mycelium: cyclic, each colour chases the next. Agents wind into ribbons.
Velvet Observatory: every off-diagonal entry negative. Colours repel into separate islands.
Paper Lantern Fog: matrix filled with ones. Colours collapse into one cooperative blob.

Adding a tenth number to the matrix would tax every existing vibe. Tuning the nine I have is a text edit. Six presets in, I haven’t extended it.

The compute work, broken into small jobs

Six stages, ten WGSL files, each one short enough that I can hold it in my head when something breaks:

Agent step: sample the trail at a sensor offset, pick a turn, move, deposit colour. ~300 lines, the longest one.
Diffusion: blur and decay so old marks soften. The boring one, and the one you can’t skip: without it, strokes stay forever and the garden collapses into noise.
Brush: write user strokes into both the trail texture and a separate “source” texture the agents can read.
Eraser: two variants: one clears a region of the trail, the other kills agents in a radius.
Agent generation: spawn along strokes, resize the buffer when the cap changes, compact after erasure so dead slots don’t waste GPU time.
Render: read the trail, apply palette and grain.

The bind-group setup overhead from running more pipelines was lost in the noise next to the simulation cost. The win was that when the eraser shader started killing the wrong agents, I opened one file and reasoned about it without touching anything else.

Smaller calls

Adaptive cap, circular buffer. If FPS drops, the cap shrinks; if there’s headroom, it grows. When the cap is hit, new agents overwrite older ones. The decay you see, a stroke vanishing thirty seconds after you drew it, isn’t an explicit eraser, it’s the buffer wrapping around.
URL is the share format. The chosen vibe is in the query string. The “send your friend this preset” link is just a URL with ?vibe=tidepool-lantern on it. The parser is tolerant about accents and casing because people retype these.
One HTML file. All CSS and JS inline. The piano samples sit beside it. Self-contained enough to email or drop on a USB stick.

What I’d change

The intro animation (agents fly in to spell the title, then transition to steady state) couples three shaders through a single progress: 0 → 1 value. It’s the bit I’d least want to refactor today. Next time I’d model the intro as its own dispatch with its own buffer and hand off cleanly.
Mobile works, but the toolbar fights the canvas for screen and the agent cap has to shrink hard to keep frame time down. A proper fix means rethinking the toolbar and exposing the cap-vs-resolution tradeoff to the user.
The simulation has invariants that proptest would falsify in minutes: agent count under the cap, every stroke produces a positive-coloured deposit on the next frame, and the eraser doesn’t leak agents past its radius. Snapshot tests aren’t the right tool here.

A 3-Way Text Merger That Never Shows Conflict Markers

Andras Schmelczer — Thu, 21 May 2026 00:00:00 GMT

Why I wrote it

I keep Markdown notes in three editors I don’t control the internals of: Vim on my laptop, VS Code on my work machine, Obsidian on my phone. When two of them edit the same note between syncs, I have three files: the last-synced parent and two divergent children. That’s the input. I want one merged file out, and I want to hand it back to the editors without conflict markers, because <<<<<<< HEAD is not something a notes app should ever show me.

Every existing tool got close and missed:

git merge-file does exactly the right thing structurally, then writes markers into the output. That’s correct for source code and wrong for prose.
CRDTs and OT both assume you own the editing pipeline down to the keystroke. I don’t. I’m looking at three files.
diff-match-patch doesn’t take a common ancestor. On adjacent edits it quietly produces wrong output. I have a runnable example in the repo.

So the library does exactly one thing: pure function from three strings to one. No async, no networking, no concurrency, no plugins. Anything outside that boundary is somebody else’s library.

The decisions worth naming

Myers diff per side, then weave the diffs. Each child is diffed against the parent, the two edit scripts are optimised so adjacent changes group cleanly, then a single weaving pass interleaves them into one ordered op sequence that produces the merged text. The weave borrows the shape of operational transformation, but the inputs are batched complete diffs, not live keystrokes, so it only runs once per merge.

Tokeniser is the user knob. This is the choice I’d defend hardest. Most of what people want when they say “merge differently” isn’t a new algorithm; it’s a different unit. Word-level tokenisation turns most “conflicts” in prose into two adjacent edits that coexist. Line-level makes it behave like git merge-file. Markdown-level merges on headings and list items. Same engine, four different products depending on what you call a token.

Cursors are first-class merge inputs. Each cursor has a stable ID and rides through the merge so a collaborative editor can ask “where did this cursor go?” without reconstructing it from the output text. This is the bit that made it useful to anything that wasn’t just the Obsidian sync plugin I wrote alongside it.

The Rust core is generic; the FFI surface is not. Inside Rust, the tokeniser is a dyn Fn(&str) -> Vec<Token<T>>. That dies the moment you try to pass it through wasm-bindgen or pyo3. The fix was a closed enum of built-in tokenisers for non-Rust callers, with the generic version reserved for Rust users. Not elegant, but the alternative was per-binding glue forever.

WASM size mattered enough to tune for it. The release profile is aggressive about size, and the JS package ships a small leak detector that warns if you forget to free wasm-bindgen objects. I lost an afternoon to that the first time and didn’t want anyone else to.

What’s held up, what I’d change

Kept: the never-emits-markers, never-drops-edits guarantee. It’s the only reason a sync engine can call this library without an escape hatch.
Kept: the comparison example against diff-match-patch. It’s a runnable program in the repo showing exact inputs where the alternative is wrong. Way more convincing than a benchmark table.
Cut: the snapshot tests do well on regressions and badly on unknown edge cases. Three-way merging is exactly what proptest was made for, and I should have written generators on day one.
Next: I want to be more explicit about the boundary. reconcile-text is a merge primitive, not a live collab engine. If you have a keystroke stream and a real-time channel, use Yjs or Automerge. This library is for when you don’t.

If you take one idea from this

Prose deserves a merger that prefers a slightly clumsy sentence over a marker. Code doesn’t. That one asymmetry is the whole reason the library exists in the shape it does; everything else fell out of taking it seriously.

A Python Framework Where Doing the Right Thing Is the Default

Andras Schmelczer — Sat, 09 May 2026 00:00:00 GMT

By the end of 2021 I had stopped believing the people skipping ML deployment best practices were the problem. They knew the list. They agreed with the list. They had a deadline, and every item on the list cost five lines of glue. My MSc thesis turned that into the actual research question: not “what should engineers do” but “what API shape makes doing the right thing cheaper than not.” The framework that fell out, great-ai, is a decorator on a plain Python function. The thesis behind it is the part worth reading.

The thing nobody wants to admit

The literature has a long list of habits you should adopt when shipping an ML service: track inputs, version models, expose health, log decisions, keep predictions reproducible. Everyone agrees with the list. Almost nobody implements all of it.

I spent the bulk of the thesis catalogueing 33 such habits, proposing 6 more, and surveying engineers on which actually got applied in their day jobs. The data was pretty clear about the failure mode: it wasn’t ignorance, it wasn’t laziness, it wasn’t budget. It was that the cost of doing the right thing, five lines of glue per habit multiplied across a stack, was higher than the visible cost of skipping it. So skipping it became the default.

So the real research question wasn’t “what should engineers do.” It was “what API shape makes doing the right thing cheaper than not.”

The framework’s bet

A decorator on a plain function. @GreatAI.create turns a regular Python function into a deployed service with metadata, request tracing, and a versioned interface. No inheritance, no project layout, no enforced directory structure. The mental cost is one import.
Implicit behaviour only for cross-cutting concerns. Logging, versioning, metadata are implicit. Anything touching business logic stays explicit. The rule: if it would surprise me when I’m debugging, it shouldn’t be implicit.
Own the contract, leave the storage alone. Where you persist logs, models, or metrics is your choice; GreatAI defines the shape and provides defaults. The model registry stays somebody else’s library.

The survey backed up the central premise: ease of use and functionality both matter for adoption, and they’re independent axes. A framework that ticks every box and is awkward will lose to a smaller one that doesn’t.

What I’d change

I’d narrow further. Anything GreatAI did that overlapped with MLflow, BentoML, or modern observability stacks would go. The durable bit was always the decorator and the catalogue behind it.
I’d publish the survey instrument separately. The 33-habit catalogue and the adoption-vs-impact methodology outlive the framework. People still ask about that part.
I’d stop calling them “best practices.” I used that phrase in the thesis and it aged into corporate-speak. The honest name is “things that hurt later if you skip them.”

A 2D Ray Tracer for the Browser, Tuned for the Phone in Your Pocket

Andras Schmelczer — Fri, 08 May 2026 00:00:00 GMT

Winter 2020, BSc thesis deadline closing in, and the thing had to run acceptably on my advisor’s laptop the day he graded it. That single shipping pressure exposed every lazy assumption in the architecture and picked the design: tile-based passes, deferred shading, shaders generated per scene and per device. A 2D ray tracer in the browser via signed distance fields: soft shadows, smooth reflections, no triangle mesh. The other half of the thesis was decla.red, the multiplayer game that proved the renderer survived a real game loop.

What “mobile GPU” actually meant

A 2D SDF ray tracer is conceptually simple: for each pixel, march along a ray, sample the distance field, accumulate light. The implementation that works on a desktop NVIDIA card spends so much per pixel that a mobile GPU melts. So the design problem was never “can SDFs do soft shadows” (yes, easily), it was “what work can I avoid per pixel without giving up the look.”

Three constraints did most of the design work:

WebGL1 and WebGL2 both supported. No “modern browser only” cheat. That ruled out anything that needed compute shaders or storage buffers.
No per-scene hand-tuned shader. This is a library; users plug in their own scene descriptions. The renderer has to compile something appropriate at runtime.
Acceptable on a phone. Not “good when the user owns the right hardware.” It had to be acceptable on the laptop my advisor used to grade the thesis.

How it actually runs

Tile-based rendering. Group pixels and reason about them together. Most regions of a frame share the same nearby geometry, so you can early-out enormous swathes of pixel work if you know the tile’s bounds. This was the single biggest perf win.
Deferred shading. Separate “find the surface” from “shade the surface.” Shadow casting and reflections need the same geometry queries; doing them once per pixel and reusing the result was worth the extra texture bandwidth.
Generated shaders per scene and device. If a scene has no reflective surfaces, the generated shader doesn’t carry the reflection path. If the device only supports WebGL1, the shader doesn’t reach for WebGL2 features. Static feature flags do this badly; runtime generation does it well.
TypeScript scene descriptions, no DSL. I prototyped a small DSL for SDF authoring and threw it away. Pride’s expensive. Users describe scenes in plain TypeScript and the library compiles them down. A DSL would have meant one more language to teach and one more compiler to debug.

Held up, didn’t hold up

Held up: the mobile constraint forced structural perf work instead of cosmetic perf work. When something only runs on a desktop GPU you mistake headroom for good architecture, and the rude awakening comes from a user.
Held up: keeping the library boundary clean. A demo can hide a messy implementation; a published package can’t.
Didn’t: I had no instrumentation around shader variants. Today I’d ship a small ?debug=1 overlay that prints exactly which shader got compiled for that session and why.
Didn’t: the docs are words about ray marching. The ideas are visual; the explanation should have been too. Diagrams next time.

One Game Library, Imported by Both the Client and the Server

Andras Schmelczer — Thu, 07 May 2026 00:00:00 GMT

My thesis was a renderer; proving it in a real multiplayer loop was the point. A real game loop is a worse audience than a tech demo. That’s the point. So through autumn 2020 I built decla.red on top of SDF-2D: a conquest-style space shooter, two teams, small planets, ray-traced 2D rendering, browser and mobile. The architecture decision worth remembering came out of needing the server and the client to stop lying to each other: one TypeScript module containing the game rules, linked by both sides of the wire.

The split that usually goes wrong

Real-time multiplayer has an awkward two-machine problem. The server has to be authoritative or the game is cheatable; the client has to feel immediate or the game is unplayable. If you write the rules twice, once on each side, they will drift. Eventually a player’s screen will say one thing and the server will think another.

I wanted the server’s “compute the next state” function and the client’s “predict the next state locally” function to be literally the same function. So I put the rules in a shared TypeScript library, published nothing, and had both package.json files link to it.

The win wasn’t elegance, it was the bugs that didn’t happen. Client prediction stopped being an approximation of the server; it was the server, run optimistically and reconciled when the authoritative update came back.

Other choices worth a sentence

k-d trees for spatial queries. Once the world held more than a few dozen objects, naive collision and proximity checks dominated the server tick. A k-d tree dropped them out of the profile.
Message-passing object model. Lifted from Smalltalk’s doesNotUnderstand: idea. Entities respond to messages they care about and ignore the rest. Easier to extend than the inheritance tree I tried first, and less brittle.
Firebase only for server discovery. Not for game state, just for “which servers are currently in the pool.” Tiny consistent store, didn’t need to write one.

What I’d change

Observability for desync. Multiplayer systems live or die by visibility into divergence. I had logs; I needed dashboards showing the rate, the shape, and the triggering interaction for every prediction miss. Without those, debugging was guessing.
Don’t tangle rendering and networking in the same tree. Both were interesting, both put different kinds of pressure on the architecture, and the directories grew into each other. Separate top-level folders from day one next time.
Skip multi-server until the math demands it. I wired up multi-server early because it sounded right. With 16–32 clients per server I was nowhere near needing it; the complexity wasn’t free.

A 50 FPS Game Engine on an 8-Bit Microcontroller

Andras Schmelczer — Wed, 06 May 2026 00:00:00 GMT

I’d done microcontroller work on dev boards before and it always felt like I was renting the hardware. As soon as I had a real board with my own soldering on it, bugs stopped feeling like software inconveniences and started feeling like consequences of choices I’d made in KiCad. That shift was most of the value of doing it this way. Four years on from my first hardware project, the lesson was that owning the whole stack down to the copper changes how you debug.

This one is a handheld game built from the PCB up around an ATtiny85V: 8-bit ALU at 8 MHz, no FPU, no SIMD, 8 KB of flash. Anything I built had to fit inside that, or I’d be staring at a brick.

The bits worth showing

SIMD-on-an-8-bit-ALU display driver. The OLED is 128×64 monochrome, 1024 bytes per frame. The driver packs four pixels into a byte and processes them with bit-parallel tricks. That’s how the frame budget stayed under 20 ms with room for game logic.
Prototype-based inheritance, in C. Entities share behaviour by pointing at a struct of function pointers. No vtable, no class, no allocator. Cheap dispatch and the whole object model fits on one screen.
Atomic EEPROM commits. Sprite data and save state both live in EEPROM. The commit path writes a new region, then swaps a tiny header pointer. Pull the battery mid-write and the previous version is intact.
PNG-to-C sprite pipeline. A Python script turns PNG artwork into static C arrays the firmware can include directly. Asset workflow without ever leaving the source tree.

What I’d change

A host-side emulator. Debugging firmware directly on hardware was character-building and slow. A small SDL-based simulator linking the same C code would have shortened the iteration loop from “reflash and hope” to “rebuild and run.”
Power numbers I’d actually trust. I have peak and standby draw. I don’t have a curve over a real gameplay session, so I honestly can’t say how long the battery lasts under load. I can only say it outlasted my patience.
A development log for the driver. The display driver and the EEPROM commit protocol are the parts I’d still defend. They deserved diagrams and measurements at the time, not the half page of comments I left them with.

Syncing State with an Immutable Trie

Andras Schmelczer — Tue, 05 May 2026 00:00:00 GMT

In August 2019 I wanted a goal tracker I’d actually open, on whichever device was nearest, without watching it disagree with itself. Nothing off the shelf fit, so I built one over a couple of weekends. The tower metaphor was the part friends saw; the part that aged well was the sync model that fell out of needing the same state in three places at once.

The problem in one paragraph

Pick any non-trivial mutable object graph, sync it across devices, and you end up either sending the whole thing on every change (wasteful) or writing ad-hoc diff logic per shape (brittle). I wanted a representation where the shape of the data made the diff fall out for free.

The trie, concretely

A goal in Life Towers is a path of strings. Health / Running / 5k. Tasks under a goal hang off the leaf. A user’s whole state is a tree, and a trie is exactly the data structure that makes that tree’s identity manipulable.

Two properties did the heavy lifting:

Structural sharing. When you tick off a task under Health / Running / 5k, the new root reuses every untouched subtree by reference. The Career branch and the Reading branch are the same objects they were before. Comparing the old and new roots is mostly pointer equality; only the path that actually changed gets walked.
Immutability. Updates produce new structure instead of mutating. “Where I was” and “where I am” become two pointers, not two snapshots. The diff between them is whatever’s not shared, and that walk is O(changes), not O(state).

The sync loop falls out:

Client holds the last root the server acknowledged plus its own current root.
To send: walk only the unshared paths, emit one op per changed leaf. In practice that’s a handful of bytes for a typical edit, no matter how large the rest of the tree is.
Server applies, returns its new root.
Client rebases any in-flight edits by replaying them on top.

There’s no conflict resolution layer because the operations commute on the structure. Two clients adding tasks under different branches produce non-overlapping deltas that compose trivially. The hard cases (two clients editing the same leaf) are tiny and obvious, because they’re the only place the deltas touch the same path.

What I’d change

Property tests around the rebase. The reconcile path is exactly where a generator finds bugs that hand-written tests never think to write. I had hand-written cases; I’d start with proptest now.
A standalone spec for the wire format. The part worth lifting out was the protocol, not the goal tracker. A short spec would let me (or anyone) reimplement it in a different stack without re-deriving everything from the Python source.
Strip the visual experiment. The tower visualisation was fun but it bound the storage to a UI metaphor. The sync model should be a library; the towers should be a separate toy.

If you take one idea from this

Most sync problems are diff problems pretending to be transport problems. Pick the data structure that makes the diff free, and the protocol almost writes itself. The corollary: if you’re writing a lot of “if this changed, send that” code, you’re using the wrong structure.

Two Graphs Are Simpler Than One: A Cooling System Simulator

Andras Schmelczer — Mon, 04 May 2026 00:00:00 GMT

Trying to solve flow and heat as a coupled system would have been a real CFD problem and I had two weeks. A cybersecurity event in late 2018 needed a cooling-system simulator that contestants could poke at through PLCs over a weekend, and the deadline shaped every decision after it: cheap to compute, plausible to a non-specialist, runs all weekend on one server. The useful design move was modelling flow and heat as two separate graph passes, not one combined PDE.

What the event needed

The challenge was about PLCs. Contestants would change setpoints, valves, or pump speeds, and we needed them to see whether their action made the plant stable, wasted coolant, or melted something. That meant:

Multiple monitoring clients had to update from one simulation server in near real time.
The system had to be configurable enough that the event organisers could ship me a new plant on Friday night and have it running Saturday morning.
It had to be obvious. A simulator nobody understands isn’t a teaching tool, it’s noise.

The split that made it cheap

Instead of the coupled solver:

Flow first, as graph traversal. Walk the pipe graph from the pumps, accumulate pressure, distribute water to nodes.
Heat second, as a linear system. Build the adjacency matrix from the flow result, add boundary conditions (heaters, exchangers, base temperatures), solve for node temperatures with NumPy.
Repeat both passes per tick.

This is wrong as physics. It’s right as a model. Flow doesn’t react to instantaneous heat in any way contestants could perceive, and the cost of solving them separately was a tiny fraction of solving them together. The clean phase boundary also meant when “the heat is weird,” I knew exactly which pass to look at.

Why the editor mattered

The simulator’s most-used UI was the input editor, a separate JavaFX tool where you laid out the plant, set parameters per element, and exported JSON the sim ate. I wrote up the editor’s own story here, because in hindsight it deserved to be its own project.

The lesson: a simulation is only as useful as its input pipeline. If editing the plant requires editing source, organisers won’t use it.

What I’d change

State what the model claims. A convincing sim needs an honest README about what it does and doesn’t model. Mine didn’t. Anyone who took the numbers seriously could have walked away believing more than the model deserved.
Recorded scenarios as regression tests. Sim projects drift in ways that look plausible on screen. Storing “this input over 60 seconds produces these outputs” would have caught me when I broke the temperature solver on Saturday morning at the event.
Skip JavaFX. Cross-platform packaging was painful and the desktop dependency made the editor harder to hand off than it should have been. A web-based editor in the same browser the monitors used would have meant one fewer install for the organisers.

Predicting EUR/USD With Hanning Windows

Andras Schmelczer — Sun, 03 May 2026 00:00:00 GMT

In the autumn of 2019 I was an undergrad with a few weekends free and the quiet conviction that I could find a small edge on EUR/USD. The screenshots were flattering: the prediction (blue) hugged the actual rate (green) in a way that looked like skill. A linear regression in the frequency domain, dressed up. I did not trade real money with it, and that restraint is the only thing about the project that aged well.

The pipeline:

Smooth the input series.
Differentiate.
Short-time Fourier transform with overlapped, Hanning-windowed frames.
Extrapolate the frequency-domain coefficients.
Invert everything back to a predicted price series.

A Python server (NumPy, SciPy, Flask) ran the model. An MQL4 client on a broker terminal called the server and would have placed trades if I’d dared.

What I actually learned: even a naive model can show a sometimes-profitable backtest, and that’s the trap. The real game is built by people with co-located servers, microsecond ticks, and millions in infrastructure. This project taught me how far my edge wasn’t.

My Notes: A Markdown App for Android

Andras Schmelczer — Sat, 02 May 2026 00:00:00 GMT

In November 2019 I wrote my own notes app for Android, used it daily for a while, and then it lost a long battle with Obsidian. The loss was the lesson: I learned what I actually wanted from a notes app by watching mine fail to be it. Years later that same itch is why I wrote reconcile-text; by then I was editing the same notes in Vim, VS Code, and Obsidian, and nothing existed to merge three independently-edited copies back into one.

The app itself was small: Markdown notes, hashtag filtering, Markwon for rendering. Every developer writes their own notes app eventually and the bar for shipping one isn’t high. What I actually wanted was a few weeks outside the web stack, somewhere with different conventions about lifecycle, storage, and resource constraints. Android delivered that. I’d still recommend “write a small thing on a new platform” as a way to recalibrate what you take for granted.

A Unity City Where Bad PLC Code Made Cars Crash

Andras Schmelczer — Fri, 01 May 2026 00:00:00 GMT

Most security challenges punish wrong answers with a red “incorrect.” This one punished them with car wrecks, and people learned faster. A PLC cybersecurity event in the summer of 2018 needed something visceral; I built a small Unity city where the traffic lights were driven by a REST API and contestants wrote the control logic.

All decisions ran on the server and got broadcast to clients. The harder problem wasn’t the simulation; it was making the broadcast fault-tolerant on conference Wi-Fi without flooding it. I built it solo, including the models and animations in Blender. Not a flex, just context for why everything’s a little janky.

There was also a HUD overlay for tweets. It felt clever at the time and dated horribly. Skip that part.

A Colour Grader Where Distance Was the Whole Idea

Andras Schmelczer — Thu, 30 Apr 2026 00:00:00 GMT

In June 2018 I got tired of every grader I tried making me think in masks. I wanted to point at “this orange” in a photo from one of my walks, nudge it, and have the neighbouring reds and yellows come along by however much made sense. Distance in colour space, not a brush. So I built the proof.

The UI was a colour wheel where you’d click to drop a marker, drag to move it, click anywhere to add another. Each marker had its own settings; transformations fell off smoothly with distance from the picked colour. No masks, ever.

I never built it into a real tool. The idea still feels right: distance in colour space is the natural unit for prose-style editing of an image. If I returned to it, I’d reach for WebGL instead of canvas. The interaction only earns its keep if the preview is live on a real photo, and canvas couldn’t get there.

Avoid

Andras Schmelczer — Wed, 29 Apr 2026 00:00:00 GMT

Keeping it here because pretending the older work didn’t happen would be dishonest. The first browser game I wrote, January 2018. It isn’t good, but it was the moment a <canvas> element stopped being mysterious.

A 3D Voxel Game in C, Built While Learning Pointers

Andras Schmelczer — Tue, 28 Apr 2026 00:00:00 GMT

Autumn 2017, Basics of Programming, a deadline that forced me to learn C the hard way. I’d write almost none of it the same way today, and I’d defend every choice in it anyway. A 3D voxel platformer in pure C with SDL 1.2. No engine, no scripting layer.

Maps were randomly generated and destructible voxel by voxel, so the player could dig their way out of trouble or wall off flying enemies that merged into larger ones as they got closer. Powerups let you shoot, or slow down time at the cost of points.

What I actually learned was pointers, painfully, through an adequate number of segfaults. The course was meant to teach the basics of programming; for me it was the moment programming stopped feeling like a list of facts and started feeling like a thing I could build with. The next time I reached for C it was on hardware that punished waste; see Ad Astra.

First-project privilege.

A Photo Site That Generated Itself From a Folder

Andras Schmelczer — Mon, 27 Apr 2026 00:00:00 GMT

I take walks with a camera. Most of what I shoot isn’t good, but the act of walking slowly with a frame to think about is the most reliable way I know to come back with an idea for whatever I’m working on. In the summer of 2016 I wanted somewhere to put the few frames that survived, and I wasn’t going to maintain a CMS for it.

So a Webpack script: point it at a directory of full-size photos, get a static site with responsive variants per image. Drop in a new photo, run the build, deploy. The pipeline mattered less than making the habit visible. The same habit later produced a colour grader for the same shots.

If I rebuilt it today I’d use Astro, which is what this site runs on.

My First Real Project: LEDs Driven by an FFT

Andras Schmelczer — Sun, 26 Apr 2026 00:00:00 GMT

Spring 2016. I had a Raspberry Pi, a couple of 12V RGB LED strips someone had given me, a handful of MOSFETs from an electronics kit, and zero idea what I was doing. I wired one of the MOSFETs backwards and it got hot enough to leave a small mark on the breadboard. I learned to read a datasheet, slowly, by needing one. This was the first thing I started and actually finished.

The plan was something like: play music, look at it, make the lights match. I got bands wrong first. Mapping raw audio amplitude to brightness made the lights pulse with anything (clipping, voice, fan noise), a strobing mess that hurt to look at. Reading about Fourier transforms long enough to type numpy.fft.fft(audio_chunk) into a REPL was the moment the project started actually behaving like the thing I’d imagined. Bass-heavy frequency bins went to red; mids to green; highs to blue. Smoothing the output over a few frames stopped the seizure-inducing flicker.

The frontend was a vanilla web page on the same Pi: pick a track, tweak the band thresholds, see what changed. No framework. Just a <select>, a few sliders, and an XMLHttpRequest. It worked.

It’s not impressive in 2026. The thing I actually keep from it isn’t the FFT or the MOSFETs; it’s the discovery that I’d rather have a finished janky thing than an elegant unfinished one. Most of the projects on this site are downstream of that discovery; the ATtiny85 handheld four years later is the same instinct with the soldering iron held steadier. I’d still recommend the same path to anyone learning: pick something physical, plug things together until they work, accept that the first version will be ugly.

A JavaFX Editor for the Cooling Simulator

Andras Schmelczer — Sat, 25 Apr 2026 00:00:00 GMT

Non-technical event organisers needed to rewire a cooling plant in real time without me hovering. That was the brief, and it ruled out every interface I’d have enjoyed writing. The cooling system sim was only as useful as the tool that fed it, so in late 2018 I built a JavaFX desktop editor: lay out the plant as a graph, edit each element’s parameters in a side panel, export JSON, or upload straight to the backend.

Small tool, and the whole event hinged on it. If I built it again I’d skip JavaFX and put the editor in the browser next to the monitoring clients. One install fewer for everyone, and one fewer reason for someone to call me over.