Rendre — path-traced product rendering in the browser

rendre ✕

Rendre is a path-traced product renderer that runs entirely in your browser. Import a model, drop a material, swap the studio, and save a clean image — no account, no upload, offline once installed. It's the renderer you open before you can afford the expensive ones. Every render is yours: no watermark, nothing tracked — put it straight in a portfolio or a submission.

New here?

How to use it

Keys & clicks — ⌘Z / ⌘⇧Z undo & redo (one history across modeling and rendering) · Delete removes the selected part · right-click anything for its menu · double-click a part to edit its material · hold Shift while rotating to snap 45°. That's the whole keyboard; everything else is mouse or touch.
Import a model — ⤓ Import…, or drag a file onto the viewport: OBJ · STL · glTF/GLB · Rhino 3DM · 3MF (baked render meshes) · USDZ (ASCII). It lands auto-scaled, centered on the studio floor and framed. Rendre greets you with a default object to start; a model heavier than your GPU's triangle limit is declined with a note to decimate and re-export — or, with Lighten heavy imports on, it's decimated to fit so it still loads — so the room never chokes. Rule of thumb: aim for under ~600k triangles for snappy work (a strong GPU handles several million; the decline note tells you your exact ceiling) — triangles are what count, not file size, but roughly a 10–20 MB GLB or 30–50 MB OBJ usually lands in range. A heavy import then orbits as a light proxy while your renders use the full-res mesh automatically (⇄ Proxy·Full switches the viewport — ). Turn on Add to scene (don't replace) to append the next import beside what's already on the stage instead of starting fresh. Re-importing a file with the SAME name asks whether to Update (replaces matching parts, keeps your materials) or Append instead.
Camera — drag empty space to orbit; scroll or pinch to zoom. The two round buttons at the top-right are a Blender-style nav widget: drag the magnifier to zoom (a tap zooms in a step) and drag the hand to pan the view across the scene. The Camera tiles (Front · ¾ · Side · Top · Hero) frame the model from a preset angle; ⊡ Frame recenters on your model. Wide · Fit · Tight sets how much of the frame the model fills — keeping your angle, changing the crop (Tight for a hero product shot).
Drop a material — open the materials drawer (right edge): hundreds of PBR materials in categories (metals · plastics · glass · paint · rubber · ceramic · marble · illuminated…). Drag a swatch onto a part, or select a part and click a swatch; double-click a swatch to apply + edit it. Search by name (“glass”, “gold”, “carbon”).
Edit a material — the editor tab (right edge, below materials), or right-click / double-click a part. Tune Color, Metal, Rough, Glass (transmission) + IOR, Coat, Sheen, Aniso (brushed/spun-metal streak — 0 is a round highlight, higher smears it into a directional one; the streak is fixed in world space, not the part's own rotation, so turning the part doesn't turn the streak with it), SSS (subsurface — light wraps past the shadow edge instead of stopping sharp: skin, wax, plush fabric, a thin plastic held to a light) and Glow. On a transmissive (Glass) material, Fire splits white light into color as it refracts — a diamond's sparkle — and Dispersion (Abbe) next to it drives the SAME effect from the real optical-industry Abbe number instead of Fire's own made-up units (lower Abbe = more fire; set it above 0 and it overrides Fire). Isolated refraction (pavé), also transmissive-only: turn it on for a pavé stone so its own light path passes straight through a DIFFERENT gem that also has it on, instead of refracting/reflecting off it — a dense cluster of stones set close together reads as clean individual gems instead of one muddied blur. No visible effect on a lone stone. Edits make a session copy; the library stays untouched.
MARMO marble — pick any Marmo material (20 Italian marbles) and the editor gains a stone panel: choose the structure (veined · clouded · breccia · speckled · uniform), the vein and clast colors, vein scale & contrast, warp, redox, clast size & roundness, speckle, hue and seed. It is computed by world position (triplanar) — no UVs, and it survives any scale. ⤓ Seed from a photo samples a marble photo into the params (ground & vein color, scale, warp) — no AI, no upload; an approximation that argues with the photo, never a texture of it. A starting point; the sliders take over.
Phantom (ghost) — the editor's Phantom toggle turns a material into a non-refracting, facing-driven translucent shell: nearly transparent facing the camera, solid at the silhouette — the exploded-view “ghost” poster look, without glass's bend or tint (the interior renders true, undistorted). Tune Front opacity, Edge opacity and Edge falloff to dial how much of the interior shows through and how sharply the rim holds the form. The outliner's one-tap ◐ Ghost flips it on the part's current material instantly — model, tap Ghost on the shell, render. A ready-made Ghost swatch (bone-warm tint) lives in the materials drawer too.
Light it — the environment drawer swaps the studio (33 HDRIs) to relight; Rotation / Height / Intensity dials aim it. Drag any .hdr (or a jpg/png) onto the viewport to use your own. Teach the light: switch the backdrop to environment to see the studio that's lighting your model — then drag Rotation and watch the highlights crawl across the gloss. That's why the render looks how it does; image-based lighting stops being magic once you can see it. (Or keep a clean infinity backdrop with surround.) The same drawer's Background image loads a photo backdrop — a doorway, a porfido fan, a slab of marble — and the Render dialog composites the product onto it.
Light Rig + AfterImage — open the environment drawer and expand Light Rig + AfterImage at the top: real lights placed around the model, not just the studio's own ambient glow. Six presets do the placing for you — Three-Point, High Key, Sweep, Rim, Dramatic, Sunset — each one drops a whole rig at once and dims the studio so the lights have room to read. + Add light adds one of your own; drag it into place with Azimuth / Elevation / Distance / Size. Then the trick: pick each light's color and intensity — even after the render has already started, or finished — and it recomposites instantly, no re-render, because every light's contribution was kept separate from the start. Placement is the one thing that DOES re-render (you moved a real light); color and brightness never do. Clear removes the whole rig and gives the studio its brightness back. A LIGHTS folder also sits in the Parts tree (left edge) once a rig exists — click it to grab the whole rig with the gumball and move every light together, keeping its arrangement, or click one Light row inside it to grab just that one. If the gumball doesn't show up, the light is simply off-frame at your current angle (a real light rig often sits outside the shot, same as a photo studio's softbox) — zoom out or ⊡ Frame to bring it into view.
Breakup — each light in the rig has its own Breakup disclosure: throw a patterned shadow in front of it, like a gobo or cookie on a real fixture. Six shapes — Blinds, Foliage, Caustics, Window, Clouds, Iris — with Scale, Rotation, Contrast, Softness to fit it to the light, and a Seed (with 🎲 Re-roll) so no two lights land on the exact same pattern. In ▦ Film, once at least one light has Breakup on, an Animate Breakup switch appears — turn it on and the pattern drifts, spins, or scrolls across the clip via that light's own Speed sliders (Drift U/V, Spin); off, it stays frozen at whichever phase you left it.
Audio-reactive lights — drop an audio file at the top of the Lights drawer and Rendre analyzes it once into an amplitude envelope; any light's Audio-reactive disclosure then modulates that light's intensity to the track wherever time-driven playback already runs (▦ Film render, or a live Turntable). Baked, not live — the same moment in the track always produces the same intensity, so it composites correctly into an offline render.
HDRI Editor — double-click any studio in the environment drawer to open it: your model on the left, lit live; the dome itself on the right. Add strobes — extra bright spots baked right into the environment image, not separate lights — and aim each with Azimuth / Elevation / Size; ↺ Reset reverts the whole dome to its real recipe (or an empty one, for your own photo). Closing keeps your changes; they travel with the scene like any other edit. ⬇ Export EXR saves the dome as a real .exr file that opens in Nuke, Houdini, Blender and the rest — and carries the exact strobe recipe inside it, so ⬆ Import EXR brings every strobe back editable, not just the pixels.
AfterImage Retouch — any still you render with the Light Rig active quietly carries its own per-light data along in the saved PNG (AfterImage in renders, Preferences — On by default since it's separate from and much lighter than Recipe in renders below, which carries the whole scene; switch it off there if you want a smaller file). Drag that PNG back onto the viewport later — no model needs to be loaded — and a dedicated retouch view opens: just the image and a slim panel with each light's on/off, color and intensity, still free and instant. ⬇ Resave writes a new PNG that's still remixable next time; ⇄ Swap image… loads a different AfterImage PNG into the same view; ← Back to Rendre closes it. If a PNG was saved with both AfterImage data and a full Recipe in renders scene, you're asked which one you want — a quick light remix, or the whole scene reopened, ready to re-render. Turn on AfterImage: environment layer (Preferences, Off by default — it doubles this render's time) and the retouch view also gets an Environment on/off + intensity control, so you can isolate just the Light Rig's own contribution against a black background, or dial the studio's ambient fill back in — works even with no lights at all, for an environment-only remix.
Move things — select a part and the gumball appears: colored arrows move along an axis, rings turn, cubes scale that axis, the white center drags freely on screen, the amber cube scales uniformly. Drag a handle and the part moves — it previews as a bounding box while you drag (so it stays fast even on heavy models), a live readout at the top of the screen shows exactly how far/how much as you go, and the mesh updates when you let go. Double-click any handle to type an exact amount: degrees on a ring, a percent on a scale cube (100 = no change, 200 = double, 50 = half, a negative percent mirrors that axis), or a nudge on an arrow (1 = a small step, 100 = a big one). Right-click → Rotate 90° / Rotate by… for exact turns too.
Right-click anything — a part (Edit material · Copy/Paste material · Link/Unlink material · Drop to floor · Frame this · Isolate · Hide · Duplicate · Delete), the floor, empty space (Frame all · Import · Environment · Materials), or a material swatch (Apply to selected). Delete / Backspace removes the selected part.
Link materials — right-click a part → Link material, then right-click another → Link to copied part: from then on, editing either part's material — color, roughness, a marble structure, anything in the editor — updates both at once, a linked 🔗 mark shows in Parts. Paste material is the one-time version (copies a look once, no ongoing sync); Link is for keeping a set of parts matched as you keep tuning — a whole flatware set, every screw on a product. Unlink material frees a part to edit on its own again.
Measure — click two points on the model for the real distance between them, in mm; the HUD also shows the whole model's mm bounding box the moment you turn it on. A view aid only — never rendered, never saved into the model.
✎ Markup — draw arrows, freehand pen marks, and text labels over the render for a design crit — pick a tool and color, drag to draw. Screen-space only: it never touches the model, and ⬇ Save composites the marks onto a real offline render (never a live-canvas grab).
⊘ Section (Preferences, off by default) — slice the model with a plane to see inside it: foam, lattice, shell walls. Pick the axis, flip which half is kept, and scrub the Slice slider. A view aid only — weight and export stay the whole, unsliced model.
Animation — render a video — ⌖ Shots is the quick path: pick a ready-made camera move (orbit, dolly-zoom, boom, hero float…), scrub it live in the viewport — Weight sets how the move feels: light arrives quick like an earring, heavy accelerates slowly and settles late like a cast-iron pan, same path, different mass — then Render… hands it to Film to pick size, samples and aspect — nothing starts automatically, you render it there when you're ready. ▦ Film is the custom path: ◆ Capture a keyframe as you change the camera, lighting, depth of field, or a material, capture again, and Film morphs between your keys at whatever aspect you need (16:9, 9:16, 1:1, 4:5). Once you have keys, ◂ / ▸ step through them (each jump moves the camera/materials/lighting to exactly what that key captured), ✕ Delete removes only the one you're viewing, and ✕ Clear all wipes every key. ▶ Preview steps through the whole timeline in the viewport first; 🎬 Render video (.mp4) saves a QuickTime-ready file that plays in every browser, with a live per-frame progress bar and time estimate. On a browser without WebCodecs (an older Safari, Firefox before 130) it automatically falls back to a .webm instead of just failing — same content, same camera moves, but its timing follows however long the render actually took rather than being locked to your chosen frame rate.
IMotion — import a baked animation — drag in an Alembic (.abc) file (a physics sim, cloth, or soft-body bake from Houdini, Blender, or Maya) the same way you'd drop in a model: it's a clip, an ingredient, not a new animation-authoring surface — Rendre already has its own keyframe animator and Film for motion made INSIDE the app. A ⏱ badge appears on the part's row in Parts; click it for retime controls — Fit (Once holds at both ends, Loop wraps, Stretch spans the whole shot), Range, Speed, Offset — plus a live scrubber that previews any point in the bake instantly, no keyframes and no render needed. It plays back automatically with any Shot or Film render at whatever settings you've dialed in — there's no separate on/off switch. A multi-object bake lands as one group, every part riding the SAME clock: change Fit or Speed on any one member and the whole group follows. The source file itself is never embedded in a saved scene, only its settings — reopening a scene whose clip can't be found shows a dimmed ⏱! badge naming what's missing; click it to relink the same (or a replacement) file, and your Fit/Range/Speed/Offset come back exactly as you left them.
Batch — queue up renders and walk away — the batch drawer (right edge) queues stills and films to render later: + Add still / + Add film in the drawer itself, or the + Batch button next to Render…/Film's own render button, adding whatever's currently set up. Adding an item opens the drawer automatically and brings it to the front. A queued item stays editable right up until it starts — W, H and samples, right in the row. A Time budget caps the whole queue's total render time, scaling samples down first, then resolution if needed, always honoring what you actually asked for. ▶ Start batch works the list in order; ⏸ Pause holds between items, keeping whatever's mid-render safe. A floating HUD at the bottom of the screen shows which item is rendering and how far along it is, even with the drawer closed — always something to watch, even during an offline render. ⬇ Download all bundles every finished render into one .zip.
Compare A / B — ⇆ Compare A / B captures the look now, lets you change one thing (a material, a studio) with the camera held still, captures again, then wipes between the two with a draggable seam. The crit question made visible: “is the brushed or the polished finish stronger here?”
Decal / logo — ⤓ Decal / logo projects an image (a logo, a label, a number) onto the selected part, facing the camera. It's a real projection onto the 3D surface — it wraps the form, computed in the path trace — not a flat sticker on the screen. Planar (default) sits it on the camera-facing side, like a sticker; Cylindrical wraps it all the way around the part's vertical axis, like a label on a bottle or a can. ⊙ Click a point to place moves the decal's center exactly where you click, instead of always sitting on the part's middle. Move the view + ⟳ Reproject to aim it; Size and Opacity to fit.
Paint — 🖌 Paint… brushes a color directly onto the surface: pick a Color, Size, and Hardness, then drag on the model. No UVs — it paints at mesh density, on top of whatever material the part is wearing. Orbit pauses while painting; click ✓ Done painting to orbit normally. ✕ Clear paint removes it. It's a session feature today — it doesn't yet survive a save/share round-trip or a fresh import.
Quality & image — the Quality pills (Draft · Studio · Final) set how clean the render is; Exposure brightens or pulls highlights back; Depth of field (Aperture + Focus) adds a shallow-focus blur — or hit ⊙ Click to focus and click the spot on the model you want sharp; the focal plane snaps right there. The image converges live as you watch — the viewport is the render. Uncheck Denoise preview to watch the raw path-trace resolve — the sand and fireflies settling into the image; the grain is the honest signal of an unconverged frame, not a flaw to hide. The readout by the controls says how converged the frame is — resolving → settling → clean → converged — an honest sample count, not a fake 100%, so you decide when it's good enough to save.
Lens look — the Advanced / Lens disclosure (collapsed by default, below Depth of field) adds two finishing touches that live on the FINISHED image only, never the render itself: Bloom softly blooms bright highlights and emitters, Chromatic aberration adds a faint lens color-fringe at the frame edges. Both redraw instantly as you drag — converge to a clean, high-sample image first, then dial the look live, with zero re-render.
Render & export — ⬇ Render… saves a clean PNG up to 4K (with a time estimate before you commit). While a still or video render is actually running, the side panels and drawers dim and pause; the render dialog and the viewport stay live and front-and-center the whole time. Changed your mind mid-render? ■ Stop & save appears next to the progress bar — it saves exactly what's accumulated so far (an honest sample count, not the target you asked for), it doesn't just throw the render away. The ⊞ Export & save… button gathers the file exports behind one door: ⬇ Save scene… writes the whole setup to one re-editable .rendre file, 🔗 Copy share link puts the whole render — model, materials, camera, lighting — inside a URL (no upload, no account, no backend); paste it anywhere and opening it rebuilds the exact scene, ready to spin — the fastest way to bring a live render to a crit without anyone downloading anything, and ⬆ To Rhino / Blender… hands the scene off as a GLB — named parts at real scale, every material in Cycles’ PBR vocabulary, plus the camera and the lighting setup as a cited reference. In the Render dialog, ⬇ Per-part mattes saves a ZIP of the beauty plus a transparent cutout of each part — stack them in Photoshop / Affinity / Figma to recolor or adjust parts on their own layers (the hand-off for finishing in a 2D editor, not another 3D app). ▦ Contact sheet renders your model under six studios (or six finishes) into one labeled grid PNG — the crit artifact: which reads best? For composites: Transparent background cuts the product out, a Background image (loaded from the environment drawer — it's a backdrop choice) drops it onto your own image, and Shadow-catcher floor adds a grounding shadow so it sits down on the plate — this works even with Transparent background OFF, darkening the real floor in place, not just for cutouts (reads cleanest with a light studio floor — tune Shadow strength; Shadow accuracy → Accurate renders the floor a second time with the model hidden and compares the two, so an unevenly-lit floor doesn’t read as haze — and, on a glossy floor, a real reflection of the model survives into the cutout too, not just the shadow — costs roughly double the render time, worth it for a hero shot).
⬇ Manifest (weight + watertight) — in the Render dialog, pick a real material and download an honest manifest: triangle count, exact mm bounding box, volume, a per-part watertight (closed 2-manifold) check that names any unclosed part with its open-edge count, and the weight at that material's real density. The economics inside the file, not just the picture.
The render can carry its own recipe (sometimes called a “magic PNG”) — turn on Recipe in renders (Preferences) and every saved ⬇ Render… PNG embeds the scene that made it (model, materials, camera, lighting, exposure) right inside the image file — no upload, no account. Drag a Rendre render back onto the viewport and it rebuilds that exact scene. Hand in the image and the reproducible setup as one thing — this is the answer to “my class only accepts one file upload to the LMS”: one PNG, and your professor can drag it right back in and see the whole build, materials and all. Off by default — a render you hand out or post publicly won't silently carry your whole scene setup unless you choose to include it. (A very heavy imported mesh is left out of the image either way — save the .rendre for those — but the look still travels.)
A movie can carry its own keyed recipe too (experimental) — turn on Recipe in movies (Preferences) and every 🎬 Render video — from Film, Shots, or a queued Batch item — embeds the keyed scene (camera, materials, lighting, your ◆ keys) inside the exported .mp4/.webm. Drag that movie back onto the viewport and it rebuilds the animation, keys and all, ready to re-render — a movie carries the recipe as text only, never an instant remix like the PNG's heavier buffer mode. Off by default: messaging and social apps re-encode video on upload far more aggressively than they do images, which strips the embedded data (the movie still plays fine either way) — share the original file if you want it to stay re-openable.
Start over — ⟲ Clear (bottom-right) empties the stage; ↺ Reset everything (in Preferences) returns to the original starting model and clears every setting (it asks first).
Skins — Preferences (the ⚙ by the wordmark) re-tints the interface: Azure (baby blue, the default), Bloom (pink), Ember, Viridian, Graphite and Achromatic (neutral gray). Idle auto-rotate lives there too.
Advanced dispersion (Preferences, off by default) — on a glass or gem material with Fire or Dispersion (Abbe) set above 0, this swaps the basic red/green/blue approximation of its fire for a continuous rainbow: every sample draws one true wavelength across the visible spectrum instead of picking one of 3 fixed colors. Real, physically-derived color, not a filter — and a genuinely noisier render than basic mode, so it's a quality/cost dial you turn on when you want it, same as bounce count or aperture.
Bananas Mode (Preferences, experimental) — lifts the safety caps that keep a render finite by default: samples up to 1,000,000 (a numeric field replaces the preset pills) and bounces up to 64. For experiments, not deadlines — a heavy setting can run for hours, or reset a weak GPU (it recovers on its own if it does). Resolution and import size stay capped either way, and it's never remembered between sessions, so nobody inherits a bananas render by accident. A 🍌 tag stays visible the whole time it's on.
Trace over a photo (Preferences → Reference image) — loads a photo to ghost faintly over the stage, so you can eyeball a real object's proportions against it while you frame or position an import: Opacity and Size dial it in, Clear removes it. It's a tracing aid only — never weighed, never exported, never saved into the scene file.
Live preview auto-stop (Preferences, off by default) — caps the live viewport's own accumulation at a chosen sample count, so it stops burning GPU (and battery) once the image already looks clean instead of grinding on toward the natural 4096-sample ceiling forever. Never touches a real ⬇ Render — that always runs whatever sample count you asked for there, regardless of this cap.
Ray visualization (Preferences, teaching, off by default) — click anywhere on the model and it draws that pixel's actual bounce path through the scene: real hit points and surface normals straight from the BVH, with a simplified mirror-bounce direction at each hit, ending where the ray leaves toward the environment's light. A diagram of how a ray finds its way through a scene, not a literal replay of one random path-trace sample.
System benchmark (Preferences) — renders a fixed test object (the “Rendre Twist”) at a fixed resolution and sample count and times it: a rough, comparable read on how fast THIS computer renders, on THIS build. Takes about 10-20 seconds.
Bounce-count override (Preferences, off by default) — surfaces the raw 1/2/4/8 light-bounce picker in Core Controls, a technical dial mainly useful on glass-heavy scenes. Off by default because Quality (Draft/Studio/Final) already sets a sensible bounce count for most work — this is for when you want to hand-tune it yourself.
Film: interpolate part properties (Preferences, on by default) — between two ▦ Film keyframes, a part's color/roughness/metalness and position blend smoothly instead of jump-cutting at the next key; geometry only blends when both keys share the same mesh topology (a mismatched part falls back to holding). Turn it off to go back to the old hold-until-the-next-key behavior. Camera/exposure/DOF/environment always blend regardless of this setting; which studio or material a part is wearing always holds — a part can't be “43% gold.”

How it renders

Rendre is a real path tracer, running on your GPU through WebGPU. Every pixel fires rays that bounce around the scene gathering light from the studio environment and the materials — the way light actually behaves — so reflections, soft shadows, glass refraction and color bleed are physically simulated, not faked. The image starts noisy and refines as it accumulates samples; that live, converging preview is the final render. The display transform is AgX, for filmic highlights. It needs WebGPU (Safari 26+ on Mac, or a current Chrome / Edge) and a real GPU.

Credits & license

Made by Phil Renato and Claude (Anthropic), 2026 — part of ILCA, one app among the rest of renato.design. Rendre's own marketing page — the two-editions overview, feature tour and comparison table — lives at renato.design/rendre. Non-commercial research software — your models and renders are yours (see LICENSE, DISCLAIMER & NOTICES alongside the app). Installable on iPad — Add to Home Screen for a fullscreen app that works offline.

The science inside is the published literature: path tracing after Kajiya (1986); the GGX microfacet model (Walter et al., 2007) with Smith masking, Schlick's Fresnel approximation and exact dielectric Fresnel; environment importance sampling after Pharr, Jakob & Humphreys (PBRT); BVH construction after Wald (2007); orthonormal bases after Duff et al. (2017); O'Neill's PCG hash; and Troy Sobotka's AgX display transform (polynomial fit after Benjamin Wrensch). The procedural MARMO marble is computed triplanar from value-noise and a Voronoi partition — after Georgy Voronoi (1908) and Steven Worley's cellular texture (1996) — with hue rotation via Rodrigues' formula. The WGSL / JS implementations are Rendre's own — see NOTICES for details. Hear the fuller history at Classicery's Canon: Kajiya's rendering equation (track 13) and Cook, Porter & Carpenter's distributed ray tracing (track 11) — the same physically-based thin-lens DOF this engine implements.

Studio environments: 33 in the drawer = 28 synthesized originals + 5 photographic sets from Poly Haven (CC0), plus the built-in default (also synthesized) — per-file provenance in NOTICES. Built with three.js + rhino3dm. A provisional, early-stage renderer — expect rough edges.

Full LICENSE / DISCLAIMER / NOTICES text — embedded here so it travels with this one file, even if renato.design ever disappears

LICENSE.txt

RENDRE (web edition) — LICENSE
===========================================================

Copyright (c) 2026 Phil Renato. All rights reserved.

NON-COMMERCIAL RESEARCH SOFTWARE. Rendre is published as a
research artifact — an investigation into browser-native,
offline path-traced product rendering — not as a commercial
product. It is made available for use, study, and teaching
at renato.design free of charge, without accounts, telemetry,
or payment of any kind.

WHAT YOU MAY DO
- Use Rendre in the browser for any purpose, including in
  your own commercial design work: the renders, scenes, and
  exports YOU make with Rendre are YOURS, entirely.
- Study it. The source is one readable HTML file by design.

WHAT THIS LICENSE DOES NOT GRANT
- Redistribution, rehosting, mirroring, or resale of the
  application or its bundled material/environment libraries,
  in whole or in part, outside renato.design.
- Use of the Rendre name to imply endorsement.

THIRD-PARTY COMPONENTS + ASSET PROVENANCE
- See NOTICES.txt for the full third-party license texts
  (three.js MIT, rhino3dm MIT, IBM Plex Mono OFL), algorithm
  attributions (AgX display transform et al.), and the
  provenance statement for the material + environment
  libraries.

LINEAGE. Rendre (web edition) is forked from the WebGPU
render room inside glisten, which is itself a sibling of the
native Rendre desktop renderer (a Blender app-template fork).
Same family, same render-view parity discipline.

NO WARRANTY — see DISCLAIMER.txt. Provided AS IS; no fitness
for any purpose is promised; estimates are estimates.

DISCLAIMER.txt

RENDRE (web edition) — DISCLAIMER
===========================================================

Rendre is NON-COMMERCIAL RESEARCH SOFTWARE — a research
artifact published for study and teaching, not a commercial
product. It is provided AS IS, without warranty of any kind,
express or implied. Use it at your own risk.

WHAT RENDRE IS. A path-traced product renderer that runs
entirely in your browser: import a model, drop a material,
swap the studio environment, render a clean image. No
account, no upload, no cloud — your model never leaves your
machine. Offline-capable once installed.

RENDERS ARE PREVISUALIZATION. Path-traced renders are a
faithful physical simulation of the bundled materials and
environments, but they are previsualization — not
color-managed proofs. The display transform is AgX; final
print/production color decisions need a managed pipeline.

IMPORT. Rendre imports OBJ, STL, glTF/GLB, and Rhino .3dm
(baked render meshes only — render or shade your model once
in Rhino before exporting). Large models are decimated/capped to stay
interactive; very high-poly CAD may need decimating first.
Source materials do not travel with an imported mesh — dress
the parts from Rendre's own material library.

EXPORTS. Image renders are saved as PNG. Scene hand-off to
Rhino / Blender is a GLB carrying named parts at real scale,
PBR materials in Cycles' vocabulary, the camera, and the
lighting setup as a cited reference.

BROWSER REQUIREMENTS. Rendre needs WebGPU — Safari 26+ on
Mac, or a current Chrome / Edge — and a real GPU. Older
iPhones and Safari versions that lack WebGPU cannot run the
path tracer.

NOTICES.txt

RENDRE (web edition) — THIRD-PARTY NOTICES + ASSET PROVENANCE
===========================================================
Rendre is NON-COMMERCIAL RESEARCH SOFTWARE published as a
research artifact by Phil Renato (see LICENSE.txt +
DISCLAIMER.txt). This file lists what it uses and where the
bundled assets came from.

RUNTIME LIBRARIES (vendored locally in vendor/ — not fetched from
a CDN, so the app works fully offline once installed)
-----------------------------------------------------------

three.js — MIT License
  Copyright (c) 2010-2026 three.js authors

  Permission is hereby granted, free of charge, to any person
  obtaining a copy of this software and associated documentation
  files (the "Software"), to deal in the Software without
  restriction, including without limitation the rights to use,
  copy, modify, merge, publish, distribute, sublicense, and/or
  sell copies of the Software, and to permit persons to whom the
  Software is furnished to do so, subject to the following
  conditions:

  The above copyright notice and this permission notice shall be
  included in all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  OTHER DEALINGS IN THE SOFTWARE.

rhino3dm / openNURBS — MIT License
  Copyright (c) 2018-2026 Robert McNeel & Associates
  (Same MIT terms as above. Loaded on demand, only when a
  Rhino .3dm file is imported. "Rhino" and "Rhinoceros" are
  trademarks of Robert McNeel & Associates; Rendre is not
  affiliated with or endorsed by McNeel — the name is used only
  to identify file-format compatibility.)

mp4-muxer — MIT License, © Vanilagy
  (Same MIT terms as three.js above. Vendored at
  vendor/mp4-muxer/; writes the QuickTime-ready .mp4 that Film,
  Shots, and Batch video renders export, fully offline.)

FONTS
-----------------------------------------------------------
IBM Plex Mono — SIL Open Font License 1.1, © IBM. Vendored
locally (vendor/font/) so the app needs zero cross-origin
fetches offline; not served from Google Fonts at runtime.

Syne — SIL Open Font License 1.1, © the Syne Project
Authors. Bold weight only, used for the "Rendre" wordmark —
the same display face renato.design's own marketing pages
set their headings in. Vendored locally the same way as
IBM Plex Mono above (vendor/font/syne-700.woff2).

CODE PROVENANCE (algorithms re-implemented from literature)
-----------------------------------------------------------
Rendre's own render path (what you actually use in this app):
- AgX display transform: Troy Sobotka's AgX (the Blender 4.x
  default look); the minimal polynomial fit follows the widely
  shared approximation published by Benjamin Wrensch (iolite
  engine blog). Reimplemented in WGSL for this app.
- GGX microfacet model: Walter et al. 2007; Smith masking;
  Schlick Fresnel approximation; exact dielectric Fresnel.
- Environment importance sampling: piecewise-constant 2D
  distribution after Pharr/Jakob/Humphreys, PBRT.
- BVH: binned SAH construction after Wald 2007.
- Orthonormal basis: Duff et al. 2017 (Pixar).
- PCG hash RNG: O'Neill, PCG family.
- Path tracing: Kajiya 1986, the rendering equation.
These are methods from published literature; the WGSL
implementations here were written for Rendre.

Present in this file but DORMANT in Rendre mode (Rendre (web
edition) is served from the same HTML source as glisten's SDF
clay modeler — see LICENSE.txt's lineage note; the modeler's UI
is hidden here, but its code ships in the same download):
- Marching tetrahedra polygonization: after Doi & Koide 1991.
- Mesh fairing: Taubin 1995 (λ|μ smoothing without shrinkage,
  with Newton projection back to the true SDF surface).
- Smooth-min SDF combines, and the analytic curve/segment
  distance functions (the quadratic-bezier tube and capsule
  behind the Tendrile / Spine / Braid organic builders):
  popularized by Inigo Quilez.
- L-systems (the GROW branching builder): the parallel
  rewriting grammar of Aristid Lindenmayer 1968; 3-D
  turtle interpretation after Prusinkiewicz & Lindenmayer,
  "The Algorithmic Beauty of Plants" 1990. The stochastic
  grammar + tropism model and the GLSL/JS code are glisten's.
- Skeletal posing: linear-blend skinning of the grown bodies
  (standard skeleton-subspace deformation).
- The Alembic/Ogawa writer: original to glisten.
All of the above are methods from published literature; the
GLSL/JS implementations were written for glisten.

BUNDLED ASSET LIBRARIES (Rendre mode)
-----------------------------------------------------------
The parametric MATERIAL LIBRARY (567 entries) consists of
scalar shading parameters (color, metalness, roughness, IOR,
transmission, coat, sheen, emission) extracted from the
material library authored for Rendre (Phil Renato's research
renderer), with Rendre's own re-authored names and taxonomy
(Lucida, Aurum, Argent, Latten, Heartwood, Lithic, …).
Texture-driven and procedural node-group materials were
deliberately EXCLUDED from the port — only parameter values
travel, no third-party textures, node graphs, or .blend data.

The ENVIRONMENT LIBRARY was REBUILT 2026-06-06 so every
shipped studio has pinned provenance. ONE TELLING, used
everywhere: 33 fetched studios in the drawer = 28
synthesized originals + 5 Poly Haven CC0 photographic sets,
plus the embedded default studio (also synthesized). Two
buckets, no exceptions:

SYNTHESIZED / ORIGINAL (28 in the drawer, + the embedded
default + the modeler's reflective studio): procedurally
generated, original work, made for this shared render pipeline
by Phil Renato + Claude with rendre_assets/tools/make_envs.py
(soft-panel / pinhole / tube / ring / gradient-wash synthesis
in direction space).
  annulus-low-contrast · backwash-cinnabar · backwash-sodium
  · backwash-three-pinholes · backwash-tyrian ·
  backwash-verdigris · cage-room · coved · five-light-studio
  · floorlight-screen · four-light-studio ·
  four-square-mirrored · full-wash-tyrian · low-contrast ·
  paneled · plush-gray · rendre-studio · rimlit-three-point
  · soft-back · soft-light · studio-panel ·
  three-light-studio · three-point-high-contrast ·
  three-point-two-pinholes · top-and-bottom-center-pinhole ·
  tubes · underlit-square · vertical-bands · plus the
  embedded "Rendre Studio" default and the modeler's
  reflective studio image.

PHOTOGRAPHIC, CC0 — Poly Haven (5 in the drawer): fetched
2026-06-06 from polyhaven.com (CC0 1.0 — no attribution
required; given with thanks; disused-warehouse re-encoded
same day to clean a malformed upstream header — pixel data
identical, see _provenance_cc0.json). Per-file source log
ships in
rendre_assets/env/_provenance_cc0.json.
  ballroom            <- polyhaven.com/a/dancing_hall
  photo-studio-sienna <- polyhaven.com/a/brown_photostudio_02
  empty-cell          <- polyhaven.com/a/small_empty_room_3
  snow-wood           <- polyhaven.com/a/snowy_forest
  disused-warehouse   <- polyhaven.com/a/empty_warehouse_01

RASTER, CC BY-SA: NONE SHIPPED. The SEATL "chrome" material is a
procedural mirror finish (no embedded image) — no raster CC BY-SA
asset ships in this build.

TRADEMARKS
-----------------------------------------------------------
Glisten™ and RENDRE™ are marks of Phil Renato. Ideas and
source may travel; the names may not. All other trademarks
are the property of their respective owners. Mentions of
third-party applications (e.g. Rhino, Blender) identify
file-format compatibility only and imply no affiliation or
endorsement.

CONTACT
-----------------------------------------------------------
Phil Renato · renato.design · philrenato@gmail.com