renato.design

Marezzo doesn't model marble's appearance - it re-runs its making. A grammar of cuts (the pavement patterns), a stock of procedural stone (procedural marbles across several structures - veined, clouded, breccia, speckled, uniform), and a patina of feet (the lagoon undulation, lippage, fuga, wear, iron stain, damage). The breccia is a redox map: reduced serpentine clasts in an oxidized hematite matrix, domain-warped round by metamorphism, with a calcite vein network. Every stone and pattern carries an academic citation.

Built on the MARMORAIO spec, from field captures in Venezia & Milano, June 2026. Enter Marezzo →

Materials - what the thing is made of. Processes - how it’s worked. Applications - what it ends up as. Every entry links to the others. Click a process from a material; click a material from an application. The library is the network, not the rows.

Where a writer’s register attaches, the entry carries it - channeled if the author is dead and the philosophy is the point, verbatim if the author is living and the words must be theirs. Every voice block is dated, edition’d, page’d. The ethics of citation is the test the library has to pass on every page.

Each material renders as a small sphere with a tuned palette and a finish enum - the visible character, before the property table. From those values the build derives PBR starter numbers and a downloadable glTF you can drop into a 3D scene. The sphere is honest about being a proxy. The numbers are honest about their sources.

Current v0.5. The cabinet drawers don’t all open yet; numbers are editorial estimates; voice blocks are still being added. Verify any property, citation, or substitution against a primary source before you design against it.

Witness is a registrar. Clinical, dated, uninterested in flattery. Surface reads as glazed ceramic. Bottom not captured. Approximately fourteen centimeters across. It names what the record contains and what it doesn’t.

Afterwords is six voices from the dead. Not critics. Sōetsu Yanagi (1889–1961) on the beauty of anonymous objects. Walter Benjamin (1892–1940) on aura under reproduction. D’Arcy Thompson (1860–1948) on the forces that made the form. Roland Barthes (1915–1980) on the detail that pierces the viewer. George Kubler (1912–1981) on where this object sits in its class. Vilém Flusser (1920–1991) on the gesture of capture. System prompts forbid fabricated verbatim quotes - every voice paraphrases in register.

Concordance names the mechanism. A student who does not know what LiDAR actually is can’t think critically about what a scan actually represents.

Apple exposes full-detail reconstruction only on macOS. specimen comes in two pieces: an iPhone app that captures, and a Mac companion that reconstructs. AirDrop is the pipe. The drop zone is the door. No cloud, no account.

The Mac Companion includes a four-step print-prep workflow under the preview. Thicken offsets vertices inward along their normals, bridges open edges, and reports boundary and non-manifold edge counts so you know if the shell closed. Make watertight voxelizes the mesh, builds a signed shell field, extracts a closed surface via dual marching cubes - or falls back to a coarse voxel hull when the shell field can’t close the input. Min-thickness guard ray-samples each face inward and tags under-threshold walls red in a sibling OBJ. Grow thin is the pair op - displaces under-threshold vertices outward by half the deficit and Laplacian-smooths the patch in, iterating guard → grow → re-guard until the wall meets the threshold. Output quality varies with scan cleanliness; the canonical mesh is never overwritten.

Exports come out in millimeters and +Z up. That’s what Rhino expects, what every 3D-print slicer expects, what the shop floor expects. Switchable to inches for the truly stubborn or architects among you. Not switchable to centimeters or meters - those aren’t the units of the trade this app is for.

Import. Toolpaths. Simulate. Clear. Export. That’s the whole top bar. Every other setting is a choice you make inside one of the five, not a tab you have to hunt through.

Mill-red ribbons of light trace each toolpath the moment the paths are generated - before the simulation runs, so you see the plan first and watch the tool follow it second. Width scales with the stepover. A big pass leaves a wide glow, a fine finishing pass leaves a narrow one.

Aluminum 6061, hard wood, polycarbonate, mild steel, rigid foam. Each with its own PBR setup and chip physics: aluminum throws curls, foam throws flake, hardwood throws long shavings. The stock mesh carries the material you chose so the block being cut looks like what it is.

Import. Toolpaths. Simulate. Clear. Export. That is the whole top bar. Every other setting is a choice you make inside one of the five, not a tab you have to hunt through. Until Toolpaths is hit the scene shows only the stock; the moment it is, glowing red ribbons light up across the part, and Simulate runs the tool along them in real time, throwing chips that settle on the platform.

The toolpath is a flat ribbon of mill-red light that lies on the surface of the cut. Width scales with the stepover: a big pass leaves a wide glow, a fine finishing pass leaves a narrow one.

