Pet Projects & Experiments

Two interchangeable detectors sit behind one interface: a classic OpenCV pipeline (adaptive threshold or Canny → morphology → findContours, then shape classification by circularity, fill ratio, aspect and corner angles) and Segment Anything. Detected regions are arranged into a containment tree, and only then does the LLM get involved — for OCR, connections and styles, with its answers cached.

It recognizes rectangles, circles, ellipses, diamonds, triangles, cylinders (database icons) and arrows, along with labels, styles and background colors. Still a work in progress: neither of the diagrams in the post below was touched up before publishing.

Sourcing is one of those areas where everyone has an opinion and nobody has numbers. osbench generates a world and an order stream from a config, replays it against eleven sourcing and five replenishment policies under identical random draws, and reports paired confidence intervals rather than single runs.

It also models the things that make sourcing hard in practice: four delivery-promise methods with customer acceptance, three kinds of shortage (substitution, re-sourcing, backorder), deferred sourcing, and ATP in both basic and cumulative flavors with tolerance. There is a live web dashboard with a map and per-warehouse drill-down, a visual config studio, weight tuning, parameter sweeps and offline HTML reports. Everything model-relevant is config-driven.

Five courses, from single notes through intervals and triads to inversions, seventh chords, melodic interval chains and chord progressions. The key, the mode (major, natural and harmonic minor, or no key at all), the range in semitones and the harmonic level are all adjustable, and there is an adaptive mode that keeps track of what you keep getting wrong and comes back to it.

The task can be played through a connected MIDI instrument or through the browser's own synthesis; answers come back over Web MIDI. Progress is kept in the browser, per key and mode. The interface itself is in Russian.

The second take on openai-hotkey, and mostly a study in doing the keyboard plumbing properly. Hotkeys go through Carbon's RegisterEventHotKey rather than a global event tap, so macOS can't silently time it out and disable it. It waits for the modifiers to be released before sending ⌘C from a private event source, waits for the pasteboard to actually change instead of sleeping a fixed interval, and restores your previous clipboard contents afterwards.

Three recognition engines, all running locally on CPU with int8: faster-whisper large-v3-turbo for any language, GigaAM v3 for Russian (about 20× faster than Whisper), and Parakeet TDT v3 for mixed Russian/English. Silero VAD means only speech is recognized, and timestamps come from the audio itself, so they stay correct even when recognition falls behind. Speaker diarization is optional and can be recomputed later without re-recording.

Audio comes from the microphone or from a single app — Teams, Zoom, Meet in a browser — alone or together with the mic as [Them] / [Me] lines, via Core Audio process taps on macOS and WASAPI process loopback on Windows. Screenshots are captured on a hotkey or automatically, classified, and placed inline. The "beautify" pass, which turns the raw transcript into a document with speakers, sections and slides, is the only step that can use a remote LLM — and you choose which.

Packaged as a desktop app for macOS and Windows with Python, ffmpeg and the helpers inside; models download on first use and then it works offline.

The camera rarely sees the whole canvas, so the tool computes a homography between the image and the canvas plane in millimeters, which is enough to both rectify what the camera sees and to project a reference onto it. Two printed targets are supported: six 63 mm squares on a single A4 sheet in the corner of the canvas, or a one-inch ArUco grid covering the canvas, where any two or three cells in frame are enough and the markers identify themselves — so the camera can come as close as you like.

The second half is for an easel with a real projector: one tool measures where the projector's pixels land on the canvas, using the calibrated camera as the instrument, and another throws a reference onto the canvas pre-distorted so that it lands square whatever angle the projector sits at.

Written up as a paper with Joeran Beel (University of Siegen). Seed generation provably produces no false negatives, and output equivalence with exact baselines was confirmed on every Gutenberg-8k subset where any baseline finishes at all. On the Gutenberg-BookCorpus-Cleaned corpus — up to 3.07 billion tokens — it runs 11–15× faster than FHK with up to 2× lower peak memory, and it was the only algorithm in the evaluation to complete at 50,000 documents within a 40 GB heap.

The repository carries the paper, a Java benchmark framework with all the competing algorithms, and a C++ prototype.

You write in a rich editor — prose, math, images, embedded PDFs with annotations, clipped web pages. An inbox takes things in from outside, search finds whatever got orphaned, and a handful of LLM plugins do the jobs that are tedious by hand: structuring a raw transcript into linked sections, collecting a whole subtree into one document, translating a page while leaving its formulas and layout intact.

It started as a SaaS storing documents only in Turso. It now also writes to local SQLite, a folder on disk, a GitHub repository or a Google Drive folder — and synchronizes between any two of them three-way: what A has, what B has, and what the two last agreed on, so "these differ" becomes "this one changed" without consulting a clock on someone else's machine. Pairings are bidirectional by default, can be scoped to a page and everything it reaches (assets included, found by reading ids out of the content), and offer a dry run that decides everything and changes nothing. Conflicts keep both sides as a conflicted copy rather than merging or dropping; deletions leave tombstones, so a page that merely vanished can't wipe the other side's copy.

Desktop builds for macOS, Windows and Linux, and it works from a mobile browser. Invite-only, both the service and the source.

The idea is to keep the reader in flow: you glance at the next four or five definitions, they sit in short-term memory, and then you read the actual sentence and recognize the word instead of stopping. Entries are graded into three difficulty levels, and the whole thing runs to 600–700 pages depending on the language — about twice the length of the novel.

