Screen & Demo Tools

A deep dive into the local-first architecture, encrypted collaboration, and canvas performance tricks that make Excalidraw feel simple on the surface and unusually careful underneath.

A deep look at how tldraw turns React, the DOM, multiplayer sync, and AI-friendly tooling into a canvas engine for building spatial software.

It does not edit the app. It talks to it, measures the art, and adapts the interface in real time.

Moving past rigid templates to AI-orchestrated, zero-dependency editorial design.

A deep dive into the fountain-coded QR system that moves files across an air gap with no network, no cable, and no native app.

A tiny Canvas 2D engine turns AI status into semantic motion, with states for searching, solving, composing, and more.

How a developer used zero dependencies, Vanilla JavaScript, and pure spite to clone a mechanical split-flap display for any browser.

A physics-first bamboo cicada built to run offline, survive dependency rot, and recreate the feel of a folk object through motion, audio, and procedural form.

An open-source runtime that turns prerendered motion into deterministic, seekless interaction without giving up visual fidelity.

A React dashboard turns arrival windows, route playback, meal logistics, and trip readiness into an ops-style interface that makes group travel feel like a live system.

A Windows-native visibility layer for Claude Code that turns browser automation, shell activity, and agent state into one supervised desktop.

How the web's most rigorous terminal documentation uses Nix, MDX, and custom AST transformations to turn dry escape sequences into an interactive technical manual.

A look at the open-source pixel art editor that pairs a fast local canvas with an MCP server, turning sprite work into a structured, editable pipeline instead of a flat image dump.

A Chrome extension, a local server, and a SQLite state machine work together to turn the New Tab page into a control surface for open tabs, tab groups, and instant cleanup.

SoraMarker turns a meme into a browser-native video pipeline, then makes the logo move so the effect feels alive instead of pasted on.

How a minimalist Go service leverages HTTP and ANSI escape codes to deliver instant, terminal-native QR codes without a single local dependency.

A look at how callback injection, async pauses, and generator-based stepping let one small app teach sorting, search, and pathfinding without burying the logic in UI code.

A deep dive into the timing loop, manual DOM updates, and design discipline behind a screen that feels mechanical, not decorative.

Inside `ljg-card`, raw text is parsed for meaning first, assigned visual weight next, and rendered into polished PNG cards with headless-browser typography.

A surgical BepInEx mod that forces higher internal resolution, unlocks rendering options, adds a free camera, and shows how much a fix mod can do with a handful of targeted hooks.

A tiny no-build canvas app shows how far you can get with WebRTC, a shared peer ID, and a deliberate refusal to build a server.

A minimal Claude Code skill that turns raw notes into polished PNG infographics by making the model choose structure, theme, and hierarchy before the browser renders anything.

By rendering to a single hidden framebuffer and transferring pixels to standard 2D canvases, Chenglou's zero-dependency playground bypasses a hard browser constraint.

A tiny API route and a polling loader turn a plain Next.js site into a live host for an external script.

How a strict Markdown spec and a zero-dependency architecture turned an AI coding session into a masterclass in procedural generation.

How a React 19 visual laboratory replaces the static README to prove the safety of a cancel-correct Rust runtime.

A high-fidelity retro desktop, built as a portfolio template, where the real invention is not nostalgia but the orchestration of windows, state, and user attention.

A small BepInEx plugin that unlocks frame rate, internal resolution, anti-aliasing, and camera controls by patching Unity at runtime.

A noir-styled map and graph app for tracing spatio-temporal links across people, institutions, and status states, built to work cleanly even when the network does not.

A small Next.js experiment that turns parallax, masking, and particle recycling into a convincing illusion of depth.

A conversational editor that turns raw markdown into structured articles by forcing every section to justify itself.

A TypeScript agar.io-style arena that turns live typography into a physics object, from custom rendering to authoritative multiplayer sync.

How a headless typing engine and CSS-driven heatmaps turn raw keystrokes into actionable performance data.

Moving past static decks to bespoke, zero-dependency web engines that treat the browser as a stage.

A close look at how a cursor effect turns into raw WebGL, shader plumbing, and Shadcn-style copy-paste distribution.

A low-resolution canvas, a replayable action history, and an AI reference grid turn every artwork into a process you can watch, learn from, and share.

A tiny Python tool that pads screenshots to a safe vertical canvas, keeps text crisp with 4:4:4 JPEG output, and packages the whole workflow as an AI-friendly skill.

A manual collision system, a hand-rolled animation loop, and a one-file game state machine turn a simple zombie clicker into a lesson in game logic.

A tiny browser game flips a familiar arcade loop, then makes the hunt feel intelligent with predictive AI, slippery movement, and a revive-by-teleport trick.

A browser-based sprite studio with an MCP server, programmatic templates, and one shared engine for humans and agents.

A compact arcade project that uses authoritative multiplayer, browser-aware RPC paths, and a convincing 2.5D illusion to make a small world feel much bigger.

Aiden Bai’s experiment treats motion, layout, and scroll activation as coordination, not decoration.

A plain-JavaScript SVG engine that parses tree dialects, maps nodes, and animates BST and heap operations with almost no machinery.

A single-file, schema-aware tool that turns tabletop chaos into downloadable XML without a backend, a login, or a build step.

Bills, cards, coins, and wallets get their depth from HTML, CSS, Canvas, and math, not from a heavyweight graphics stack.

A Bun-powered TypeScript script, a virtual clock, and SVG output turn messy shell sessions into lightweight documentation assets.