Aluminum 6061, brass, mild steel. Acrylic, polycarbonate, HDPE. MDF, hardwood, machining wax, rigid foam. Each one looks like what it is and cuts like what it is: aluminum throws curls, foam throws flake, hardwood throws long shavings, and the chips tint to match the stock they came from. Picking one also loads a feed, spindle speed, step-down and ramp angle for the tool in hand — conservative values for HSS tooling, slow enough to survive a first cut. This is all a starting point; students should edit to suit what they need.

Built on Kiri:Moto, re-conceived for design classrooms. The name is the noun, the curls of material you sweep off the shop floor. This is in its day-two state, so come back for more.

Glassine, Slow Honey, Dérive, Hauntology, Bad Dream. Five equalizer-style snap settings between reference render and confrontation. Tap one, tweak from there.

Drop a single still and Dilate dreams forward from it. Drop two stills for a diffusion-bridged morph. Drop a folder for ordered keyframe bridges. Or use no source at all - file menu, Imagine New Clip, and the app dreams the entire piece from a single line of text.

Dilate accepts more than video. A clip, a single still, two stills, a folder of stills, or nothing at all - type a prompt and the app dreams the entire piece from your words. The interface adapts to what you drop: video gets slowdown and extension controls, stills get duration and frame rate, nothing gets a text field and an act of faith.

Two stills is a diffusion-bridged morph from A to B. A folder of stills is a dreamed sequence, keyframes bridged in pairs. A single still is the strangest - the model treats it as frame one and invents what comes next, feeding each output back through itself with a drifting prompt seed. This is tricky to control. That is part of the appeal.

Depending on your settings, you might come back to something you don't recognize. That is not a bug. By default the hallucination stays cinematic - fantastical but filmed, impossible but photographed. Turn Hyperreal off and it forgets what a photograph looks like.

Start with Token Prediction if you want to know how ChatGPT writes. Start with The Chinese Room if you want to know whether it understands. Start with Reward Hacking if you want to know why optimizing the wrong thing is worse than not optimizing at all. Start with Labor Displacement if the question is personal.

dozens of labs. Every one cites its source, and every source is checkable through a three-layer concordance. This is an investigation rather than a course.

Every lab includes a section that turns the lens on TuringTaster itself. The app was built by a language model - which makes it a living specimen of the phenomena it investigates.

Visualizations use metaphors designers already speak - typesetting trays, photocopies of photocopies, design critique chains, mood boards with missing images, forgers and detectives, factories in an arms race.

Every lab includes a “How This App Relates” section that turns the lens on TuringTaster itself. The app was built by a language model, which makes it a living specimen of the phenomena it investigates. One lab explains token prediction; this app was written by token prediction. Another explains hallucination; this app had to guard against it by citing every claim.

Three layers of depth - a source at the bottom of every lab, a full citation in the diagnostic overlay, and a searchable concordance with Verify notes that say exactly how to fact-check each claim. The app does not ask you to trust it. It asks you to check. A fourth layer, PRIOR ART, sits apart from those three on purpose. It records the novel, the play, the poem, the film that described a phenomenon before it existed - and it marks every entry for how much that actually proves. Fiction and cultural work, not evidence but precedence.

A browser-based hardware design tool. You describe in plain language what you want a thing to do. ingenue proposes a set of real parts that could do the thing, draws the envelope those parts would fit inside, and names the closest everyday object that envelope resembles. It treats a supplier catalog as a behavioral vocabulary, not a shopping list - a PIR sensor isn't a motion detector, it is a part that waits.

AnalogyMode. Type a description; the engine maps your language onto behavior tags across the catalog and returns a three-to-six-part stack. ConstraintMode. Set an envelope (budget, skill floor, power source) and get viable stacks ranked by novelty. CuriosityMode. No input; the engine surfaces combinations nobody usually makes. Shrink-To-Fit. Name a target size (pack of gum, Altoids tin, watch face); the engine re-thinks the stack to fit, reporting what survived and what didn't.

The engine proposes, five FabricationVoices argue. The Tinkerer bins-and-bridges. The Professor asks what problem is being solved. The Artist rejects technically correct stacks on poetic grounds. The Engineer names the specific thing that breaks first. The Bricoleur asks what is already in the drawer. The disagreement is the useful part.

The voices run three ways - against the Anthropic API with your own key, against a local model through Ollama or LM Studio, or from authored response banks if you have neither. Nothing leaves your browser - no server, no account.

