From a logo to a playable QR world

The first request was simple: make a QR that opens jdt.engineering and resembles the black-and-white JDT logo. The challenge was to make the logo emerge from the code itself. QR data, error-correction bytes and the chosen mask all influence where dark squares appear, so there was much more to explore than dropping a logo onto a finished symbol.

The original Go QArt route gave the encoder a long numeric fragment after the website address. Those digits were real encoded content, chosen to help draw the image; the browser still opened the same website. The search tried QR sizes, masks, rotations and URL spellings. Each promising image was decoded and independently reconstructed before it became a finished design. Later experiments moved the artistic freedom into padding, keeping the decoded URL shorter.

A small square interrupted the logo. It was an alignment pattern: one of the features a scanner uses to recover the grid. Removing it would have turned a structural requirement into a damaged part of the code. Instead, the project kept the original designs and built a second route around QR versions with a more open middle.

Versions 4–6 made that possible at a lower resolution. They keep the large corner finders and a small alignment pattern near the lower-right corner, without the interior alignment grid of the denser examples. The tradeoff is less room for both data and artwork. The result became two clearly separated collections, letting the viewer choose between a more detailed logo and a cleaner center.

The next addition was a small invitation: scan me. Lowercase lettering suited the logo better, so it became part of the target image rather than a separate label pasted onto the page. Variants placed the words above or below the logo and repeated the search with and without the central alignment pattern.

Text makes the problem more demanding. A single misplaced square can close a letter or break a narrow stroke. The lettering route therefore checked the requested text area explicitly, alongside the complete QR matrix and actual decoder output. It also made a practical point about these experiments: the artwork should tell someone what to do before they know how it was made.

The encoded message does not have to be a website URL. A QR can describe an email action, a telephone action or a contact card. The public woven email code is a compact example: it directly encodes mailto:jim@jdt.engineering, so the receiving device can offer its email app without visiting a redirect page first.

This also separates the visible artwork from the message. A woven pattern can carry an email address, and a live camera image can later carry a vCard. The scanner interprets the encoded text; the picture is not itself an attached contact photo. What happens after scanning still depends on the device: an email action opens a composer, and a telephone action opens a dialler rather than placing a call automatically.

The first playable step was Snake inside a QR. Here the picture and the encoded message describe the same game. Each completed frame contains a URL with the current board, snake, food, direction, score, speed and random-number state. Scan it on another device and the game opens paused at that position, ready to continue.

The saved state is small because the body is stored as a head cell followed by two-bit steps toward the tail. A checksum catches corrupted links, and Base64url turns the record into a short URL fragment. The game only presents a new state after its QR has finished encoding, so the screen, copied link and saved PNG agree. The fragment is the saved game data, not the JavaScript program; the destination still hosts the game.

Music used the same general engine for a different purpose. The destination stays https://howler-audio.com while the data padding changes to follow a spectrum or waveform. A local recording, microphone or shared computer audio drives the image. Freeze holds a completed QR for scanning while the sound can continue.

The spectrum uses an 8,192-point FFT and logarithmically spaced frequency bands. It averages spectral power within each band, avoiding an artificial advantage for wider bands. The waveform instead uses real sample-clock history: a two-second buffer, a selectable time window, and positive/negative minima and maxima for each column. A simple 300 Hz display-only low-pass and automatic gain keep the shape legible without changing the audio you hear.

Once the artwork no longer had to be a logo, spirals, mazes, woven ribbons, radial patterns and fractals became natural targets. The first atlas collected 216 finished designs in 18 families. Circular artwork could suggest symmetry, but the QR’s required finder and alignment layout remained visible and constrained the complete image.

A fractal-looking picture is not automatically a QR within a QR. The separate nested experiments made that distinction concrete: an actual smaller code and its white border were fitted into a larger code, then cropped straight from the finished parent image and decoded. The outer code retained exact parity; changes imposed by its requirements could disturb the child, which then depended on its own correction capacity. Bounding boxes were checked so detecting the child could not be mistaken for detecting the parent.

