AI Projects

A self-contained audio-visual toy: the music is synthesized live in your browser with the Web Audio API — there is no audio file. An FFT analyser reads that sound in real time and drives every pixel of the cat.

• Synthesized live — an upbeat four-on-the-floor groove generated entirely in code with the Web Audio API; there is no audio file, every kick, bass note, and melody is produced at playback.
• Warps & morphs to the beat — an SVG turbulence + displacement filter liquifies the cat, distorting harder on every kick.
• Reactive everything — pulsing glow ring, spinning color field, and beat-driven hue shifts, all tied to the live mix.
• Zero assets — no audio or video files; the sound and motion are 100% code.

▶

Tap play — the cat pulses to a live, generative beat synthesized in your browser.

Open the full experience →

A hand-built gallery with two sections — Found Art (a large collection of sourced and discovered imagery) and My Photoshops (original edits made with photo manipulation tools). Any piece opens into a full-screen lightbox with keyboard navigation.

*grid thumbnails are embedded as base64 and streamed in lazy chunks — the grid paints instantly with no per-thumbnail round-trips.

How images are added

• Processed locally — source images are converted to WebP, resized, and stripped of all metadata before anything leaves the machine.
• Encrypted upload — images are pushed to the server over a TLS 1.3 connection; the password is stored encrypted at rest and decrypted only in memory at upload time.
• Base64 thumbnails — a small preview of each image is embedded directly into JSON chunk files; full-resolution images are only fetched when a piece is opened.
• Live updates — single images can be added or removed without reprocessing the whole collection; the chunk index updates and syncs to the server in one step.

An in-browser generator that pulls a random piece from the gallery and weaves it into a seamless, symmetric tapestry — then lets you grade it into something properly psychedelic and download it.

• Kaleidoscopic symmetry — 4-, 6-, 8-, or 12-fold mirrored wedges, tiled with mirrored neighbours so the weave is seamless.
• Live colour grade — hue, vibrance, and a shimmer mode push it into psychedelic territory.
• Sourced from the gallery — every generate draws a new piece; the whole thing runs in your browser.
• Download — export your tapestry as a high-res PNG.

A quiet, full-screen ambient experience — click to enter and let it drift. The soundscape is synthesized live in your browser, with no audio file.

• Live ambient audio — slow oscillators and an LFO generate an evolving drone entirely in code.
• Animated canvas — a soft, breathing visual field rendered frame by frame.
• Drifting quotes — fragments fade in and out as you sit with it.
• Zero assets — sound and motion are 100% code.

A Python script that pushes every changed file from the local folder to the live site over an encrypted TLS 1.3 connection. One command, no manual steps.

Private chat rooms where every message is encrypted in your browser before it ever touches the network. The server only ever stores ciphertext — it cannot read a single word.

• AES-256-GCM end-to-end — the key is derived in your browser from the room name and an optional passphrase; the server never sees it.
• No accounts, no IP logging — pick a handle and go; nothing identifying is stored.
• Room names are hashed — the backend stores a one-way hash, never the plaintext room name.
• Ephemeral — messages auto-expire, and a key fingerprint lets both sides verify they share the same key.

Drop a file, get a link. The file is encrypted in your browser first; the decryption key lives only in the link's # fragment and is never sent to the server. The server stores nothing but opaque ciphertext.

• Zero-knowledge — filename, type, and contents are all encrypted client-side; the server can't read any of it.
• Up to 300 MB — uploads are chunked so large files transfer reliably.
• Self-deletes in 24h — every drop expires automatically; nothing lingers.
• Hardened — unguessable links, size and download caps, and stored blobs are never executed or served inline.

Paste text or code, get a link. It’s encrypted in your browser first; the key lives only in the link’s # fragment and never reaches the server, which stores nothing but ciphertext.

• Zero-knowledge — AES-256-GCM in the browser; the server can’t read the paste.
• Burn after reading — optionally destroy the paste the moment it’s first opened.
• Expires in 24h — everything self-deletes automatically.
• Shared hardened backend — same unguessable-ID, capped, never-executed storage as the file drop.