In 1787 Ernst Chladni dragged a violin bow across a metal plate dusted with sand and the sand jumped into geometry. The plate had no opinion about music. It just responded. murmur is that plate, with a few centuries of physics catching up. Sing into your laptop and wave at it. A four-layer physics surface tells you, in real time, what your sound actually is, right now, shaped into something you can look at.

Not a music generator, not a visualizer, not a game. A quasi-scientific instrument that happens, as a side effect of being played, to produce something you could call a composition and something you could call an image. You make both by doing something with your mouth and your hands. The app holds still and watches.

murmur exists in two forms, and you should not feel a difference between them when you are playing. The web version runs in your browser. No install, no account, audio and camera data never leave your machine. The Mac version is the web version inside a native window: real macOS menubar, native panels, dock icon, draggable title bar, and the kind of small comforts that justify an .app instead of a bookmark.

Two channels. VoiceChannel listens to your microphone - pitch, amplitude, spectral centroid, zero-crossing rate. It does not change your voice. GestureChannel watches your hands through your webcam, runs them through MediaPipe Hands, and reads a couple of dozen landmarks per hand, live. Position is timbre, depth is space, velocity is a wave, pinching is a request for the field to crystallize.

A dozen material presets, named for material states, not instruments - Annealed, Drawn Wire, Spalled, Woven Ground, Cast Form, Ferric, Hollow Shell, Knapped, Risen Glaze, Cold Weld, Quenched, Dead Room. Hold two at once and the space between them, located by your hand spread, is a valid destination.

Four physics layers: a Faraday-flavored fluid film, a Gray-Scott reaction-diffusion system that crystallizes into Chladni figures on stable pitch and dissolves into turbulence on noise, thousands of sand grains drifting toward nodal lines and scattering on transients, and a displacement layer that lets your hands push dimples into the surface.

Every session bundles into a single zip with a LoopFile, an optional video, any high-resolution CymaFrames you captured, and a SessionSlate parameter stream. Filenames don't use timestamps - they use a vocabulary. murmur_glassine-drift.zip. CymaFrame_palimpsestual-eddy.png. The kind of thing.

Gesture is a blank rectangle that waits for your first mark to dirty it up. It refines it, you move a slider and your mark gets darker or disappears, you make another mark and the LLM refines or extends it. Activate text or voice input and your verbal prompts subtly adjust the drawing - if the transfiguration slider is high enough. Make it quicker, make it hotter, it's too damned sharp and it's about to cut me - help!

My largest app by code line count, which means little to me other than the tokens I burned to make it. macOS native, pressure-sensitive tablet capable. It only has a few brushes, it's not meant to compete with the big kids (yet.) But it can draw and edit vector splines and Bezier handles for precise editing if you want them. It uses Core ML Stable Diffusion, was trained with a dozen or so vernacular packs (but you can extend by feeding it your own drawings.) You can capture images for exporting out all at once. And like all my apps, gesture has a rich Concordance panel in addition to full help and tooltips.

You draw. Your voice adds design vocabulary while your hands stay on the surface. The transfiguration slider controls how much the model transforms your marks - from a whisper of refinement to aggressive reimagining, capped at 0.85 because your hand should always be visible in the result. Pin what you like. Export the batch. Repeat until the drawing is smarter than you expected.

A figuration prompt overlay for direct prompt editing on canvas, a DisCursive bar with hundreds of design vocabulary terms across a dozen domains (elements, principles, edge character, composition, rendering, vernacular, affect), and voice input that listens while your hands stay on the surface. Say "aggressive contour, cross section, knife edge" and it knows what that means without asking a cloud. Everything runs on your machine.

Pencil, marker, chalk, pen, blueline annotation (visible to you, invisible to the model), eraser. Pressure-sensitive. Catmull-Rom interpolation. Spline editing with anchor points and Bezier handles for when the gesture needs precision.

IcarusMode pushes divergence to the ceiling. StrangerMode starts cold with no conditioning. HeartattaCk sets every parameter to maximum. DayspringMode is a Konami Code easter egg. You'll know when you find it.

A word processor that watches how you write - not what. It reads your keystrokes, your pauses, your pasted-in fragments and abandoned paragraphs. It responds through color shifts, typographic adjustments, and a voice grounded in writing pedagogy and classical rhetoric. provoc calls forth better composition by refusing to be neutral.

You write. provoc reads the behavioral telemetry - typing rhythm, pause duration, edit frequency, paste events. It infers a state. The state changes the room: background color drifts, typography tightens or loosens, the voice says something worth hearing or says nothing at all. The silence counts as a comment too.