The definitions aren't generic dictionary entries; they take into account how Nabokov himself rendered the passage when he translated the book into Russian. Getting that required a custom sentence aligner, since the off-the-shelf ones weren't accurate enough: recursive anchoring, where the longest sentences are embedded with multilingual-e5 and matched by cosine similarity to become anchors, and the segments between anchors are then aligned the same way. It handles sentences that were split, merged or dropped in translation. Both language versions of each sentence go to the LLM, so the author's own choices ground the definition.

The games are picked out of 800,000 by taking only decisive results and sorting by rating gap, on the theory that a wide gap means a more decisive win — a crude proxy, but better than none. That leaves 20,000 games and 534,453 positions. The weaker side's moves are dropped during training rather than beforehand: if it is White to move and White won, the position is learned; if the side to move went on to lose, it is skipped. The network takes a board and emits 4096 values, one per from-square/to-square pair.

Selecting the games takes about five minutes and training about ten, so the obvious next step is simply more games. It is not strong, but it gets through the opening without embarrassing itself — which was the whole point of the exercise.

The whole thing rests on one assumption: people reply to messages that are close behind them, and a message several people reply to was probably worth asking. So the tool cuts a window starting at a message with at least three replies and ending at the last message in its reply chain, then summarizes that window into a Q&A pair. Windows overlap freely — someone asking a new question while others are still answering the previous one produces two of them, nested.

Dividing an image into 10×10 blocks costs you a factor of ten in resolution, so each channel is drawn in several passes with different cell sizes on shifted grids — large cells first, then finer ones offset by ten pixels, then finer still offset diagonally. Color goes through CMYK separation as in printing: each channel gets its own grid and its own lines, and the plates are then laid over each other with transparency.

The whole run is driven by a JSON config, with separate parameters per channel and per pass within a channel. It only really works large — at phone size the lines merge into gray.

The part I am most pleased with is the contextual recommendation system. Where a paragraph mentions Drools, a link to the related article appears right next to it, with a note on why it is relevant there specifically — as a margin note on desktop and an inline callout on mobile. Articles come in English, Russian and Ukrainian from the same source, and the build also produces this page, the per-vacancy CVs and the search index.

Relevance work on Coveo keeps running into the same wall: the ranking information is right there in the response, as a semi-structured text blob nobody wants to parse by hand. The extension picks up valid authentication tokens and headers from ordinary user activity, replays the request with debug=true and debugRankingInformation=true, and hands you a table you can open in Excel or pandas.

It hooks both window.fetch and XMLHttpRequest (still widely used by Sitecore/Coveo integrations) and rewrites the POST body immediately before the request goes out, targeting only the /coveo/rest/search/v2 endpoint so nothing else on the page is disturbed. Overrides apply to the next request, with no page reload.

Text is paginated on sentence and paragraph boundaries, so no fragment is cut mid-thought. Tokenization is dictionary-driven and greedy: if the dictionary has "web application", it wins over the two separate words. Reading position is kept per file via an MD5 of its contents, so a session resumes exactly where it stopped.

The plot deliberately extends beyond the training range, so you can watch each model's behavior fall apart outside the data it saw. The part I built it for is the neural decomposition view: the individual basis functions each hidden neuron contributes, and how they sum into the final prediction.

It is deliberately built for small datasets. It will run on larger ones, but the visualizations get less informative and some algorithms need more data than an interactive session can reasonably hold — this was never meant to be a full-scale benchmark, it is a teaching instrument.

The problem it exists for: you have a production search and a hypothesis about improving it, and no way to tell whether the change quietly broke something else. The platform computes NDCG@k, MAP, precision, recall and a couple of dozen other metrics, with statistical significance rather than single runs, and only at the very end uses an LLM — to explain the numbers, not to produce them.

It also works as a virtual assessor, grading how well each result matches its query, which for long documents means chunking, embeddings and per-chunk evaluation. Around it grew several smaller pieces: context-aware autocomplete from a locally trained model ("Tyson Foods stock" suggests price, "Tyson Foods chicken stock" suggests recipe), and an agent that is given a site and a goal in plain language, writes its own queries, judges the results against the original intent, and can carry the session through to checkout — which makes both ground-truth data and realistic session data to train recommenders on.

Ten sites shared one search index and sent it ten different versions of the same inscrutable expression — template ids and page ids to include or exclude, ten open parentheses and a few closing ones placed seemingly at random, with deeply nested conditions where "exclude this template" applies only when some other field equals one. Reformatting it did not help; reading it by hand helped less.

Simplification discards duplicates, collapses nesting and drops conditions logically absorbed by others, which flattens the trees into something readable. To prove nothing was lost, a generator reassembles the simplified logic into a working request and checks that the document count matches the original. From there a comparison matrix shows the common core — conditions guaranteed to hold for every document that passes — against the per-site tails.

It began as a nostalgic afternoon in the archives and turned into a decent excuse to build a hybrid retrieval stack end to end on material that fights back: century-old scans, period typography, and illustrations that matter as much as the text.

A new post triggers the whole chain: translate it, process the attached images and describe them, derive a title and tags from the text plus those descriptions, write the record to Turso, build embeddings, index them in Qdrant, upload the images through the WordPress API and publish both language versions. The 2024 article below documents the original migration; the pipeline was rebuilt in 2026 around the cloud databases.

Two use cases it was built for. First, pulling specific files off a remote system you only have SSH to: take a snapshot, pick the files in the UI, get a .sh script that produces a tar.gz with exactly those. Second, two people debugging the same system and suspecting their environments differ — each takes a snapshot, the tool shows what diverges, and generates the script to close the gap.

The hardware was an easel, a walking stick and a quantity of tape, which is roughly the right level of engineering for a first run. OpenCV and PIL handle the board detection and square extraction; the network does piece recognition per square, and diffing two consecutive readings gives the move.