DOOM turned the QR into a display for an existing game engine. The WebAssembly engine produces a real 320×200 framebuffer; the renderer samples, dithers and fits it into a valid QR. The public build includes Freedoom game data, and a local original WAD can be loaded separately. Scanning a frame opens the game website; unlike Snake, it does not transfer the running game state.

The detailed view can use the maximum standard QR size, 177×177 modules. That gives the scene more room but makes camera detection harder. Pausing for a scan switches to a smaller symbol. Optional color preserves the distinction between dark and light modules, while Smooth reveals the source scene between slightly smaller data squares. This particular engine port is silent; the QR renderer does not add an invented soundtrack.

The request for Grand Prix Circuit led to a broader tool: QR DOS. A real DOSBox WebAssembly emulator runs the program, produces its video and supplies its original PCM sound. The QR layer draws that video as artwork while the keyboard and mouse still reach the original program. The supplied Grand Prix Circuit can launch directly; other compatible DOS programs can be loaded locally.

The scan destination remains the DOS app, not a copy of the running virtual machine. Local imports are not uploaded, and explicitly saved browser files are separate from CPU and RAM state. That boundary matters: the QR is a live visual output and a way to open the tool, while the emulator is responsible for executing the game. A compact view and pause control help when the detailed moving picture is difficult to scan.

The next challenge was aesthetic: a picture in the middle still felt too much like an insert. Whole-field work gave every available data and parity position an artwork target, including the edges. Required QR structures remained fixed, but the rest of the code could participate in a woven, rippling or geometric texture.

The bit-level solver models how each free padding bit changes the finished code. Because the parity relationship is linear, those changes can be combined into equations for desired dark and light modules. Not every request can be satisfied at once, so the solver chooses a consistent set and preserves a valid result. The decoded payload can now remain exactly https://jdt.engineering: the artistic variables sit after the message terminator instead of in a visible numeric URL fragment.

The camera tool applies the whole-field approach to a live image. A square crop fills the entire QR, while selected contact fields become a vCard or telephone action. The image changes from frame to frame, but the chosen contact message remains the thing a scanner reads. Only layouts without a structural pattern in the central 5×5 area are offered.

The camera picture is visual artwork, not a photo attachment inside the vCard. Capture and contact details stay in browser memory; saving a PNG deliberately carries the selected details with it. The app can freeze a completed frame, hide the original camera view, and stop its tracks when capture ends. Smooth is a drawing mode with smaller data squares over the source image, not a blur filter applied to the finished code.

The full-field approach then expanded into a much larger collection: Mandelbrot and Julia bands, Burning Ship dynamics, iterative affine systems, Hilbert transformations and dragon folds. Lissajous curves added a different kind of structure: two sine motions with changing frequency ratios and phase create knots, ribbons and tiled loops. These were mathematical target generators, not just different seeds applied to one picture.

The same collection also explored cellular distance fields, warped checkerboards, woven ribbons and actual Gray–Scott reaction-diffusion simulations. A separate 120-design route returned to versions 5–6, keeping structural squares near the edges. Smooth versions retain the encoded module centers while revealing the target between 90%-width data squares. The original square-module exports remain available for comparison.

Photographic work pushed the display method further. Generated images of an alpine lake, canal houses and a snow leopard cover the complete field. In the fine-photo view, tiny black or white marks occupy the centers of data cells, while most of the surrounding image remains visible. The required structural cells remain full-size and the white margin stays clear.

This makes a crucial distinction visible. The underlying QR matrix can have exact parity and every sampled center can be correct, while different scanner detectors still disagree about the image. The gallery therefore pairs photo-preserving experiments with tonal and black-and-white references. It reports what each decoder actually read, rather than treating a beautiful image or a mathematical matrix check as a camera guarantee.