Eight behavioral states inferred from keystroke patterns, never selected. TORRENT when you've been writing for twenty minutes straight. THE STALL when the cursor blinks without input. PASTE EVENT desaturates the interface for a breath. REVISION SPIRAL notices when you've edited the same paragraph four times in six minutes.

The Seminar: highlight a passage and summon dozens of readers. Each of your choices responds in four parts: reaction, principle, citation, and what is lost. That fourth part names what your original does that their position would sacrifice.

Register Intelligence: state your communicative intention. Not genre, but relational goal. provoc analyzes the gap between intended register and received tonality across multiple tensions.

The Canon. Two dozen lessons - twelve anatomy letters (A, g, H, O, n, e, f, Q, S, a) and six interactive: real GPOS kerning pairs, OpenType feature toggles, leading and measure sliders on a real paragraph, real vs. faked small caps, and a paragraph with a live ink-density heatmap. Lesson 21 renders the same letter at five point sizes and snaps the opsz axis per size. Lesson 24 puts a mechanical skew next to a real italic so you can see which files redraw and which only lean. The variable-fonts lesson reads the file’s fvar table and hands you a slider per axis.

Dig. Font-Book-level inspection, plus two moves of its own. Fingerprint rasterizes six canonical glyphs to an offscreen canvas and measures stress axis, x-height ratio, stroke contrast, aperture, counter density, and overshoot - then emits a three-word voice and a classification from the numbers. Downloads as a shareable SVG card. Pair Atlas enumerates every kerning pair the font ships, ranked by magnitude, with a live per-pair adjustment slider.

Forge. Programmatic remix. Walks every glyph’s path commands, applies slant / stretch / anatomy-zone scaling / curve rebuild / wave / perturb, rebuilds the font, writes a real .otf. The source’s copyright, license, designer, and foundry are preserved verbatim in the output’s name table, plus a description line recording exactly what was transformed.

Mix. Drop two or more fonts. Blend visually interpolates outlines (sampleContours → arc-length resample → rotational align → lerp → Catmull-Rom refit). Pick composes range-by-range: B from Bodoni, g from Garamond, digits from Space Grotesk. Every contributor’s attribution lands in the output.

Everything on screen is computed from whatever file you dropped. The leading slider moves lead through real lines of the loaded font. The Pair Atlas ranks the font’s own GPOS data, not a guess. The Fingerprint rasterizes six letters and scans the pixels. Nothing is pretended. The song is Grandmaster Flash’s 1982 “The Message” - no wildstyle, no Spiekermann impersonation, the framing is structural.

graf is a research artifact, not an authority. It doesn’t endorse or speak for anyone cited, and its labels - the Fingerprint’s classification, the license read - are heuristics, guesses worth checking rather than certifications. Non-Latin typography is still out of scope, Glyphs and FontLab remain safe, and it can be wrong, especially on display faces and unusual variable axes.

A 3D modeling room for beginning design students. A student draws one Bézier curve in the left view and watches a surface appear in the right, revolved or extruded or swept or lofted or built as a curve network, depending on which operation is set. The 3D view orbits on its own so nobody has to learn pan, orbit and dolly before they can see their own form.

The math is cubic Bézier - the same pen-tool curve any design student has already dragged a handle on - with none of the NURBS apparatus of knots and weights sitting on top of it. Add anchors, take them away, drag the handles, switch the operation, watch it rebuild. Every operation supports live thicken, and the offset runs along the true surface normal at every vertex so the wall stays perpendicular and the open ends cap themselves. Export writes real quad faces, not split triangles.

Two ways to author now live in the same room. CURVE is everything above: draw the profile, the surface follows. NDZ is a node-and-wire graph that gets there backwards, you wire it, it settles. There is no run button. It is the same kernel underneath, so a Revolve node is the surface builder and the OBJ that leaves is the same real quads.

points is dressed in 8-bit chrome - a phosphor-dark workstation palette, bitmap type, dithered shading and not one gradient. Period-correct to within about half a decade of the IRIS workstations that ran the original Alias/1. Those 8 bits are the museum. The 9th bit is the live curve, glowing full-saturation cyan-and-magenta against the period palette. It is the only place the present day shows up on screen.

Pgon is a digital sculpting toolset for teaching and learning. There is a smooth ball of polygons, you push them around. It is not for production work. It is small, simple, hopefully something you can wrap your head around, arranged so the ideas underneath stay visible and cascade.