Get a random throwaway email address, use it to sign up for anything, and let it vanish. No account, no personal info — and the whole address self-deletes after a day.

• Anonymous — no signup, no IP logging; a fresh random address on demand, with a QR code for mobile.
• Self-destructs — pick a 1h, 6h, or 24h lifetime, or burn the inbox instantly; the address and its mail are then purged.
• Anti-tracking — messages are shown as plain text with remote images and scripts stripped, so tracking pixels can’t fire.
• Optional PGP — generate an ephemeral key in your browser; mail a sender encrypts to it is end-to-end encrypted, decrypted only in your browser.
• Honest scope — receive-only; plain email isn’t end-to-end encrypted (inbound SMTP is plaintext), so without PGP it isn’t zero-knowledge like the chat and file drop.

A privacy-first message board where you post without ever making an account. Pick a handle, or don't — either way nothing identifying is kept. It comes in two flavours: public boards anyone can read, and encrypted boards only you and your passphrase can open.

• No accounts, no IP logging — you just start typing; nothing that points back to you gets stored.
• Optional tripcodes — add a secret to your handle (name#secret) to prove a post is really you across visits, still with no account behind it.
• IP-free rate limiting — abuse throttling uses one-way HMAC buckets that store no IP address, so speed limits work without a log of who you are.
• Public boards — posts are plaintext and moderated by a server-side word filter; these are the ones listed on the front page.
• Encrypted boards are zero-knowledge — the board id and key are derived in your browser from a board name plus a passphrase; the server only ever holds ciphertext and can't read or moderate them.

Drop in a file to compute its SHA-256, SHA-512, and SHA-1 and check it against an expected value — handy for confirming a download wasn’t tampered with.

• Runs entirely in your browser — Web Crypto hashing, nothing is uploaded.
• Provably offline — the page ships a connect-src 'none' policy, so it physically cannot make a network request.
• Instant compare — paste an expected hash and get a match / no-match verdict against any of the three algorithms.

Found a hole in one of these dens? A coordinated disclosure page where you write up the bug and it is encrypted in your browser to a key only the operator holds — then you email the ciphertext. Nobody in between can read a word of it.

• PGP-encrypted in your browser — the report is sealed client-side with OpenPGP to the operator's public key; the plaintext never leaves your device.
• RSA-4096 disclosure key — reports are encrypted to a 4096-bit public key that only the operator's private key can open.
• Report body is end-to-end encrypted — you email ciphertext, so even though email transport isn't private, the contents are only ever readable by the operator.
• Auto-discovered public key — the browser pulls the operator's key from the standardized /.well-known/ location; you can also paste one in yourself.
• Operator tools stay local — the built-in keypair generator and report decryptor run entirely in-browser; the private key and its passphrase never leave the page.

A compact Windows 11 desktop widget that follows whatever is playing in the TIDAL desktop app and shows line-synchronized lyrics — the previous, current, and next line drifting past in time with the song. It is built in C# on .NET 10 (WPF), reads the now-playing track through Windows' own media controls, and pulls timed lyrics from the community LRCLIB database. It runs entirely on your own machine.

• Reads the song, not your files — title, artist, playback position, and album art come from Windows' Global System Media Transport Controls; the widget extrapolates the playhead while music plays and re-anchors whenever the timeline jumps.
• Whole-window kinetic themes — the lyric style switches the entire surface at once (typography, tint, border, album frame, glow, and particle palette), backed by optional particle fields and a low-key etched PANDACAT header mark.
• Honest audio reactivity — the visualizer moves to a single normalized loudness value read only from TIDAL's own audio session; it carries no frequency bands and never claims to measure bass, and it keeps a calm resting shape during real silence instead of inventing energy.
• A cat lives here — a dependency-free, green-eyed vector cat walks the widget's edge and, if you let it, goes on occasional desktop adventures: chasing a butterfly across a cloud, hitching a ride on a little biplane, or being caught by a portal when you fling the window around.
• Considerate by default — it honors Windows reduced-motion and High Contrast, settling into a static pose and stripping decoration; the cat and text scale to taste, and every choice is remembered between launches.

A Windows desktop gallery for presenting a folder of artwork as a fluid, music-responsive slideshow. Point it at a directory — subfolders included — and the current image becomes a continuously moving canvas: pixels flow, color channels bloom, the frame breathes and drifts, and musical ripples travel through the composition. It targets a smooth 60 FPS and can sit in a compact snap-friendly window or expand into a full-screen visual installation.

• Motion with a real visual vocabulary — five live controls separate liquid flow, animation tempo, color travel, musical pulse, and whole-picture drift. Mellow, Dreamy, and Expressive presets make the range approachable, while Custom mode exposes the full shader without turning ordinary settings into a strobe.
• Mapped to the song — when TIDAL is playing, the app estimates tempo and follows verified playback energy, onsets, sustained passages, and song position. It gradually builds a local per-song motion map, then reuses that beat grid after a seek or on a later listen while continuing to refine sections it has actually heard.
• True-color text art — an optional Chafa-inspired mode reconstructs each picture from real ASCII glyph shapes with independent foreground and background colors, then sends that textual image through the same warping, crossfade, hue, and music-motion pipeline. The fixed-width grid can be copied raw or wrapped for Markdown.
• A gallery, not a format fight — it walks nested folders and accepts AVIF, BMP, GIF, HEIC/HEIF, JPEG, PNG, TIFF, and WebP whenever the matching Windows codec is installed. Previous, next, pause, motion, ASCII, and fullscreen controls stay deliberately compact so the artwork keeps the room.
• Panda Lyrics built into the frame — a dedicated lower strip shows Windows-provided album art, track and artist, the emphasized current lyric, the next lyric, BPM, mapping progress, and the same restrained TIDAL pulse used by the standalone widget.

A ground-up, open-source reimplementation of the Ultima 8: Pagan game engine in Rust — in the spirit of OpenMW and Exult. Modern rendering, widescreen, a smooth framerate; the original world, story, and mechanics. It ships no game assets whatsoever — it reads the data from your own legally-owned copy and extracts everything locally.

• Bring your own copy — the engine parses the original files from your install; generated art and audio land in a gitignored folder that is never committed or shared.
• Hand-written parsers, no unsafe — the file-format decoders are pure safe Rust, so a whole class of memory-corruption bugs simply cannot happen.
• Hardened against hostile data — parsers return errors instead of crashing, with fuzz-style tests proving they never panic on malformed or garbage input.
• Clean-room lineage — the formats were documented from public open-source references, then reimplemented from those specs and released under the GPL.
• In active development — the extraction toolchain and art pipeline are done and verified; world rendering is the next milestone. Not yet a playable game — but the engine is being built in the open.

A ground-up, open-source engine reimplementation of Crusader: No Remorse (Origin Systems, 1995), written in Rust. Same idea as OpenMW, Exult, and devilutionX: a brand-new engine that reads the original game's data from your own legally-owned copy. This one is early — in active development, so it's more workshop than playground right now.

• Ships zero game assets — the repository is original code only; you bring your own copy, and everything the tools extract stays in a local, git-ignored folder.
• Hardened data parsers — the format readers use no unsafe Rust and are built to never panic on malformed or corrupted input, with fuzz-style robustness tests.
• Clean-room lineage — file formats are documented from a study of an open-source reference engine plus real game files; the Rust code is written from those specs, then adversarially re-verified claim by claim.
• The goal — the original missions, story, and mechanics preserved exactly, with modernized presentation and an optional modern control scheme layered on top of a faithful classic mode.

Where it is right now

The toolchain and asset-extraction pipeline are working — a full-corpus extraction run completed with zero decode errors. The Bevy-based asset viewer is the next milestone and the gate out of the current phase. Rendering, controls, and the game simulation itself are still ahead on the roadmap — no promises the cat can't keep.

A local, offline vault for Windows and Linux that keeps two things in one application: a password manager — usernames, passwords, passphrase generation, secure notes, and live TOTP codes — and an encrypted data vault for images, video, and arbitrary files. The whole store is a single portable encrypted file you control: no account, no cloud, no telemetry, no network client. It is written in Rust and is pre-release — a workshop project under active security-debugging, not something to trust with real secrets yet.

• Established crypto, not hand-rolled — Argon2id key derivation and XChaCha20-Poly1305 authenticated encryption from the vetted RustCrypto and dalek libraries, with the entire vault header authenticated so a parameter-downgrade attempt simply fails to decrypt.
• Layered unlock — the master password can be combined with an optional keyfile and an optional hybrid X25519 + ML-KEM-1024 identity file, mixing a classical and a post-quantum secret so the extra factor rests on neither alone.
• Every imported file is treated as hostile — images, archives, and video are decoded in disposable, out-of-process workers that hold no vault keys, over a framed protocol with strict size and geometry bounds, parent-side revalidation, and watchdogs that kill anything that stalls.
• Media stays sealed — each file lives in its own chunked, streaming-encrypted sidecar under a unique per-file key, and supported media is viewed straight from RAM without ever landing in the clear on disk.
• Panic and auto-lock — a panic hotkey locks the vault, zeroizes keys, and clears the clipboard; a dead-man timer locks on idle, session-lock, or suspend; and root secrets sit in guarded, page-locked memory that wipes on drop.
• Tamper-evident history — a keyed hash-chain audit log anchored inside the encrypted vault, with a forward-secure per-entry ratchet, so committed history cannot be silently rewritten or rolled back.

Where it is right now

The cryptography, vault format, memory hardening, and out-of-process decoding all work today, with a large adversarial test suite proving that malformed vaults and hostile files fail closed. A release is deliberately gated on moving every untrusted parser into fresh, hardware-isolated sandboxes on both platforms — that pipeline is designed but not built yet — so this is shared as serious work in progress, not a finished product.

A research and design effort — not a shipping product yet. PandaSOS is a Rust security substrate that would sit between applications and the operating system, deciding what an app is allowed to do from capability-based policy, enforcing that at the OS boundary, and leaving tamper-evident evidence of every decision. Right now it exists as an architecture and a formal specification; no implementation has shipped.

• Design stage, stated plainly — the specification is written and the crate layout is planned, but essentially the whole system is still conceptual; there is no running code yet.
• Rides on your existing OS — it is deliberately not a new kernel, hypervisor, antivirus, or blockchain. It is meant to mediate execution on top of Linux and Windows rather than replace them.
• Capabilities, not ambient trust — the design binds each capability to the hardware page table, so a permission is enforced by the MMU and privilege escalation would require compromising the kernel itself.
• A tiny trusted core — a framekernel discipline is designed to confine all unsafe Rust to a single small kernel crate, leaving every other crate as ordinary safe Rust and shrinking the trusted computing base.
• Built to be proven, not just tested — the goal is machine-checked correctness: a formal state machine, capability rules, and a breach-probability bound expressed as proof obligations for tools like TLA+ and Verus.

An honest snapshot: this is the ambitious end of the workshop — a substrate we are still designing and reasoning about, shared here as work in progress rather than something you can run today.

Every page is hand-written and ships as static files — no build framework, no analytics, no tracking, and zero third-party requests: even the fonts are self-hosted, so the whole site loads only from its own origin. The interactive tools (chat, file drop) are backed by small, hardened, same-origin endpoints that only ever see encrypted data.

*on the homepage all artwork is embedded inline as base64, so the page itself makes no extra image requests.

Security hardening

Under the hood

• The ambient music is synthesized live with the Web Audio API and the visuals are audio-reactive — no audio files; sound and motion are pure code.
• The interactive tools all run in the browser: the tapestry and dark room are fully client-side, the gallery streams its (public) art on demand, and the chat and file drop are end-to-end encrypted — their backends only ever store ciphertext.
• Mobile visitors get a separate, hand-tuned layout.
• Deploys run over an encrypted TLS 1.3 connection, publishing only obfuscated, content-hashed output.