The first photo-preserving versions passed native software decoding but were reported unreliable when scanned. That feedback changed the default: stronger tonal contrast, larger squares or larger circles, a wider correction-level search, and a large scan viewer that uses whole pixels per module. The tiny-dot experiments remain available separately. The new defaults pass a broader digital test set, while confirmation on physical phones is still pending.

The recursive zoom takes a different route from the exact-parity artwork. A smaller copy of the same QR is placed inside a parent, including its quiet zone. The animation zooms until that child becomes the next parent, producing a seamless loop. Every complete readable level points to jdt.engineering.

The renderer caches 32 QR variants that all decode to the same URL. They differ in padding after the message; each change recomputes its parity. With Different levels enabled, every nested level advances through this cache independently. Turning it off restores one repeating code. Zoom speed, nesting depth and render resolution are adjustable, and controls stay beside the image.

The alternate homepage places a working, scrolling page inside a QR frame. Its destination is the hub itself. Unlike an image target, page content can change freely as someone scrolls, focuses a control or opens a section. The design therefore needs a bound on any possible changes inside its content window, not merely one screenshot that happened to scan.

The current frame uses version 6 with high error correction. Its narrow window avoids every structural module, and all content is clipped inside that rectangle. The calculation counts which codewords the rectangle can touch in each block, leaving a correction reserve outside it. Larger layouts and content windows remain research: an exact QArt fit to one fixed card layout is not evidence that an arbitrary scrolling page will keep working.

A second view gives most of the screen back to the actual site. Small QR marks sit over the interactive page, with a preserved quiet border and corner markers. It is an experimental rendering: the browser screenshots read in ZXing, while OpenCV does not read this style. The protected frame remains available as a separate choice.

QR Riot puts moving QR creatures on one shared screen. Phones remain both cameras and controllers. Joining through the room QR asks only for a name; each joined person adds one recognizable creature, with optional NPCs set separately.

The growth game makes size both an advantage and a liability. Eat food to grow, swallow smaller creatures and bank growth before someone takes it. Giants move more slowly and carry larger, easier-to-scan codes. A threatened small player can escape or scan the attacker to steal its body and reverse the encounter.

Swallowing takes two seconds of directed contact at a mass advantage of at least 1.35 times. Victims receive a protected respawn and keep banked points; starter mass cannot be farmed. Jet spends a little growth for an escape burst. Scanning the bomb lights a visible fuse and blasts nearby creatures, spilling growth.

The title is thirteen separate codes spelling QR experiments. Every letter opens the same hub. Every second, one randomly selected position changes to another variant, without immediately repeating the previous position. Smaller matrices and larger display tiles make the letters easier to scan.

KolibriOS boots inside a browser-hosted emulated PC, then its actual video memory becomes the QR artwork. Text editing, drawing and calculation happen inside the guest computer. A source-included helper handles mouse positioning and application launches; the original OS view is optional.

Gravity lets the visitor shape the picture. Hundreds of particles leave trails around up to five draggable attractors. Reverse the forces to push particles away, clear the wells or start again.

Ink is a chemical simulation. Brush strokes seed a second substance; diffusion, replenishment and removal turn marks into fronts, spots and branching patterns. Change the reaction preset and brush size, freeze the field or save its QR. Scanning opens the experiment, rather than transferring the entire grid.

Synth turns the QR into a musical handoff. Toggle steps, change tempo and play an arrangement. Its URL carries the pattern so another device can load the same sequence. Sound starts after pressing Play; voices are synthesized locally.

Aurora layers mathematical ribbons into drifting curtains of light. Green, violet and ember palettes share the same destination. Change drift speed, pause, switch Smooth or save a frame.

Rose windows, fragments, ribbons, sunwheels, arcades and prisms each appear in four palettes. The whole field is the picture; there is no central image inset. The gallery offers filters, enlarged views, Smooth switching and PNG/SVG downloads. All artwork opens jdt.engineering.