It starts as a cage of quads. Subdivide the cage and every face becomes four, smoother, closer to the surface. The coarser cage is still underneath, still editable. Sculpt at a coarse level and the detail above follows. Sculpt fine detail at the top and it survives the trip back down and up again. That relationship, between a control mesh and the surface it produces, is most of what there is to learn here — which is why the mesh is a real one: strict Catmull-Clark, closed and manifold at every level.

Eventually the topology stops cooperating. Pull a horn out of a sphere and the quads stretch until they are no longer quads in any useful sense. Remesh rebuilds it all.

Press and hold any control and it says what it is in plain words, and what the same idea is called elsewhere. Built for iPad and Pencil in Safari. No login, free, and it keeps working with no connection once it has loaded.

Sketch with geometric abstractions, not curves or topology. Drop soft primitives into space, move them together and they fuse, by osmotic union, into blobjects. A metaball-first workshop for the early, unstructured phase of form-finding.

Every form in glisten is a signed distance function, raymarched together on a single quad and combined with a smooth minimum. There's no mesh while you work - just fields melting into one another. Add fuses two forms into one; Subtract carves. A per-form slider says how molten each joint reads; a global Blend multiplies them all at once.

Infill doesn't just hollow a part, it re-grows the inside as one continuous lattice: a gyroid, a Schwarz-P, an octet truss, or Voronoi foam, rounded cell-edge pipes with real open windows. Grade it dense and stiff at one end, open and soft at the other, the same trick a printed midsole uses. Filigree traces fine wire across a form's own surface — not a decal, it walks the actual distance field, so it bends and wraps wherever the body curves, and the readout counts total wire length, the same number a goldsmith would want.

Designo is an Italy-based alternate take on glisten, the same metaball engine reskinned as a radical-Italian workshop, with skeuomorphic faucet-knob controls and a shelf of procedural Italian marbles. Both install. Expect rough edges; it's released as research, not product.

A deterministic decoder for the factory production documents on Mopar muscle and GM third-generation F-body cars. Give it a VIN. Or pick a document type (fender tag, broadcast sheet, SPID label) and it will try to read the codes off your car into the textbox. The decode returns a structured read (engine, transmission, paint, plant, package) with a citation under every code and a confidence tag that says how sure it is.

Every code carries a confidence tag - factory-documented, registry-corroborated, registry-attested, forum-consensus, single-source, disputed. Damaged sheets get partial decodes; missing cells are marked, not invented. When two sources disagree, both readings show. Plant-aware (a Lynch Road tag is not a St. Louis tag) and year-aware (the A32 axle code means one thing in 1970 and another in 1971).

The decode engine is pure TypeScript, running in your browser - no server hop, no LLM, no telemetry. Same input, same output, every time. Photos never leave your device, and the OCR is local. The codes themselves are facts and unrestricted; the compilation, the citation discipline, and the writing on top are the work product.

An architectural pedagogy instrument. You give it a design brief. Seven paradigms, each a real position from the discipline's literature, respond. Each one in the first person. Each one citing the source. Each one with a different idea about what your building should be. You then take the parts you want from each, axis by axis, and watch the building that results. Where the paradigms agree, the building is calm. Where they disagree, the system flags the conflict and shows you what each side stands to lose.

The point is not to find the right answer. The point is to be made aware that there is more than one position, that those positions have history, and that the choice you make is a choice.

Seven voices, anchored in primary literature: Alberti (concinnitas, harmonic proportion), Venturi (complexity and contradiction, the decorated shed), Loos (Raumplan, ornament as crime), Social Dimensions (program as labor question), Palladio (Quattro Libri proportion, bilateral symmetry), Alexander (Pattern Language, the Quality Without a Name), Hadid (parametric continuity, dissolved thresholds).

The web demo runs the three sample briefs through a fixed library of paradigm responses - click a brief, see all seven respond, blend in the mixer, watch the building change. The Mac version writes new responses live against a local LLM (Ollama, llama3.1:8b), accepts your own custom briefs, opens the full mixer with all seven axes, and runs the full viewport with massing, render, and plan. Same chamber, two scales of commitment.

One input, three directions. Type plain English and watch it become code through decreasing ambiguity. Paste code and see it decoded upward into language you can discuss in a design review. Put German next to Swift next to CSS and see how each language encodes the same reality through different constraints.

Every programming language is a pidgin - a trade language that formed when two groups needed to communicate across a gap. Humans don’t think in semicolons. Machines don’t understand “make it pop.” Code is the simplified contact language that formed between. The name of this app isn’t a metaphor.

