Things written down, as they happen.

A macOS app that learns your folder structure and automatically sorts incoming PDFs using a Naive Bayes classifier and OCR.

A webhook-driven Vapor server that listens for new Strava activities, automatically marks bike commutes, and generates descriptive activity names using GPT-4o mini.

Galaxus’ write-up of their annual Hackfest — 200 people, 26 teams, 54 hours from raw idea to stage. My team built Galaxus Snap: scan a barcode in a brick-and-mortar shop, or just photograph the sneakers a stranger is wearing, and the product opens in the app ready to order. We demoed live, won the Audience Prize, and a founder said he’d wanted it for years and to ship it tomorrow. We did the right thing for hackathon code and didn’t — though a barcode scanner did land in a later release, well after I’d moved on.

The most interesting code in a hybrid app lives at the seams. Inside the running app you can pretend the native shell and the embedded WKWebView are one thing — until a URL arrives from outside (a push, a shared link, a search result) and something has to translate a flat web URL into a native navigation decision. A .de link reaching a Swiss user who just wants the product; a checkout URL that should land on the cart tab, not a freshly-loaded checkout; a destination that may no longer exist on our servers. Six edge cases in, you have a system. Pure-native apps never treat URLs as first-class input, and pure-web apps have no native tabs to route into — hybrid apps have both, and the seam is where the trade-offs turn into real work you don’t appreciate until you’ve done it.

A quiet observability bug in hybrid apps: the native shell and the embedded WKWebView each track their own analytics session, so one user doing one thing shows up as two unrelated sessions, and every funnel breaks at the boundary. The fix is architectural, not clever — pick one side to own the session, have the other adopt it. Which side wins depends on the codebase and doesn’t matter to the pattern; what matters is one source of truth. After that it’s just bookkeeping: keeping the two in sync across session rotations, cold starts, and one side restarting while the other is still alive.

Apple's privacy-aware attribution API replaces IDFA. Getting it right is mostly about the discipline around the call: defer until online, retry with backoff, fire exactly once.

A small CLI turned Figma color tokens into an Xcode asset catalogue, and the iOS app used them by name. Dark mode arrived for almost free.

On a hybrid app where most of the product was web, the web teams had a tight loop — open a PR, click the preview URL, see the change in the browser in minutes. For anything touching the mobile experience that loop broke: testing meant finding someone with a Mac, an Xcode signing setup, and time, and that someone was always an iOS engineer. We closed the loop with a thin pipeline. Each web PR injects its preview URL into the test target’s Info.plist with a single PlistBuddy call, builds a signed .ipa, uploads it to BrowserStack, and posts back a link that opens the app on a real device showing that PR’s changes. The infrastructure was a little YAML and a plist trick; the real win was cultural — web engineers stopped treating the app as a black box and started catching mobile regressions in their own PRs.

Users kept getting logged out of a hybrid iOS app I worked on. The fix was collapsing six independent stores of auth state into a single observable source of truth.

Combine's `CurrentValueSubject` is the obvious tool for shared observable state. It also lets every observer mutate that state. A small read-only wrapper fixes it.

iOS's default localization assumes the device language is the right answer. For apps that ship across multiple regions with user override, it isn't.

How to keep a hybrid iOS app and its embedded WebView from drifting: a single contract upstream of either platform, generated into Swift and TypeScript bindings.

Finished App Architecture by the objc.io team. The patterns hold up — MVC, view models, and the testing discipline around them — and the real-world case studies are the reason to read it over a blog post. The caveat: it predates SwiftUI and Combine, so everything is UIKit and storyboards, and applying any of it to an existing codebase is far harder than the clean-slate examples suggest. Refactoring into an architecture takes time and a real grasp of the code you already have. Still the book I’d hand a beginner who wants to structure an app properly.

AR web app for viewing restaurant dishes in 3D, built with Next.js and Apple's Object Capture API.

Azure-based cloud-native app replacing analogue doorbells in stores using BLE beacons and an iOS companion app.

Kotlin-based multiplayer Pong for Android using sockets, gyroscope controls, and QR code game joining.

Electron-based document sorting app using a Bayesian Classifier and OCR for automatic PDF organization.

Full-stack JavaScript multiplayer Jump & Run game using Node.js, Phaser, Socket.IO, and Matter.js.

Solving a graph optimization challenge by PostFinance using Dijkstra's, the Travelling Salesman Problem, and Floyd-Warshall algorithms.

Cross-platform packing list app built with Xamarin.Forms, featuring tinder-like activity swiping and destination info.

AI agent for the 2048 game using heuristics and expectimax search, achieving a high score of 146,348.

Java-based round-based racing game with smart track detection from images and multiplayer support.