Each translation is a set of choices about what to preserve and what to sacrifice. Translating a poem into another language requires dozens of attempts, each losing (and gaining) something different. Code works the same way. Python's list comprehension, Swift's filter chain, C#'s LINQ query and C++'s explicit loop all express the same intent, and no idea can be expressed and executed the same way in two development environments. Each language ‘thinks’ about the problem differently. Translation doesn't just change the words. It changes the thought.

Translate is the hero verb, one input and three directions: type English and see code, paste code and see English, paste anything at all - terminal output, config files, jargon - and see it decoded into plain language. Click any token in a real code specimen and a plain-English explanation appears: what it is, what it does, why it is there. Dissection, not production.

Built for people who will direct code, not write it. Design leads, machines follow. Not a code editor, not thirty-seven steps and a certificate at the end.

A free WebGPU path tracer for product design visualization. Import a model (OBJ, STL, glTF/GLB, Rhino 3DM, 3MF, or an Alembic .abc clip, which plays back as animation) and it lands auto-scaled and framed. Drop one of hundreds of PBR materials on it and tune it in a live editor. Then render: a clean PNG up to 4K. Heavy models orbit as a light proxy and render at full resolution.

Six presets drop a whole rig of real lights around the model at once and dim the studio so they have room to read. Then pick each light's color and intensity after the render has finished, with no re-render. And it travels with the image. Every still can carry its own light data inside the saved PNG - drag that PNG back onto the viewport later, with no model, and a slim panel of on/off, color and intensity per light opens with it.

Drop a glass or gem material on a part and it doesn't fake refraction, it bends real rays through the surface, tints by thickness, and throws colored fire the way a cut diamond actually does. Metal doesn't have to throw a round highlight either: dial Aniso up and the same roughness value smears the gloss into a directional streak, the look of a lathe or a brushing wheel, not a photo of one. Marmo is stone with no photograph anywhere near it — the veining is computed on the surface itself, so it wraps a part with no seams and no UVs to unwrap first.

It needs WebGPU (Safari 26+ on Mac, or a current Chrome / Edge) and a real GPU. Free, no login, nothing leaves your machine.

Drop two images, two clips, or a small batch of renders and a seam appears between them, draggable by hand. Video plays in sync on both sides. Wipe and blend cover the basic A/B; multi-seam splits up to six at once; blink flips between them at a rate you set; checkerboard tiles them together at a size you drag; diff heatmap is a real per-pixel readout of what changed, not a guess. Zoom in and drop a loupe to check a detail up close.

Cull & Rank is for the bigger pile: load a batch and it runs quick pairwise duels (left, right, or too close to call) converging on a ranked order using the same rating math a chess tournament uses to seed itself, far fewer comparisons than sorting a grid of near-duplicates by eye. Tinct, a separate wing, needs no photos at all: it generates color palettes across a range of harmony families and historical registers, renders them into honest contexts instead of bare swatch strips, and blind-tests them the same pairwise way.

Sweep the seam and export it as an actual video - the kind of thing that belongs in a crit deck, not a folder of loose stills - or everything as a zip. And save the whole session as one small .juxt file: every image loaded, the mode, the ranking, an optional note about what to look at. Drop it back into Juxt later, or hand it to someone else entirely — a student can turn one in, and an instructor opens it in Juxt and sees exactly what was being compared and why.

Juxt grew up alongside Rendre, a render queue can hand its output straight in, but it takes anything, from anywhere, and stands on its own. Nothing here uploads anywhere - it runs against whatever's loaded, in the tab, and stays there.

A small laboratory for the principles that make interfaces work - and the moments when breaking those principles is the move. Every "law" is a live instrument you can drag, click, and bend. Every rule has a "How this app uses it" disclosure that lets the app audit itself against its own teachings. If it cheats, it tells you.

The Labs. Playable demonstrations - Fitts, Hick, Miller, Doherty, Wertheimer, Zeigarnik, von Restorff, and friends. Built so you can feel each principle instead of read about it.

The Deviations. Rules the renato.design suite breaks on purpose, with reasons. Hidden undo. Modal-less panels. Sliders only for brushes. The other half of the book.

The Dark Patterns. Cataloged, several playable - confirmshaming, roach motels, fake countdowns - each with a "← gotcha" reveal that names the cognitive lever being pulled.

Web-only now, in any modern browser - nothing to install, nothing tracked. A native Mac edition existed for a while; it's been retired in favor of one browser edition.