Loupe Shader · Version 1.0.0

User Manual

Version: 1.0.0
For: Blender 4.2 LTS – 5.x
Location: Shader Editor → N‑panel → Loupe Shader tab
Author: Black Lykhen
License: GPL‑2.0‑or‑later

Loupe Shader renders a live preview thumbnail of every shader node directly on top of the nodes in your Shader Editor, so you can see exactly what each node produces — a noise pattern, a color ramp, a bump map, the final material — without leaving the node graph. Rendering happens in a separate background GPU process, so your main Blender stays responsive while previews update as you edit.

It also includes a large Pop‑Out preview, a node organizer (Label & Frame / Tidy), a value readout, hover tooltips, and a pie menu.

1. What it does

Draws a rendered thumbnail above each shader node, updated live as you tweak values: in materials, in the World editor, on a light's node tree, and inside node groups (Tab into one).
Renders with Cycles (path‑traced) or EEVEE (fast), switchable instantly. Pure texture chains (noise, ramps, math, images…) are drawn by the add‑on itself in about a millisecond, with no render at all.
Previews appear on a cube by default (or sphere, flat plane, pyramid, cylinder, torus, Suzanne, or any object you choose).
The Material Output node shows a final‑material thumbnail using the real surface and real displacement.
Each preview can be rotated, zoomed, panned, free‑flown, and popped out to a large preview.
Every output is shown the way it is meant to be seen: normals as lit relief, displacements on real geometry, coordinates as a grid, volumes as fog, see‑through shaders on a checker backdrop, constants as their number (see §11, What each thumbnail shows).
Script (OSL) nodes render in Cycles on the CPU automatically; Attribute and Object Info nodes read the object that uses the material (its attributes, custom properties and color).
Tools to label, group, and tidy large node trees automatically, plus align, straighten, find and compact.

Everything is non‑destructive: the add‑on never changes your node connections. The Organize Nodes tools write node positions and labels (only when you press its buttons). Per‑thumbnail view settings — the chosen output, rotation, zoom, pan and free‑fly camera — are stored as small custom properties on the node itself (sp_socket, sp_quat, sp_zoom, sp_pan, sp_fly, sp_show_all), so every node keeps its own pose and they survive a save/reload; they have no effect on rendering. Everything else it touches is temporary render files outside your .blend.

2. Minimum requirements & compatibility

Requirement	Detail
Blender	4.2 LTS minimum, through 5.x (checked on 4.2, 4.3, 4.4, 4.5, 5.0, 5.1, 5.2 and 5.3). Won't run below 4.2. On 4.3 only, the quick frames shown while a thumbnail turns are rendered rather than drawn from the viewport (that version draws them at half size), so drags there are a little less smooth.
OS	Windows (fully featured, primary target). macOS supported, including the Pop‑Out auto‑resize/float. Linux runs the core features.
GPU	NVIDIA is the best path (OptiX/CUDA). AMD (HIP), Apple Silicon (Metal), and Intel Arc (oneAPI) are supported as fallbacks. EEVEE previews work on any GPU. If no GPU backend is available it falls back to CPU.
RAM/VRAM	By default two extra Blender processes run in the background: the render worker plus the Interaction Worker (spins and per‑node previews). Each one holds its own RAM and a GPU context, so budget for both. On a tight machine turn Interaction Worker off (Performance) to run just one. With Cycles, a hidden live Cycles viewport takes the interaction worker's place for drags (about 3 GB of GPU memory, measured on an RTX 4090; a worker takes about 2.7 GB). Loupe Shader reads the GPU's free memory first (NVIDIA) and starts it only when it fits.
Disk	The thumbnail cache in your system temp folder: at most 750 MB and 14 days old by default (Cache Size / Cache Age in the preferences).

GPU backend selection is automatic: the worker tries OptiX → CUDA → HIP → Metal → oneAPI and uses the first one that exposes a device, pinning to the card whose name matches the GPU field. The denoiser uses OptiX on NVIDIA and OpenImageDenoise everywhere else.

3. Installation

Edit → Preferences → Get Extensions, then the ▾ menu in the top‑right → Install from Disk…
Select loupe_shader-<version>.zip and make sure it is enabled.
If Blender's Auto‑Save Preferences is off (☰ menu at the bottom‑left of the Preferences window), press Save Preferences once, otherwise the add‑on is forgotten at the next start. The panel reminds you when this applies.
Open a Shader Editor, select a material, and press N to open the side panel. You'll see a Loupe Shader tab. The ? at the right of its header opens this manual in your web browser.

Updating is the same Install from Disk with the newer zip; it replaces the previous version in place. Keep a single copy installed.

4. Quick start

Open a material in the Shader Editor.
In the Loupe Shader panel, set Show to Selected or All.
Thumbnails start by themselves, using the scene's render engine; the background worker boots on first use (a moment), then thumbnails appear above your nodes. Cycles / EEVEE switch the engine any time.
Hover a thumbnail and drag to spin it, scroll to zoom, double‑click to pop it out big.
Edit any node value — the affected thumbnails refresh automatically.
The same works in the World editor (Shader Editor header → World), on a light that uses nodes, and inside a node group: select the group node and press Tab.

5. How it works (architecture)

Loupe Shader draws thumbnails in two ways, plus a third for drags.

In‑process, for texture chains. A node fed only by texture, math, color and coordinate nodes (and node groups made of those) is turned into a small GPU program and drawn by the add‑on itself, inside your Blender: about a millisecond, no render, no shader compile. Bump, Normal Map and Normal previews are drawn this way too, lit like the render. See Instant Texture Nodes under Performance.
In a render worker, for everything else. A separate, resident background Blender (the "worker"), launched with --background --factory-startup and pinned to one GPU, renders shaders, volumes, displacement, worlds, lights, scripts and the final Material Output. The add‑on sends it jobs through a pipe and gets raw pixels back the same way; no job or result files are written. On Windows the worker is a normal Blender window on a separate, invisible Windows desktop (you never see it, and it has no taskbar button), so it can also draw a viewport: while you drag with EEVEE and Live, while you drag (below) can't draw the node, each frame is drawn through a hidden viewport of the same camera, the way the Pop‑Out draws (about 20 ms, against about 150 ms for a render on a heavy material), and the settled picture when you let go is a normal render. If that kind of worker can't start, Loupe Shader uses --background workers instead. macOS and Linux always use --background.
Live, while you drag (Windows, EEVEE materials). The active node's thumbnail and the Large View are drawn by your own Blender during a drag, the way the Pop‑Out draws. The copy is compiled in a hidden, off‑screen viewport while you look at the node. Each frame is then drawn in the Shader Editor's own redraw at the drag's latest angle and never leaves the GPU. The first frame appears 11–20 ms after the mouse moves (22–33 ms on a heavy material), at 40–60 frames a second. Each new view (another node, or the Large View) is drawn once while you are idle, because EEVEE's first draw of a view is several times slower than the ones after it. The live copy takes 4 viewport samples: a viewport draw renders all of its samples every frame, and 16 would cost three times as long. When you let go, the settled picture is a normal render from a worker. In the Large View a drag frame is drawn at full size, so it gets a one‑pixel smoothing filter. A noisy material, such as a leaf with subsurface scattering, ambient occlusion and a fine bump, would still show fat, crawling dots at 4 samples. So the first time a node is drawn live, it is drawn once at 4 and once at 12 samples while you are idle. If the two differ, that node's drags use up to 12 samples, as many as keep a frame near 30 ms, in the Large View and in its thumbnail. A thumbnail is the frame shrunk 3x, which smooths dots by about that much, so it takes three times the difference to count as noisy there. On the reported leaves that is about 25 frames a second instead of 40, with the dots gone. Nodes that look the same at 4 keep the faster 4. A node not checked yet starts from what its material's last node measured, or 8 samples if none has been checked. The live path draws only nodes whose thumbnail is the material lit on one shape. It skips Mix Shader's three balls, see‑through and translucent previews, volumes, swatches, node groups' own trees, scripts, other materials' faces, orbit and fly views, and true displacement; those drags go to the workers as before.
Cycles drags. With Cycles, the active node's drag frames (thumbnail, Large View and Pop‑Out) come from a hidden Blender that keeps a Cycles viewport open on the preview scene, in the interaction worker's place. It keeps its session between frames, so a new pose shows after one sample (about 35–80 ms a frame), and while the mouse rests the picture keeps refining in place. If that process can't start (not enough GPU memory) or its frames turn slow, the worker renders the drag frames instead, each a real path‑traced render at the draft sample count.

Around those two:

The worker gets the tree's structure once (a small .blend in a temp folder, rewritten only when you add, remove or rewire nodes). Values travel with each job and are poked into the material it keeps loaded and compiled, so dragging a slider never recompiles a shader.
The whole tree renders in one pass on EEVEE and on Cycles: every shown output is tapped as a render pass of the same render. Shader nodes (BSDFs, Mix Shader…) render on their own compiled copies. With batching on, a second interaction worker takes spins, pans and flies so they never wait behind a whole‑tree render.
Only changed nodes and everything downstream of them re‑render, not the whole tree.
Results are uploaded straight to GPU textures (no image datablocks) and drawn above the nodes by a draw handler. Finished thumbnails also go to a disk cache, so reopening a material, or a node you looked at before, is a load instead of a render.
A double‑buffer keeps the currently shown thumbnail on screen until its fresh replacement is ready, so previews never flash blank.
The worker sets the current frame before each render, so animated values are evaluated correctly (see Animated preview).
While you are idle the worker warms up what you are likely to need next: the rest of a large tree, the shader nodes' copies, then the file's other materials, one compile at a time.

Why a separate process? Rendering inside your interactive Blender would lock the UI and conflict with the live session. Offloading to a worker keeps editing smooth and lets the GPU churn previews in parallel.

6. The panel — every control

The panel lives in the Shader Editor's N‑panel under the Loupe Shader tab. The controls at the top are always visible; the rest sit in collapsible sub‑panels, listed here in the order they appear.

Always visible

Show (Off / Selected / All) — master switch. Off draws nothing, Selected draws thumbnails on selected nodes only, All on every eligible node. (Default: Selected.)

Focus Selected (under Show) — with All on, select a node or a few and the other thumbnails fade, so the ones you are working on stand out; their badges go with them. The Fade slider beside it sets how far: 0 leaves them as they are, 1 hides them (default 0.75, about a quarter of their strength left). Nothing selected: every thumbnail is back in focus. Dragging, zooming and hovering a faded thumbnail still work. With Selected, which hides the rest outright, it does nothing. (Off by default.)

Cycles / EEVEE — the engine rendering the thumbnails. Switching is instant (the worker handles both, it does not relaunch); the active button is highlighted, the status line names the engine, and each thumbnail carries a small engine badge. The engine also follows your scene: change the render engine in Render Properties and thumbnails (and an open Pop‑Out) switch and re‑render at once. The rule is the latest change wins, whether made there or here; when the two differ the status line says so, e.g. EEVEE (scene: Cycles).

Texture nodes never wait for a render. A node fed only by texture and math nodes is drawn by the add‑on itself, in your Blender, on the GPU (see Instant Texture Nodes under Performance): about a millisecond, no compile, so those thumbnails are on screen the moment a material opens and follow a drag at the poll rate. The renders below are for everything else. > How EEVEE thumbnails are made. EEVEE renders the tree's color and value outputs in one pass: every such output being shown is tapped as a render pass of the same render, and the Material Output's thumbnail is that render's own image. So a tree of 40 texture and math nodes costs one EEVEE render, not 40, and a value edit re‑renders through the already‑compiled material. Shader‑socket nodes (BSDFs, Mix Shader…) render one by one on their own compiled copies, so they cost a render each but never a recompile after the first. The first render of a material still compiles its shaders — a second or two on a simple material, five to ten seconds on a heavy one — and the slot shows compiling shader… meanwhile (see Waiting for the first thumbnails below). The node you clicked comes first: it renders on its own plain copy of the material (the same compile the viewport does) before the whole tapped tree compiles, and so does the Material Output's thumbnail, whichever node is active (on a heavy pot material its plain copy compiled in 8.6 s, the tapped tree in 22 s). Spins, pans and flies render on a small per‑node copy of the material on the interaction worker: only the nodes feeding that one output, with no render‑pass taps, which compiles in a fraction of the time the tapped tree takes (on a heavy plant material, about a second against nine). While you are idle the add‑on compiles that copy for the active node ahead of time, so its first drag starts at once; if you drag another node before its copy exists and the batch worker is free with the node's pass already compiled, the frames go through that pass instead. After the first pass the add‑on also keeps compiling in the background once you have been idle for 12 seconds: the other tap groups of a large tree, and a per‑node copy for each shader‑socket node; the status line reads warming shaders (n left)… until it is done. A frame you are dragging never waits for such a background compile, and neither does the node you click: if the batch worker is in the middle of one, that node renders on its own copy on the other worker instead. Texture and math previews that the add‑on draws itself also compile a small GPU shader each the first time; those compiles are spread over several redraws (the node you clicked first), so Blender stays responsive while the thumbnails fill in one after another. Every output socket is tapped up front, so Next Output and Show All never trigger a compile. Blender 4.2–4.5 can tap at most 16 outputs per render, 5.x far more, so very large trees take a few passes. Cycles batches the same way (one path‑traced render per tree, its scene kept resident on the GPU between renders) with no shader compile at all, so a tree's first thumbnails arrive in a fraction of a second; only spins render node by node there, because that is cheaper on Cycles. The ms/node readout shows the measured cost of each engine on your machine. The workers render EEVEE with a 32 MB shadow pool instead of Blender's 512 MB default: a thumbnail's shadows fit with identical pixels, and each render skips a large GPU allocation (about a third faster). Your scene's own setting is not changed. The batching can be switched off in the preferences (see Performance).

Status line — e.g. "EEVEE: rendering 4/12… · 260 ms/node" while a batch is in progress, "Cycles: 12 nodes · 0.90s · 42 ms/node" when it finishes, with a small × to stop the workers. While the worker starts or EEVEE compiles, it says so instead (see Waiting for the first thumbnails below).

Open Pop‑Out — renders the active node at size, as a split area (see §13); an × appears while a Pop‑Out is open. In a World tree, a light's tree or inside a node group it opens the rendered Pop‑Out.

Waiting for the first thumbnails

The first thumbnails of a session take longer than the rest, and Loupe Shader says what it is waiting for, both in the status line and in a dim box in each thumbnail's place:

Stage	Status line	In the thumbnail's place	How long
The render worker starts (a hidden copy of Blender, then one tiny render with the scene's engine so your first thumbnail doesn't pay for it)	Starting renderer: starting Blender / loading Cycles / loading EEVEE shaders… 4 s	starting renderer… with the stage and the seconds so far	A few seconds. The very first time on a computer (or after a graphics driver or Blender update) EEVEE compiles its whole shader library here, which can take a few minutes; the panel then adds First start on this computer can take a few minutes. It happens once.
EEVEE compiles this material (the first time each material is shown)	EEVEE: compiling shaders… 6 s · 3/12 done	compiling shader… first time: 6 s, or waiting for a shader compile… when a thumbnail is queued behind another compile	A second or two on a simple material, five to fifteen seconds on a heavy one or with real displacement. The seconds count from when the worker started on it, not from when you clicked.
Cycles builds GPU kernels (the first time a shader feature is used with this Blender and GPU)	Cycles: building GPU kernels (first time only, can take a few minutes)…	building GPU kernels… first time only	Minutes, once per feature set.
Rendering	EEVEE: rendering 4/12… · 260 ms/node	rendering…	Usually well under a second per tree.

Texture‑only chains skip all of this: they are drawn in your Blender (see Instant Texture Nodes) and appear straight away.

Updating an existing thumbnail. After an edit, a draft being sharpened, or a switch between EEVEE and Cycles, a thumbnail keeps showing its previous picture until the new one is ready, then cross‑fades to it (about a sixth of a second) instead of flipping. A picture that is still waiting for its replacement after about a third of a second carries a small turning arc in its top‑right corner: what you see is the previous result, and the new one is on its way. Dragging, spinning, panning and flying swap frames at once, with no fade, and so does any change of only the angle, zoom or pan (for example a thumbnail turning to the Pop‑Out's angle): a new view never fades in.

Thumbnails always come from the engine you picked: there is no quick Cycles picture in between, so a slot never flips from one look to another. A render is only given up on after a minute without an answer (then asked for once more), and one that arrives late is still shown, so a slow compile never leaves a slot stuck on rendering…. If the status line stays on one stage for much longer than the times above, use Copy Diagnostics (Shortcuts & Help).

Notices

A box appears at the top of the panel only when something needs your attention:

Welcome to Loupe Shader — the first time the add‑on runs; Dismiss hides it for good.
Auto‑Save Preferences is off in this Blender — until preferences are saved, Loupe Shader will not be enabled the next time Blender starts. Save Preferences saves them; the × hides the notice.
Another copy of Loupe Shader is enabled — two enabled copies fight over the same panel. Disable the one named in the box (Preferences → Add‑ons) and restart Blender.
EEVEE thumbnails are failing here — the worker rendered nothing with EEVEE on this GPU or driver, so the thumbnails keep their last state. The box offers Use Cycles instead and Copy Diagnostics. Loupe Shader never switches engines on its own.

Preview

Object Shape — every thumbnail previews on the object that uses the material, and only on the part of it that material actually covers: a two‑material barrel's metal material shows just the metal bands, its wood material just the wood; the middle of each thumbnail is missing where the other material's faces would be. The Pop‑Out matches: it opens (and switches) on the same cut‑down mesh as the thumbnail. Turn it off and every node falls back to Shape below. Worlds, lights, the Mix Shader's three balls and color/value swatches always keep their own scenes, on or off. (On by default.)
Whole Object / Textured Others / Gray Others (the row under Object Shape, also in the Pop‑Out's sidebar) — what Object Shape covers. Whole Object off: only the faces the material covers (above). Whole Object on keeps every face, so a scanned or painted mesh whose materials interleave face by face keeps its shape instead of showing ragged holes, and the pair beside it picks what the faces of the other materials show: Textured Others — their own materials, so you see the whole object as it really looks, with only this material's faces showing the selected node (a dirt mound of dirt and rock keeps its rock); Gray Others — plain gray, like a sculpt, so only this material's faces show the node. The round‑arrow button, or Shift + W in the Shader Editor or the Pop‑Out, cycles Material Faces → Textured Others → Gray Others. Other Shape is grayed out while Object Shape is on. With Gray Others on — or with Textured Others on an object that really has other materials — texture‑node thumbnails render in the worker instead of in‑process. (Both off by default.)
Shape (labeled Other Shape while Object Shape is on) — the mesh the shader is previewed on when Object Shape is off, or for a node it doesn't cover: Auto (sphere for shaders, flat otherwise), Sphere, Flat, Cube, Pyramid, Cylinder, Torus, Suzanne, or Custom. 3D shapes start at a 3/4 view. (Default: Cube.) With Custom, an Object field picks any scene object; its modifiers are applied and it is auto‑centered and scaled.
Object Shape for Mesh Data (only shown while Object Shape above is off) — nodes that read the object's own mesh data (Attribute, Color Attribute, UV Map, Tangent, Pointiness, Random Per Island, and everything they feed) preview on the object that uses the material, so they show its real attributes, color layers and UV layout, while everything else still uses Shape. Turn it off too and every node uses Shape; those nodes then show the preview shape's own data (its UV map and color attribute, or nothing for an attribute it doesn't have). Values the material reads from the object or the scene rather than the mesh (an Attribute node set to Object, Instancer or View Layer, and the Object Info color) come from that object and scene either way. (On by default; moot while Object Shape is on, since that already covers these nodes.)
Active node — the active node's name, then Recenter (C) (move it back to the middle, keeping its zoom and angle) and Next Output (V) (step a multi‑output node to its next output, then All). When the node has more than one output, one button per output plus All follow, showing which is previewed. The buttons act on the active node; the C and V keys act on the thumbnail under the cursor.
Pin Before / After (P) — pin how the active node's thumbnail looks now, then keep editing: the thumbnail shows the pinned before and the live now side by side (see §7, Before / after). The button reads Unpin (P) while it is pinned; Unpin All (n) appears beside it when any thumbnail is pinned.
Range Check — stripe the values each thumbnail shows that are out of range for the input it feeds: a Base Color too dark or too bright for a real surface, a Metallic neither metal nor non‑metal, a 0–1 input (Roughness, Alpha, a Mix factor…) below 0 or above 1. The active node's thumbnail always shows the verdict, in range included. See §11, Range Check. (Off by default.)
Value Readout (beside Range Check) — measure the min / max / average of the active node's output a second after you stop editing, shown on the active node's thumbnail as Min · Avg · Max (and explained in the hover tooltip). Reads the true range of a mask or factor at a glance. (Off by default.)
Fling to Spin — let go of a thumbnail while flicking it and it keeps turning (see §7, Grab rotation). (Off by default: a thumbnail stays exactly where you let go.)
Rotate Together — every thumbnail of the material shares one view: turning, zooming, panning or recentering (C) one does the same to all of them, live while you drag. A thumbnail pinned for before / after keeps its own view; Auto-rotate and Fling to Spin still spin only the active node. In Selected mode, a node you click after a turn appears straight at the new angle: if its picture is from before the turn, it waits a moment for the new one instead of showing the old angle first. (On by default. Off: each node keeps its own view, and nothing jumps when you switch.)
Auto‑rotate with its Speed slider beside it (radians per second) — spin the active node's preview by itself. It keeps the render worker busy the whole time, so it is off by default. (Speed 0.7, range 0.05–4.0.) Follow Cursor steers the spin toward the mouse instead.

Lighting (shared by thumbnails and the Pop‑Out)

Studio HDRI — image‑based lighting with reflections. Pick a built‑in HDRI, load a Custom .hdr/.exr, and set Rotation so the bright side faces the preview.
Sun + Color — a directional sun over a solid Background color (behind the Pop‑Out, and behind the thumbnails when their Background is on), with Sun Strength, Fill Light, Elevation (height above the horizon), Rotation (compass direction), Shadow Softness and Sun Color (white by default, a neutral light; a warm or cool tint colors the lit side while the fill stays neutral: the thumbnails, the Large View and the Pop‑Out all take it).

Both panels draw the same Camera section, so you can set it from wherever you are looking.

Match Lens Thumbnail / Pop‑Out — on, one lens and one projection drive both views, so they frame the same way; off, each keeps its own. (On by default, with a 50 mm perspective lens: the thumbnail, the Large View and the Pop‑Out frame the object the same way and show the HDRI through the same field of view.)
Orthographic — no perspective at all: nothing converges with distance, and the Lens does nothing. Turning it off in the Pop‑Out is what makes it see into a barrel and cast the hard shadow edge on the inner wall that an orthographic thumbnail never shows.
Lens — focal length, 5–250 mm. A short lens exaggerates depth, a long one flattens it. The framing does not change: a perspective camera is pulled back to where a 36 mm sensor covers the same frame, so the shape stays the same size and only the depth changes. Grayed out while Orthographic is on. While you drag the slider, every thumbnail (and the Large View) shows the focal length at its bottom center, 35 mm (or Orthographic), for a couple of seconds after the last change, then it fades out.
Zooming in the Pop‑Out goes as far as in the thumbnails, 60x. A zoom lengthens the lens, and Blender's viewport lens stops at 250 mm (about 4x on the default 50 mm), so past that the Pop‑Out switches to an orthographic view of exactly the same size. A lens that long is nearly flat already, so the switch doesn't jump. Zoom back out and it's perspective again.

Appearance

Scale — thumbnail size relative to the node width. (Default 1.0, range 0.1–4.0.)
Keep Readable + Min Size — never let a thumbnail shrink below Min Size pixels as you zoom out. The Scale slider multiplies this floor too. (On; 80 px, range 20–400.)
Only Into Free Space — zoomed out, a thumbnail held at Min Size grows only into the empty space around its node: it stops short of the nodes above it and beside it and shares the gap with a neighbor's thumbnail, so an overview never turns into a wall of thumbnails covering the nodes. A thumbnail with room gets the full Min Size; one boxed in stays at least its normal size. Nothing moves in the file (node positions, undo and saving are untouched) and zooming back in brings every thumbnail back to its normal size. Off: every thumbnail gets the full Min Size and may overlap. (On.)
Brightness — brightens the thumbnail's lighting only, never your material. (Default 1.0, range 0.1–5.0.)
Edge Softness — feathering of the thumbnail edge; 0 is crisp. (Default 0.)
Corner Radius — rounding of the thumbnail corners; 0 square, 0.5 fully round. (Default 0.09.)
Border — a solid outline around each thumbnail. Match Node Color colors it like the node's header (textures orange, shaders green, output maroon…); turn that off to pick a fixed Color. Width sets its thickness. (Border on, matched, width 0.02.)
Node Labels — draws each node's label above its thumbnail, so nodes stay readable when thumbnails cover their headers (useful in All mode). Run Label & Frame first to populate the names. (Off by default.)
Background — a solid backing behind each thumbnail, so the see‑through parts of a render don't show nodes and wires underneath. With Sun + Color lighting it is that mode's Background color, the same one behind the Pop‑Out, and follows it as you change it; with Studio HDRI (where the Pop‑Out shows the HDRI itself) it is the Shader Editor's own background gray, taken from your theme. Off, thumbnails are transparent. (On by default.)
Engine Badge — stamps the bottom‑right corner of each thumbnail with Cycles or EEVEE on a small dark pill. (On by default.)
Constant Values — prints the number on a thumbnail whose output is the same everywhere: the value, the hex code of a flat color, or a Blackbody's Kelvin / a Wavelength's nanometers (see §11, Numbers on the thumbnails). Off, such a thumbnail is just its flat color. The no image badge stays either way. (On by default.)
Tooltips — the hover info box (see §7); the same setting as in the preferences. (Off by default.)
Technical Details — adds the render details to the tooltip (shape, engine, samples, speed, in‑process or worker). (Off by default.)

Quality

Resolution — render size of each thumbnail in pixels. Higher is sharper but slower, and it is part of the cache key. (Default 256, range 64–512.)
Samples — render samples per thumbnail. (Default 4, range 1–32.)
Progressive + Draft Samples — while you edit a value, render a quick draft, then sharpen to full quality once you settle. Spin, pan and fly frames are always drafts, sharpened on release, whatever this setting. A draft is simply fewer samples, on both engines, so it only kicks in when Draft Samples is below Samples. (Drafts never switch EEVEE's ray tracing or shadows off: those are compiled into every material's shaders, and switching them made a heavy material recompile for five to twenty‑five seconds on every change between a draft and a full frame. The worker keeps ray tracing on for every EEVEE render.) (On; draft 8.)

Organize Nodes

Label & Frame Nodes — names every node and groups the tree into functional Frames (Base Color, Roughness, Normal / Bump, Displacement, shared coordinates, the shader assembly…), packed where the tree already sits. Frames you made are left alone, and clicking it again changes nothing. See §14.
Tidy (within frames) — reflows the nodes inside each frame into clean columns without moving the frames, keeping room above each node for its thumbnail.
Spacing — pushes the tidied nodes apart (>1) or together (<1), live as you drag. (Default 1.0, range 0.3–3.0.)
Find (top of the section) — type part of a node's name, label or type to jump to the first match; the arrow cycles through the rest.
Straighten Links — moves nodes up or down so their links run horizontal. With Reroutes on it lays the tree out in tight columns instead and runs each wire that is still bent through two reroute dots. It acts on the selected nodes when any are selected, even just the one you last clicked: the button then reads Straighten Selected (n), and the small tree button beside it does the whole tree. See §14.
Selected nodes: six align buttons (Left / Center / Right, Top / Middle / Bottom), Spread H / V to space three or more nodes evenly, and Frame Selection to put the selection in a new frame named after what it feeds.
Display: Compact / Expand — hide or restore unlinked sockets and node options (selected nodes, or all when nothing is selected). Color by Category tints node bodies by role (textures, shaders, math…); Reset Colors turns their custom color off, back to the theme (a color you set yourself on those nodes goes too). Both act on the selected nodes, or all when nothing is selected.

Performance (per‑machine settings)

These live in the add‑on preferences (Edit → Preferences → Add‑ons → Loupe Shader) because they describe your machine, not your scene, so they never travel with a .blend. The sub‑panel shows the same controls.

GPU — leave blank to auto‑pick the fastest card, or type part of a card's name (e.g. 4090) to pin the worker to it on a multi‑GPU machine. Works across all backends.
Workers — number of render processes. One is usually fastest on a single strong GPU. With Batch Renders and Interaction Worker on (the defaults), one more process runs on top of this number. (Default 1, range 1–8.)
Instant Texture Nodes — draw pure texture‑node chains (noise, voronoi in 2D, 3D and 4D, wave, magic, checker, brick, gradients, white noise, color ramps, math, mix, map range, mapping, node groups made of these, Image Textures, Texture Coordinates set to another object, and the nodes that read the object: Attribute, Color Attribute, UV Map and Object Info…) directly in this Blender on the GPU: no render worker, no shader compile, spins at full frame rate. Bump, Normal Map and Normal previews are drawn in‑process too, lit like the render. Nodes that read the object's mesh are drawn on the object's own mesh, uploaded once per object and again whenever you edit it (switching between materials never uploads it again), with its real attributes, color layers and UV maps; a custom preview object is drawn the same way. Everything else (shader sockets, displacements, volumes, Bevel, Pointiness, Random Per Island, Tangent, camera / window coordinates) still renders in the worker; hover a thumbnail to see which path it took. Turn it off if such a thumbnail ever looks different from the render. (On by default.)
Instant Drag — while you turn the active node's thumbnail or the Large View, your own Blender draws it with EEVEE, the way the Pop‑Out draws, instead of waiting on a render worker for each frame (see §5). The node's copy compiles out of sight while you look at the node; until it is ready, the workers draw the drag as before. Windows only, EEVEE only: Cycles drags and the cases listed in §5 always use the workers. (On by default.)
- Works with any Shader Compilation Method. A node's copy is taken live the moment EEVEE has compiled it, as the Pop-Out takes it (about a third of a second after the click). A material too heavy to draw without holding Blender's window (a frame over 120 ms, twice) is left to the workers, which then draw its drags as before.
- When the workers draw a drag, a noisy material (fine bump, subsurface, ambient occlusion) is drawn larger with more samples and shrunk, so it stays smooth while it moves, at about 25–30 frames a second.
- The node you are dragging always comes first. With Rotate Together, the other thumbnails turn along when a worker is free, so you can turn a node while the rest of the tree is still rendering.
Warm Other Materials — once you have been idle for 30 seconds, compile the other materials of this file in the background, one at a time, so switching to them is quicker: the materials of the selected objects first, then those of the visible objects, then the rest. It stops after 30 seconds of compiling in a session. Each compile holds the GPU for five to fifteen seconds on a heavy material, which you can feel as a slower Blender, so it is off unless you want it. The status line reads warming file (n materials left)… meanwhile. (Off by default.)
Batch Renders — render every node's thumbnail from one pass of the material (each shown output tapped as a render pass) instead of one render per node, on EEVEE and on Cycles; see §6. Shader‑socket nodes (BSDFs, Mix Shader…) stay per‑node, and so do Cycles spins (cheaper that way). Turn it off to use the classic per‑node renders if batched thumbnails look wrong on your machine. (On by default.)
Interaction Worker — with batching on, keep one extra render process for spins, pans, flies and the per‑node shader previews, so they never wait behind a whole‑tree render. Spins there render on small per‑node copies of the material (see §6, How EEVEE thumbnails are made). Costs one more background Blender (RAM and a GPU context); turn it off on a tight machine. (On by default.)
Enable Pop‑Out — see §13. Off: double‑clicking a thumbnail only selects its node.
Click Picks Material Slot — click a part of an object in the 3D Viewport and its material slot becomes the active one, so the Shader Editor shows the material on that part (a barrel: click the metal band, get the metal material). See §7, Click the mesh to pick its material. (On by default.)
Thumbnail Tooltips and Technical Details — on the preferences page only; in the panel they are Tooltips and Technical Details in Appearance.
Cache Size / Cache Age — bounds for the on‑disk thumbnail cache in your temp folder, with the current size and a Clear button. (Defaults 750 MB, 14 days.)
Below the controls: the card each worker actually pinned to, how many workers are up and ready, and a Stop Workers button while they run. Before the workers start, it shows what the GPU field will pick (Auto: … or Pins to: …), Probing GPUs… while it finds out, or a warning when the name you typed matches no card.

Shortcuts & Help

A cheat‑sheet of every mouse and key control, followed by Shortcuts — where you set the keys yourself (see below); Shortcuts Overlay, which shows the same list in a see‑through card at the top left of the Shader Editor (also Ctrl + Space → Shortcuts; press it again to hide it). Drag the card to put it anywhere, and click its X to close it; Open Manual, which opens this manual as a page in your web browser (the same as the ? in the panel header, the button in the welcome box and the one in the add‑on preferences); and Copy Diagnostics, which puts a support report (versions, GPU, engine, worker state, recent errors) on the clipboard for bug reports. Below it, Email Support starts an email to support@blacklykhen.com in your mail app with the question headings filled in, and With Diagnostics does the same with the report's first lines (versions, GPU) in the email and the full report already on your clipboard, so you only press Ctrl + V where the email says to (a mail link can only carry a short text). If no mail app is set up, the address and the text are put on the clipboard instead.

Changing the shortcut keys

Six Loupe Shader shortcuts are yours to set: Recenter Thumbnail, Next Output, Pin Before / After, Free‑Fly, Pie Menu and Object Faces. Each gets a row with a key dropdown and Ctrl / Shift / Alt toggles, in the panel's Shortcuts & Help section and in Preferences → Add‑ons → Loupe Shader. Pick a key and it is bound straight away — no restart — and every place that names a key updates with it: the shortcuts overlay, the cheat‑sheet above it, the hover tooltip's control line, and the key that leaves free‑fly (the same key that started it always ends it).

If two Loupe Shader shortcuts end up on the same key, both rows turn red and a warning appears; both operators will then fire on that press, so give one of them another key. Restore Default Shortcuts puts every one of them back to the key the add‑on shipped with (grayed out while nothing has been changed).

The keys are a per‑machine preference, like the GPU and cache settings: they stay with this Blender rather than traveling inside a .blend. If Blender's Auto‑Save Preferences is off, press Save Preferences to keep them past a restart.

These are Loupe Shader's own bindings. They do not know what else that key does in the Shader Editor — if you take a key Blender already uses there (say G), Loupe Shader's operator sees the press first while the mouse is over a thumbnail. Pick a free key if that matters to you.

The manual ships inside the extension. Open Manual turns it into a single web page in your system temp folder (LoupeShader_Manual.html, rewritten each time) and opens it with your default browser; it needs no internet connection.

7. Thumbnail interactions (mouse & keys)

These work when your cursor is over a thumbnail (unless noted):

Input	Action
Left‑click	Select the thumbnail's node (never whatever the thumbnail covers, see The thumbnail is on top below)
Shift + click	Add the thumbnail's node to the selection, or take it out again, as Shift + click on a node does
Left‑drag on a 3D shape	Turn the preview freely, and it stays exactly where you let go (style set by Drag Rotation, see Grab rotation below).
Double‑click	Large View on / off: the active node large in a corner of the Shader Editor (see §13)
Scroll wheel	Zoom the thumbnail in/out (instantly, 1.3x a notch), from 0.3x to 60x. With a perspective lens, zoom lengthens the lens (like a telephoto) and never moves the camera into the object
Middle‑drag	Pan the preview within the thumbnail, one to one with the cursor
C	Recenter — move that thumbnail's object back to the middle (and leave free‑fly's camera); the zoom and the angle stay
Shift + ` (backtick)	Free‑fly the preview camera (keys below)
V	Cycle the node's outputs (see §8)
Shift + W	Object Shape: Material Faces → Textured Others → Gray Others (also in the Pop‑Out; see §9)
P	Pin the thumbnail for a before / after comparison; P again unpins (see Before / after below)
Left‑drag across a pinned thumbnail	Move the before / after divider
Esc or right‑click during a drag	End the rotate or pan where it is (a divider drag goes back to where it was)
Ctrl + Space	Open the add‑on's pie menu
Tab on a node group (Blender's own key)	Enter the group: its nodes get thumbnails too (see §11, Inside node groups)

All of these pass through to Blender's normal behavior when you're not over a thumbnail, so regular node selection, view zoom/pan, and group editing are untouched elsewhere.

The thumbnail is on top. With nodes close together a thumbnail often covers part of another node: its sliders, fields or panel arrows. Clicks, drags and double‑clicks on the thumbnail are the thumbnail's; they never reach the node underneath, so a drag turns the shape instead of dragging a hidden slider, and a double‑click never starts typing into one. Moving across a thumbnail doesn't highlight the widgets under it or pop up their tooltips, and Enter and Backspace over a thumbnail never type into or reset one either. (Blender still highlights a widget the cursor lands on straight from outside the thumbnail, and keeps it highlighted until the cursor leaves the thumbnail, so other keys that act on the widget under the mouse, such as Ctrl + C / V to copy or paste a value, can still reach it there.) Where two thumbnails overlap, the one drawn on top gets the click.

Mouse Buttons. The buttons above are Left Drag, the default: left‑drag turns and middle‑drag moves, on a thumbnail and the Large View. The Pop‑Out works the same: left‑drag turns the shape exactly as on its thumbnail (same Rotation Style and speed, no stop at the top), middle‑drag moves and the scroll wheel zooms, and those are the node's own view, so its thumbnail and the Large View move and zoom with it (and a pan or zoom on them moves the Pop‑Out). With Mouse Buttons: Blender it is middle‑drag to orbit and Shift + middle‑drag to move, as in any viewport. Only the Pop‑Out: every other 3D Viewport keeps Blender's buttons, and a left click there selects as always. Switch to Blender (Middle Mouse) with Mouse Buttons in the add‑on preferences, or untick Left Drag in the Loupe Shader sidebar (under Fling to Spin): middle‑drag then turns, Shift + middle‑drag moves, a left click only selects, and the Pop‑Out's left button selects again. The shortcuts card, the Large View's hint line and the tooltips follow the setting.

Grab rotation. How a drag turns the shape is set by Drag Rotation in the add‑on preferences:

The front of the shape moves with the cursor, and letting go leaves it exactly where the cursor put it. It works the same on world thumbnails (the view turns round the ball) and lights.

Tilt & Spin — left and right spins the shape about its own up axis; up and down tilts it toward or away from you and stops at a straight top or bottom view. The shape never rolls sideways, and dragging back to where you pressed undoes the turn exactly.
Spin Only — a turntable: left and right spins, up and down is ignored.
Free (default) — any orientation: up and down tips the shape about the screen's horizontal, left and right spins it about Z at whatever tilt it is at. Each drag turns from where the shape is, so it can end up upside down or rolled.

Pan and zoom follow instantly. Middle‑drag moves the picture one to one with the cursor, and the scroll wheel zooms it, straight away: the last rendered frame is shifted and scaled to the new pan and zoom while the fresh render is on its way, so the picture never lags behind and then jumps. Frames rendered during a pan cover 1.6 times the thumbnail, so a shape bigger than its thumbnail has its sides ready as you move it instead of showing them cut off. Zoomed in, a thumbnail also keeps a whole picture of its angle (rendered in the background after you let go), so zooming back out shrinks that one and never shows the object's sides cut off.

Fling to Spin (Preview section, off by default). With it on, letting go of a thumbnail while flicking it keeps it turning about the same axis, slowing to a stop; only a real flick does that, released while the mouse is still moving fast, and a drag that stops before you let go never spins. Any click, scroll or Esc stops a spin, and that click still does its normal job (selects a node, starts the next drag).

Free‑fly (Shift + ` over a thumbnail) takes over the mouse until you leave it; the Shader Editor header lists the keys meanwhile:

Key	In free‑fly
Move the mouse	Orbit around the preview: the shape follows the mouse, with no limit in any direction, and the camera never rolls
A / D	Orbit sideways
Q / E	Orbit under / over (the camera sinks / rises)
W / S or the wheel	Move closer / further
R	Reset to the starting view
Esc, a click, or Shift + ` again	Leave free‑fly (the view is kept; C resets it)

Before / after. Press P over a thumbnail (or Pin Before / After in the Preview section for the active node) and keep editing: the thumbnail keeps the frame it showed when you pinned it on the left of a white divider, labeled before, and shows the live result on the right, labeled now. Press or drag across the thumbnail to move the divider: all the way right shows only before, all the way left only now. The hover tooltip says how long ago it was pinned, and with Range Check on it gives the verdict for both. P again (or Unpin) goes back to the normal thumbnail.

A pinned thumbnail's view is frozen, since the pinned frame cannot turn: dragging moves the divider instead of turning the shape, the scroll wheel and middle‑drag go to the editor as they do off a thumbnail, C and free‑fly are refused with a note, and Auto‑rotate leaves it alone. To look at it from another side, unpin it, turn it, and pin again. Pins last for the session and each output of each node can have its own; opening another file drops them.

Auto‑rotate (Preview section) spins the active node's thumbnail by itself; with Follow Cursor on, it turns toward the mouse, faster the further the cursor is from the thumbnail.

Rest the cursor on a thumbnail and a small box appears beside it that tells you, in plain words, what you are looking at and whether it looks right:

The node (and which output, when it has more than one).
What the preview means: "A gray surface lit with this normal: bumps and dents catch the light", "A checker grid laid out by these coordinates…", "The value as gray: black is 0, white is 1" (see §11).
When not to take it literally, in orange: a node that reads your object (Ambient Occlusion, Bevel, Geometry, Attribute, UV Map, Object Info, the mesh outputs of Texture Coordinate…) is shown on the preview shape, not your mesh; an Image Texture with no image; a thumbnail previewed in EEVEE while you render in Cycles (or the other way round); light nodes in an EEVEE scene; a Script node, which updates slower.
The value readout, explained (when Value Readout is on): "All 0: this output has no effect", "The same value everywhere", "Barely changes (0.30 to 0.40): a mask or factor from this will look flat. A Map Range or Color Ramp can stretch it", "Goes above 1" / "below 0", followed by the range and average.
The Range Check verdict with what to do (when Range Check is on): "Base Color (non‑metal): 20% of the surface is too dark - nothing real is darker than charcoal (sRGB 30): brighten it", "Metallic: 40% of the surface is part metal - use 0 or 1", "Roughness: 5% of the surface is above 1 - Blender cuts it to 1: add a Clamp or Map Range". A pinned thumbnail adds the verdict from before pinning.
When it is pinned, how long ago, and how to compare and unpin.
A short controls reminder for the first few thumbnails you hover in a session; the pie menu's Shortcuts card lists every key.

Turn on Technical Details to add the render details: preview shape, engine and samples, speed per node, whether it was drawn in‑process or by a worker (and why), and the full controls line. Use it when a thumbnail looks wrong.

The tooltip hides while you drag, and fades after a few seconds if the mouse stays still. It is off by default: turn it on with Thumbnail Tooltips in the preferences or Tooltips in the panel's Appearance section.

Click the mesh to pick its material

On an object with more than one material, click the part you want in the 3D Viewport and the Shader Editor switches to that part's material: click a barrel's metal band and you get the metal material, click the wood and you get the wood. Loupe Shader makes that part's material slot the active one (the same as picking it in Properties → Material), so the thumbnails and any open Pop‑Out follow it too.

Object Mode: the face under the cursor decides. The click still selects the object as it always does; if it selects a different object, the slot is picked on that object.
Edit Mode: the active face decides (the last face you clicked in face select). Clicking a vertex or an edge leaves the slot as it is.
Dragging (a box select, a tweak) never changes the slot: only a click that stays in place counts.
Objects with a single material are left alone.
Modifiers are taken into account: the face you see (beveled, subdivided…) is the one that counts.
Turn it off with Click Picks Material Slot in Edit → Preferences → Add‑ons → Loupe Shader (or the panel's Performance section). It is a per‑machine setting. (On by default.)

8. Multi‑output previews & V cycling

Nodes with several outputs (Texture Coordinate, Voronoi, Separate Color, etc.) can preview any one output or all at once.

V cycles the active node through its outputs one at a time, then All, then wraps back to the first. It works from anywhere in the editor — you don't need to hover the thumbnail. (If you do hover a specific thumbnail, V targets that node instead.)
The output name is drawn above the thumbnail whenever a node has more than one output, so you always know which one you're looking at. Single‑output nodes show no label.
You can also click an output directly: the panel's Preview section lists one button per output, plus All, under the active node's name, and the Pop‑Out's N‑panel has the same picker.
All draws every output of the node side by side, each with its name.

V only hijacks nodes with 2+ outputs; on single‑output nodes it falls through to Blender's normal V.

9. Preview shapes & custom objects

Object Shape (Preview section, on by default) previews every thumbnail on the object that uses the material — and only on the faces that material actually covers. A two‑material barrel's metal material shows just the metal bands, its wood material just the wood; open its node in the Pop‑Out and the Pop‑Out is cut to the same faces. This is what most thumbnails should look like most of the time: the material's own object, in the shape it actually surfaces.

On a mesh where materials are painted face by face (a scan, a sculpt with worn paint), the faces of one material leave jagged holes. Whole Object keeps every face: with Textured Others the ones this material doesn't cover keep their own materials; with Gray Others the ones the material doesn't cover turn plain gray. Shift + W cycles the three, in the Shader Editor and in the Pop‑Out.

The Shape setting (labeled Other Shape while Object Shape is on) picks the mesh used instead: when Object Shape is off, or for the handful of node kinds Object Shape never covers (below). The default is Cube.

Auto picks per node: a sphere for shaders, a flat plane for textures, colors and values; and where a shape matters, Suzanne for Ambient Occlusion (it needs crevices), the cube for Bevel (hard edges) and for volumes, the sphere for Sky and Environment textures.
Sphere / Flat / Cube / Pyramid / Cylinder / Torus / Suzanne use that shape for every node. Flat reads a raw pattern best; the sphere shows reflections and roundness; the cube, cylinder and torus show how a material wraps.
Custom Object previews on any object in your scene, with its modifiers and geometry nodes applied, centered and scaled to fit. Its mesh is exported again once you stop editing it.

With Object Shape off, Object Shape for Mesh Data still previews nodes that read the object's own mesh data (Attribute, Color Attribute, UV Map, Tangent, Pointiness, Random Per Island) on the object that uses the material, so they show its real attributes, color layers and UV layout, while everything else uses Shape.

Some thumbnails keep their own scene whatever Object Shape and Shape say: World and Light trees (mirror balls, a chrome and a gray ball, a lamp on a wall; §11), the Mix Shader's three balls, and color/value swatches.

10. Lighting

Lighting applies to both the inline thumbnails and the Pop‑Out window.

Studio HDRI gives realistic image‑based lighting and reflections. Choose a built‑in HDRI or load your own, and rotate it so the bright part faces the preview.
Sun + Color is a cleaner, controllable directional setup: set the sun's elevation (height above horizon), rotation (compass direction), Sun Strength, Fill Light, Shadow Softness and Sun Color (white, neutral, by default; tint it warm or cool and the lit side takes the color while the fill light stays neutral), over a flat background color. Good for evaluating a material under predictable light. Reset Lighting puts the color back to white with the rest.

With EEVEE, the HDRI's bright areas (a studio's softboxes, the sun in an outdoor HDRI) are found and turned into soft sun lamps of the same size, direction, color and power, the rest staying in the world. So EEVEE thumbnails are lit and shadowed like the Cycles render of the same thumbnail, and the in‑process previews use the same lights.
World and Light trees are not lit by these settings: a world's thumbnails are lit by that world, a light's by that lamp.
HDRI Follows Drag (Studio HDRI; Light Follows Drag for Sun + Color) — with it on, a drag turns the camera round the object instead of the object, so the HDRI, the sun and their reflections turn with the drag, exactly as a drag in the Pop‑Out does. It is on by default. Off, the lighting stays put and the object turns under it. The thumbnails, the Large View and the 3D Pop‑Out share one camera, so all three follow it. Orbiting the Pop‑Out moves that camera too. Flipping the toggle never makes the picture jump.
Brightness (Appearance) brightens the thumbnails' lighting only, never your material or the Pop‑Out.

Note: fully metallic materials read as mirrors — they mostly reflect the environment, so moving the sun only shifts a specular hotspot. Studio HDRI usually reads better for metals.

11. Displacement & value readout

The Material Output's final thumbnail honors your material's real displacement (the Displacement socket and the material's displacement method), so true geometry relief shows in that thumbnail and in its Pop‑Out.
Value Readout measures the min / max / average of the focused node's output (a second after you stop editing) and shows it on the thumbnail (Min 0.30 Avg 0.35 Max 0.40, or measuring... until it arrives) and, explained, in the hover tooltip. This is the fastest way to see a mask or factor's true range — e.g. min 0.30 / max 0.40 tells you a factor is barely varying, which often explains a flat‑looking result. With EEVEE the numbers come straight from the thumbnail's own render pass (measured over the visible surface of the preview shape); with Cycles they come from a small extra flat render.

What each thumbnail shows

A socket's raw value is not always a picture worth looking at: a normal is a flat blue, a displacement vector is black, a coordinate is a color wash, a volume shader plugged into a surface is nothing, and a constant is a gray square. So every output is classified by what it is, and rendered the way it is meant to be seen. Hover a thumbnail: the tooltip says in plain words what the preview shows. With Technical Details on it also says whether it was drawn in‑process (instant) or by a render worker, with the reason (for example a node the evaluator does not cover).

Output	What the thumbnail shows
Material Output	The final material: the real surface and the real displacement.
Surface shader (BSDFs, Emission, Mix Shader…)	The shader, lit on the shape.
Volume shader (Principled Volume, Scatter, Absorption, Volume Coefficients, and Add / Mix Shaders that join volumes)	The shader rendered as fog inside the shape (a cube in Auto). A surface would show nothing. A lone Volume Absorption only darkens what is behind it, so it is shown in front of the checker backdrop.
See‑through shader (Transparent, Glass, Refraction, Translucent, Ray Portal, Holdout)	The shader on the shape in front of a checker backdrop that fills the whole view, so refraction and transparency have something to show. A Holdout is a shape‑shaped hole in the backdrop.
Normal (Normal Map, Bump, Bevel, Normal node, the geometry normals)	A neutral gray material lit with that normal, so bumps and grooves are what you see, not blue. Bump, Normal Map and Normal previews are drawn in‑process (instant); Bevel needs the renderer.
Displacement (Displacement, Vector Displacement)	The displacement applied to real geometry on a gray surface. On the cube and pyramid the faces are kept welded while displaced (flat‑shaded faces would each move along their own normal and crack apart). Very strong settings still turn the shape inside out, exactly as the render does: Midlevel above 1 with a large Scale pushes the whole surface inward by more than the shape's size.
Any other vector (Texture Coordinate, Mapping, Vector Math, Combine XYZ…)	A checker grid drawn through the coordinate, tinted by its direction: a rotation, scale or offset moves the grid; you see the transform, not a color. Geometry Position is world space, so its grid slides across the shape as you turn it — the same swim a real object shows when textured by Position.
Color	The color, as is.
Value	The value as gray.
A constant (Value, RGB, a Math node on constants, Light Path, Object Info…)	The number itself, large, on the thumbnail — or the hex code for a constant color — instead of a bare gray square (see Numbers on the thumbnails below).
Image Texture with no image	A "no image" badge; nothing is rendered.
Mix Shader	Three balls side by side: shader A, the mix factor as gray, and shader B, so you see what is being blended and where.
Blackbody, Wavelength (with a typed value)	A flat swatch of the color, labeled with its temperature ("6500 K") or wavelength ("550 nm"). Driven by a texture, they show the color as usual.
Nodes that read mesh data (Attribute, Color Attribute, UV Map, Tangent, Geometry Pointiness / Random Per Island)	Drawn on the object that uses the material (the active object if it does, else the first one in the scene), so you see its real attributes, color layers and UV layout instead of the preview shape's. Attribute, Color Attribute and UV Map chains are drawn in‑process on that mesh (instant); Pointiness, Random Per Island and Tangent render in the worker. With Object Shape on (the default), every other node previews on the object too; turn that off, and Object Shape for Mesh Data (Preview section) with it, to keep every node on the chosen Shape.
Object and scene values (Attribute set to Object or Instancer, Attribute set to View Layer, Object Info Color / Alpha)	Read from the object that uses the material (its custom properties, then its mesh's; its viewport color) and from the view layer, scene and world, and given to the preview shape, so the thumbnail shows what the object would. Editing the property or the color re-renders. Object settings other than the color (a location, say) are not copied onto the preview shape.
Material Lighting nodes (Blender 5.3+: Light Info, Light Evaluation, Shadow Raycast, an Attribute set to Light, a Vector Transform in Light space, and what they feed up to the Light Accumulation)	These values only exist while a light is being evaluated, so each one is shown summed over the preview's lights through a Light Accumulation of its own (white color): what it adds to the lighting. Light Evaluation's Factor shows the light falling off over the shape, Light Info's Color the lights' color, Shadow Raycast the shadowed side. The Light Accumulation and the Material Output show the material as it renders. Cycles has no Material Lighting nodes yet (it renders them black, as a Cycles render of your material does): in Cycles these thumbnails are black, marked No light nodes in Cycles, and the tooltip says to switch to EEVEE.
Script (OSL) nodes, and anything they feed	Rendered in Cycles on the CPU, whatever the thumbnail engine: that is the only place Blender runs scripts (in EEVEE a Script node outputs nothing). The rest of the tree keeps its engine. Expect these thumbnails to take a little longer, and the first one to wait for the script to compile. The hover tooltip says a Script node updates slower; with Technical Details on it shows "OSL script (Cycles, CPU)".

Numbers on the thumbnails

A big number in the middle of a thumbnail means the node gives that same value at every point of the shape. Nothing in its output changes from place to place, so a picture would only be a flat gray square. Loupe Shader writes the value on it instead.

On a Value node that is expected. On a texture or a node fed by one, it usually means a setting flattens the result. Example: a Map Range after a Wave Texture shows a big 0. Its To Min and To Max are both 0, so every input is mapped to 0 and the waves are gone. Set To Max to 1 and the waves come back and the number disappears.

Everything a thumbnail can have written on it, and what it means:

On the thumbnail	Where	What it means
A number, large, e.g. `0.5`, `2`, `-0.25`	center	The output is the same value everywhere (a Value node, a Math node on constants, a Light Path output…), so instead of a plain gray square you get the value itself, to three decimals with trailing zeros dropped (`0.500` shows as `0.5`; from 1000 up in short scientific form, `1.2e+03`). It is the node's real value, read from the render's raw floats, so it is exact above 1 and below 0 too, and does not depend on the view transform (AgX, Filmic…).
A hex code, e.g. `#BC7C59`	bottom	The output is one flat color everywhere. The code is that color in sRGB, the same code Blender's color picker shows for it, so you can paste it into an RGB node. Channels above 1 are shown as FF.
`6500 K` / `550 nm`	center	A Blackbody or Wavelength node with a typed‑in value: its temperature or wavelength, on a swatch of the color it makes. Fed by a link, it is labeled like any other output.
no image	center	An Image Texture with no image loaded. Nothing is rendered.
`12% too dark`, `3.5% above 1`, `40% part metal`…	top‑left, colored pill	Range Check (only when it is on): the share of the preview shape that is out of range for the input this output feeds (see Range Check below).
Cycles / EEVEE	bottom‑right, dark pill	Engine Badge: which engine rendered this thumbnail.
Output name (Color, Fac, Final…)	above	The node has more than one output: which one this thumbnail shows. Final is the Material Output's finished material.
Node label	above, yellow	Node Labels (Appearance section) is on.
starting renderer…, rendering…, compiling shader… first time: 6 s, waiting for a shader compile…, building GPU kernels… first time only	center of a dim box	The first picture is still on its way; see Waiting for the first thumbnails in §6.

A few rules for the big number:

It is exact for a settled thumbnail. While you drag a slider or spin the shape, the draft frame's number is read off its pixels and can be off by a little (and clipped to 0–1) until the full frame lands a moment later.
A texture that happens to be flat on the preview shape (a Noise with Detail and Distortion that wash out, a mask that is 1 everywhere) gets a number too: it is measured, not guessed from the node type.
It is the average over the visible shape, so a value that changes by less than a few 8‑bit steps still counts as flat. Turn on Value Readout for the exact min / max.
Very small thumbnails (zoomed far out) leave the number off so it does not cover the picture.
Turn them all off with Constant Values in the Appearance section.

World and Light node trees

Thumbnails also work in the World editor (Shader Editor → World) and on a light's node tree (select a light; its tree shows in the Shader Editor).

In a World tree	What the thumbnail shows
World Output, Background and any shader	A chrome ball and a gray ball lit by that world — the chrome one shows what it reflects, the gray one how it lights — with what the camera sees behind them. A Light Path → Is Camera Ray split reads at a glance: the backdrop is the camera's world, the balls the lighting world.
Sky Texture, Environment Texture, noise, ramps… (colors and values)	A mirror ball reflecting that output as the sky, the whole sphere of directions in one disc. Texture chains, ramps and Environment Textures draw in‑process (instant); Sky Texture renders in the worker.
Texture Coordinate and other directions	A mirror ball with a checker grid through the direction.
Volume shaders (Principled Volume, Volume Scatter / Absorption into the World Output's Volume)	The two balls inside that fog, lit by a lamp in front of them, above and to one side, so their fog shadows fall behind them instead of towards the camera. Infinite world fog swallows every light that comes from infinitely far away — the sky and any sun — in Cycles and EEVEE alike, so only a lamp inside the fog shows it; a world with fog and no lamps renders black. Denser fog hides the balls sooner and brightens the air around the lamp; the balls themselves never move.

Drag a world thumbnail to turn the view around the ball.

In a Light tree	What the thumbnail shows
Every node, the IES Texture included	The light the lamp throws on a wall, lamp just in front of it pointing down; an IES profile shows its cut‑off and pool. Rendered in Cycles whatever the thumbnail engine (EEVEE has no light nodes); the power is exposed once per node so any lamp reads, then kept, so a value edit shows as brighter or darker. Drag to tilt the lamp.

Inside node groups

Tab into a node group and its nodes get thumbnails too, nested groups included, in materials, worlds and lights. A group can be used several times with different inputs, so the thumbnails inside show the instance you entered (the group node you pressed Tab on): its Group Input values come from that node and whatever feeds it outside. Texture chains inside a group draw in‑process as usual; everything else renders on its own copy of the material in which the group has a hidden extra output wired to the node. Editing a value inside the group, or the group node's inputs outside, re‑renders what depends on it, and when you Tab back out the thumbnails outside (the Material Output included) show the edit. The group's own Group Input and Group Output nodes have no thumbnail. Double‑click a thumbnail inside a group for the rendered Pop‑Out (§13).

The preview shapes carry a UV map and a color attribute ("Col"), so UV Map, Image Texture set to UV, Color Attribute / Vertex Color and Tangent all have something to show. Environment Textures preview as a mirror ball (the Reflection coordinate) when their Vector input is empty. With the Auto shape, Ambient Occlusion previews on Suzanne (it needs crevices), Bevel on the cube (it needs hard edges; Cycles only), Sky and Environment textures on the sphere.

Range Check

Turn on Range Check (Preview section, or the pie menu) and every thumbnail whose output feeds an input with a meaningful range is checked against that input, with diagonal stripes over the offending parts and a small badge in its top‑left corner giving the share of the shape that is off (only shares of half a percent and more are shown). The active node's thumbnail always says what was found, even when nothing is wrong: Base Color (non‑metal): in range, or Range Check: feeds no checked input when its output goes into nothing with a range. A thumbnail is judged by the input it feeds, through reroutes, because that is where a value matters: a Noise going above 1 into a Math node is fine, the same Noise straight into Roughness gets clipped.

Its output feeds	Checked for	Stripes
Base Color of a Principled BSDF with Metallic at 0 (or a Diffuse BSDF's Color)	a real non‑metal surface: sRGB 30 to 240. Darker than charcoal is too dark, brighter than fresh snow (or a saturated pure color) too bright	blue: too dark, red: too bright
Base Color of a metal (a Metallic BSDF, or a Principled whose Metallic is 0.5 or more, typed in or from a Value node)	a real metal: sRGB 180 to 255	blue: too dark
Base Color of a Principled whose Metallic is driven by a map	too dark only (the map decides which parts are metal)	blue
Metallic	between 0.1 and 0.9: neither metal nor non‑metal (fine along a blend edge, wrong across a surface)	yellow: part metal
a 0–1 input (Roughness, Alpha, the weights, a Mix or Mix Shader factor…)	below 0 or above 1, which Blender clips	blue: below 0, red: above 1

Nothing is checked for color inputs of Mix and Math nodes, vectors, normals, Emission (it is meant to go above 1), rotations, a Mix with Clamp Factor off (it extrapolates on purpose), or the shader and final thumbnails (they are lit). Values below 0 and above 1 are measured on the real floats of the render, where the thumbnail itself (8‑bit) holds them clipped: the batch renders and the in‑process thumbnails send that measure along (it costs well under a millisecond), so the badge's share is exact and the stripes sit on the clipped pixels. A thumbnail rendered on its own copy of the material (a shader socket, Batch Renders off) only gets the sRGB checks. The hover tooltip names the check and lists every verdict, worst first, or in range.

12. Animated / moving‑texture preview

Thumbnails are frame‑aware: whenever the timeline frame changes, previews re‑render at that frame, with the worker evaluating the scene at the current frame first. So anything animated in your material moves in the previews — 4D Noise/Voronoi W inputs, #frame drivers, keyframed values, Wave phase, animated Mapping.

To preview moving textures:

Animate something. With a 4D Noise/Voronoi, right‑click its W value field → Add Driver, set the expression to frame/24, and delete the auto‑added empty variable. (Or keyframe a Mapping rotation, a Wave phase, etc.)
Make sure Loupe Shader is On.
Scrub the timeline or press Spacebar to play.

Texture chains drawn in‑process keep up with playback. Everything else is a real re‑render each frame, so it runs at the render rate rather than a smooth 24 fps. For the smoothest result, preview a single Selected node rather than the whole tree.

13. Large View, Backdrop and the 3D Pop‑Out

Large View

Double‑click any thumbnail (or turn on Large View in the panel or the pie's N box) and the active node is shown large in a corner of the Shader Editor — bottom left by default. It follows whichever node you make active, renders at its own size (512 to 768 px while you drag; when you let go, as many pixels as it is drawn with, from 768 up to 2048 px on a large or 4K screen, in the same engine as your scene) with the studio HDRI (or the Background color) behind the object, and is color‑managed exactly like the thumbnails. Everything that works on a thumbnail works on it: left‑drag turns, scroll zooms, middle‑drag moves (middle‑drag and Shift + middle‑drag with Mouse Buttons: Blender), C recenters (anywhere over it, its title included). Double‑click it again to close it. Corner and Width set where it sits and how much of the editor it takes. Match Node Color (off by default) colors its frame with the node's header color: green for a shader, maroon for the Material Output, and so on. It also shows World, Light and node‑group trees.

Backdrop

Backdrop draws the same picture behind the whole node tree, as the compositor's backdrop does, with the compositor's keys:

Key	Does
V	zoom the Backdrop out
Alt + V	zoom the Backdrop in
Alt + middle‑drag	move the Backdrop
Alt + Home	fit it again

With the cursor over a thumbnail, or with the Backdrop off, V keeps its Loupe Shader meaning (Next Output). Zoom and offset are also in the panel.

3D Pop‑Out (live viewport)

3D Pop‑Out (the button under the Large View settings) renders the active node at size, following whichever node you make active, with the shared Lighting settings, as a split area: the Shader Editor is split and the new area becomes a 3D Viewport in local view on a preview object that lives in your own scene, parked far below the origin in a render‑disabled collection called SP_POPOUT_preview. Close Pop‑Out (the small × next to the 3D Pop‑Out button, or in the Pop‑Out's own N‑panel, which opens hidden so it doesn't cover the preview: press N in the Pop‑Out for its Close, Lighting, Camera and Object Shape controls) removes the preview object and joins the area back. Closing the area yourself, or changing its editor type, does the same. If Blender ever crashes with one open, the leftover preview object is swept away the next time the add‑on loads or a file opens.

EEVEE Pop‑Outs use Material Preview shading with the studio HDRI shown behind the object. A Cycles Pop‑Out (with Match Lens and Sync Thumbnail / Pop‑Out on, the defaults) draws the thumbnail's own frames, rendered zoomed out to fill it, so the thumbnail, the Large View and the Pop‑Out always show the same picture: drag frames at 768 px, then a sharp frame the size of the Pop‑Out (up to 1280 px) when you let go. With Sync off it uses Blender's Rendered shading when your scene's render engine is Cycles; a viewport cannot run a different engine than its scene, so with any other scene engine it shows EEVEE and says so in the N‑panel.
Studio HDRI shadow. In EEVEE, the Pop‑Out and the render workers split the studio HDRI the same way. A copy of the HDRI with its brightest part taken out lights the object, and that part becomes one sun lamp (the Pop‑Out's is in the preview collection) that casts the hard shadow. This way the shadow and the color of the shade match in all three views, whatever your world's Sun Shadow setting. EEVEE's own extraction left the shade slightly bluer. Your world is never changed. The copy lives in your temp folder and is listed as a studio light only while Loupe Shader is enabled.
Sun + Color lighting uses a sun object in the preview collection, and the chosen Background color is a large backdrop around the preview object (Material Preview shading ignores the viewport's own background color). It shows only in the Pop‑Out, casts no shadow and is never rendered; it is the same color as Appearance > Background (one shared color, defaulting to the Shader Editor's gray; Editor Gray resets it). The backdrop is compensated for your scene's view transform so it shows the exact picked color; only a color more saturated than the view transform (e.g. AgX) can display comes out as the nearest one it can.
Smooth on noisy materials. A viewport refines only up to the scene's Viewport Samples (16 by default), which leaves Ambient Occlusion, Shader to RGB and hashed shadows speckled. While a Pop‑Out is open, Loupe Shader raises the scene's viewport samples to 256; your value comes back when the last Pop‑Out closes, before every save (it is never saved in the file), when the add‑on is disabled and when a file opens.
Thumbnails are color-managed like the Pop-Out: they go through the scene's view transform, look, exposure and gamma (Render Properties > Color Management), so both show the same brightness and contrast. Changing any of these re-renders the thumbnails.
The sun and the HDRI stay put in the world, in every view. Orbiting the Pop‑Out moves the camera the thumbnails and the Large View share, so they turn with it, and the lighting falls on the object the same way in all three.
Appearance > HDRI Background (Studio HDRI only) draws the studio HDRI behind the thumbnails instead of the flat color.
From a maximized Shader Editor (Ctrl Space, or Ctrl + Alt + Space) the Pop‑Out steps back to your layout first and splits there: a maximized editor sits on a temporary screen of its own, which Blender does not allow to be split.
The first Cycles render that uses a new shader feature builds GPU kernels (can take minutes with OptiX, once). The status line and the waiting thumbnails then read "building GPU kernels… first time only".
The Pop‑Out matches the thumbnail. It previews on exactly the mesh the thumbnail you opened it from was showing: with Object Shape on, that's the object cut to the faces its material covers (see §9) — a barrel's metal material opens the Pop‑Out on just the metal bands, not the whole barrel. Switching the active node to one on a different material re‑cuts the Pop‑Out to that material's faces on the fly; switching to a node kind that keeps its own shape (a world, a light, the Mix Shader, a swatch) or turning Object Shape off moves it to the Shape instead. It never shows the full, uncut object while the thumbnail shows only part of it. Whole Object, Textured Others and Gray Others apply to both, and Shift + W works over the Pop‑Out too.

Rendered Pop‑Out (worlds, lights, inside node groups). A 3D Viewport can only show the scene's own world and has no light nodes, so in a World tree, a light's tree or inside a node group the Pop‑Out is a large render of the active node instead (512 × 512, the same picture as its thumbnail at more samples) in an Image Editor split off the Shader Editor. It follows whichever node you make active and every edit, re‑rendering once you let go of a slider or a drag; texture chains draw in‑process, the rest in the render worker. The node's name is shown in its top‑left corner. Close it with Close Pop‑Out, or close the area yourself; its image is removed with it. It never touches your scene's world or lights.

Switching nodes without a gray screen (EEVEE, Blender 5.0 and later). Every node you show in a split‑area Pop‑Out is a new shader, and EEVEE draws an object gray while its shader compiles: up to ten seconds on a heavy material. So the new node's copy compiles on a tiny hidden object first, and the Pop‑Out keeps showing the previous node until it is ready, with compiling Noise Texture… 3 s under the node's name meanwhile; then it switches in one go. A value edit keeps its shader and shows at once, and so does a node whose shader is compiled already: the Pop‑Out notices within a few redraws that no compile started. The very first picture of a Pop‑Out compiles the same way: the preview object stays see‑through, with the compiling… line, until its shader is ready, so it never shows gray. (It no longer compiles the neighboring nodes ahead while you are idle: on a heavy material that froze Blender for two to seven seconds at a time.) Blender 4.5 (which does not report its compiles) switches straight away as before.

The Pop‑Out opens at the same eye‑level 3/4 view the thumbnails use, and the preview object carries the node's pose, so dragging a thumbnail turns the Pop‑Out with it. Clicking other nodes never turns the Pop‑Out: it keeps its angle while you walk the tree. With Sync Thumbnail / Pop‑Out on, every thumbnail of the material the Pop‑Out shows takes the Pop‑Out's angle a moment after it stops turning, so the node you click is already at that angle and nothing re‑renders or turns on the click (a node of another material turns once, instantly, without a fade); with it off, that thumbnail keeps its own angle and the Pop‑Out simply holds still. A click that turns into a drag on a thumbnail turns it (and, synced, the Pop‑Out) as usual. Synced, the scroll wheel in the Pop‑Out zooms the node's thumbnail and the Large View too, as a thumbnail zoom zooms the Pop‑Out. It shows the node, its output and the engine drawing the preview in the top‑left overlay. Its sidebar opens hidden, so nothing covers the preview: press N in the Pop‑Out for its Loupe Shader tab, with Close, Frame (re‑center the view, clearing the zoom and pan of the thumbnails too), the lighting and shape controls, and the output picker for multi‑output nodes. The small × next to the 3D Pop‑Out button in the Shader Editor closes it too, so you never have to open the sidebar to find Close.

14. Organize Nodes: Label & Frame, Tidy, Spacing, Node Labels

These analyze your tree locally (no AI, no internet) and reorganize it non‑destructively — connections are never changed, only node positions, labels, and Frames.

Thumbnails count. Every one of these tools treats a node and the thumbnail drawn above it as one piece (its footprint): nodes are placed so no thumbnail sits on another node, on another thumbnail or over a frame's label, and nothing any tool does leaves two things on top of each other. The room is reserved at the editor's normal size, for every node that can show a thumbnail (selected or not, so selecting one later never covers a neighbor), with the Thumbnail Scale, Show All and the output / node labels taken into account. When you zoom far out, Keep Readable makes thumbnails bigger than their nodes; with Only Into Free Space (on by default) they grow only into the space the layout leaves free, so a tidied tree still reads as tidy. Organizing leaves more space between nodes, and so more room for the thumbnails when zoomed out.

Label & Frame

Labels each node with a friendly name plus what it feeds, e.g. Voronoi → Base Color, Bump → Normal / Bump. It only writes empty or its own previously‑set labels, so your hand‑written labels are safe.
Frames the tree into functional groups based on what feeds the Principled BSDF's inputs and the output's Displacement/Volume: Base Color, Roughness, Metallic, Normal / Bump, Emission, Displacement, plus Coordinates / Shared for nodes used by several chains.
A group needs two or more nodes to get its own frame; the shader assembly (the BSDF, shader mixes, the output) and anything that fits no group go in Shading & Output.
The frames are packed in columns, like Tidy, placed where your tree already sits (it doesn't jump to the middle of the editor): Coordinates / Shared on the left, the input frames (Base Color, Roughness, Normal / Bump, Displacement…) stacked beside it, a new column whenever a stack gets taller than it is wide, and Shading & Output on the right, with Tidy's gaps between them. Inside a frame each separate chain gets its own compact row instead of one big grid with holes in it. The result looks like Tidy with the frames drawn on.
Its frames are sized to hold their nodes and their thumbnails (Blender's own frame fitting ignores thumbnails, which then poke out over the label), so they are fixed‑size frames.
Your frames are left alone. A frame you made yourself, and every node in it, stays exactly where it is and keeps its nodes; the new frames go below it. Only frames Label & Frame made are replaced when you run it again.
Once is enough. The layout depends only on how the nodes are connected, never on where each one happens to be, so clicking Label & Frame again changes nothing.

Tidy (within frames)

Reflows the nodes inside each frame into clean dependency columns, anchored so the frame stays put, with the room for each node's thumbnail kept free above it. Frames Label & Frame made are refitted round their nodes and thumbnails; frames you made are set back to Blender's own fit. It doesn't touch anything outside the frames. (With no frames present, it tidies the whole tree in place.)

Spacing

Pushes the framed nodes further apart or closer together, updating live as you drag. The value is shared by Label & Frame and Tidy, so you can set your preferred density once. After every re‑flow a collision pass separates everything that would otherwise overlap: first nodes stacked inside one frame, then whole frames and loose nodes, re‑measuring after every move and moving things only right or down so the arrangement keeps its shape.

Node Labels

A display toggle (covered in §6) that draws those labels above the thumbnails — pair it with Label & Frame so you can read every node at a glance, even with thumbnails covering the headers.

Layout tools

Straighten Links — every source node moves vertically so its (first) used output sits level with the input it feeds, downstream nodes first, then the collision pass keeps everything clear. Socket positions are estimated from Blender's drawing metrics, so on nodes with many value fields a link may end a few pixels off.
- Reroutes (the toggle under Spacing) — instead of moving nodes up and down, Straighten lays the tree out in tight dependency columns, left to right like Tidy and no taller than Tidy leaves it: inputs left, Material Output right, each node level with the node it feeds where its column has room, the stray inputs of a node stacked in its column, and nothing overlapping. Every wire that is still bent is then run through two reroute dots (flat, straight up or down, flat), so no wire climbs a staircase. Clicking it again changes nothing. Your own reroutes are treated as nodes; the dots the add‑on added are taken out again before every run, and turning Reroutes off removes them. One backward wire between two frames that feed each other can stay bent.
- It acts on the selection. When any node is selected, even just the one you last clicked (clicking a node selects it), only the selected nodes are leveled or get their wires rerouted and nothing else moves. The button then reads Straighten Selected (n) with the count, its tooltip says so, and the status bar reports "… of the n selected only". The small tree button beside it lays out the whole tree without deselecting; clicking empty space first (or Alt+A) does the same.
Align / Spread — act on the selected nodes. Align lines the nodes up on one axis (outermost edge, or the average center) and then packs them along the other axis in their current order, thumbnails included, so Left / Center / Right give a clean column and Top / Middle / Bottom a clean row, never a pile of overlapping nodes. Spread keeps the two outermost nodes and spaces the rest evenly, thumbnails counted. Whatever the aligned or spread nodes land on moves aside; they themselves stay put.
Frame — frames the selection and names it from what it feeds (a Principled input such as Roughness, the output's Displacement, or the consumer's name). The nodes stay exactly where they are and the frame is sized round them and their thumbnails; if it then overlaps a neighbor, one of the two moves aside as a whole.
Compact / Expand — Compact hides unlinked sockets and the node options on each node, which shrinks most trees to a fraction of their height; Expand restores them. These are Blender's own per‑node display flags, saved with the file.
Color by Category — tints node bodies with a darker shade of their category color, the same colors the thumbnail borders use; the × returns them to the theme.
Find — type in the field to jump to the first node whose name, label or type contains the text; the arrow cycles through further matches. The match is selected, made active (so its thumbnail and any Pop‑Out follow) and centered in the editor.

These use Frames (visual grouping) rather than restructuring into node groups, so nothing about how your shader evaluates changes.

Press Ctrl + Space over the Shader Editor for a radial menu of the most‑used controls:

Left / Right: EEVEE / Cycles
Bottom: Stop Workers (stops the background render processes; they start again with the next thumbnail)
Top: Show mode (Off / Selected / All), Focus Selected, and Shortcuts: every Loupe Shader shortcut in a see‑through card at the top left of the Shader Editor (drag it anywhere), until you press it again or click its X
Top‑left / Top‑right: Label & Frame / Tidy
Bottom‑left: Node Labels
Bottom‑right: Range Check

Ctrl + Space is Blender's default maximize area shortcut, but this binding only overrides it while your mouse is over the Shader Editor. You can give the pie menu another key in Preferences → Add‑ons → Loupe Shader → Shortcuts (see §6).

16. Performance tips

One worker on one strong GPU is usually the fastest, lowest‑overhead setup.
Use Selected mode while actively working a single node; All mode is great for an overview but renders far more thumbnails.
Keep Resolution and Samples modest for snappy live updates; raise them when you want a clean look.
Both engines render the whole tree in one pass (see §6). Cycles has no shader compile, so a new material's first thumbnails arrive fastest there; EEVEE compiles a material the first time it is shown, and the idle warm‑ups hide most of that afterwards. Switching engines doesn't relaunch the worker.
Keep Instant Texture Nodes on: texture chains then cost nothing at all.
Script (OSL) thumbnails render on the CPU and are the slowest kind; Selected mode keeps them to the node you are looking at.
Inside a node group, each shader node renders on its own copy of the material, so on EEVEE its first thumbnail is a compile.
Progressive keeps dragging responsive on heavy materials.
For animation playback, preview a single node for the smoothest frame rate.

17. Troubleshooting

Thumbnails don't appear. Make sure Show is Selected/All and a material is open in the Shader Editor. The first launch boots the worker — give it a moment; the status line and a dim box in each thumbnail's place say what it is waiting for (see Waiting for the first thumbnails in §6). The first start on a computer can take a few minutes while EEVEE compiles its shaders.

The Loupe Shader tab is gone after restarting Blender. Blender's Auto‑Save Preferences is off and the enable was never saved: press Save Preferences (☰ menu, bottom‑left of the Preferences window). The panel offers the same button whenever this applies.

A slider/edit didn't update the preview. Turn on Tooltips and Technical Details and hover the thumbnail: the tooltip says whether it was drawn in‑process or by a worker. If something seems stuck, nudge the value again or toggle Show off/on, and if it keeps happening, send the Copy Diagnostics report (or press Email Support → With Diagnostics): it lists what the add‑on is waiting on (queued and in‑flight renders, their age, each worker's background compiles) and the workers' logs, where every render slower than a second names what changed in the scene since the one before.

A thumbnail looks different from the render. If the tooltip (with Technical Details on) says in‑process, turn off Instant Texture Nodes to have the worker render it instead. If it says worker, try turning off Batch Renders. Either way, Copy Diagnostics helps pin it down.

EEVEE thumbnails are frozen and a red box says they are failing. Some GPUs and drivers can't run EEVEE in a background Blender. Use Use Cycles instead in that box if you want Cycles thumbnails; Loupe Shader never switches engines on its own.

Script (OSL) thumbnails are slow or empty. They render in Cycles on the CPU, and the first one waits for the script to compile. The script has to compile in your own Blender first (the Script node's update button; errors go to the system console).

Thumbnails inside a group don't match another place the group is used. They show the instance you entered with Tab, fed by that group node's inputs. Tab into the other group node to see that one.

An Attribute, Color Attribute or Object Info thumbnail is gray or black. These read the object that uses the material: the active object if it uses it, else the first one in the scene. Check that object has the attribute or custom property, and that Object Shape, or Object Shape for Mesh Data if Object Shape is off, (Preview section) is on.

The Loupe Shader panel keeps vanishing or two panels fight. Two copies are enabled; the panel names the other one. Disable it in Preferences → Add‑ons and restart.

The cache is using disk space. Lower Cache Size or Cache Age, or press Clear (Performance).

"Invalid Python expression" when adding a driver. That's a Blender quirk, not the add‑on: Add Driver attaches an empty input variable (shown as a red Object field). Delete that variable; your frame/24 expression is fine on its own. Also make sure you added the driver to the W value, not the Dimensions dropdown.

Metallic material looks dark/mirror‑like. Expected — metals reflect the environment. Use Studio HDRI lighting to read them.

Wrong GPU / runs on CPU. Set the GPU field to part of your card's name. The status box and worker log line show which device was pinned (e.g. pinned to: ['Apple M…'] (METAL)).

18. Shortcut quick reference

Shortcut	Where	Action
Left‑click	over thumbnail	Select node
Shift + click	over thumbnail	Add the node to / take it out of the selection
Left‑drag	over 3D shape, Pop‑Out	Grab and turn (Fling to Spin: flick to keep spinning); middle‑drag with Mouse Buttons: Blender
Double‑click	over thumbnail	Pop‑Out (a rendered one in worlds, lights and groups)
Scroll	over thumbnail	Zoom thumbnail
Middle‑drag	over thumbnail	Pan preview (Shift + middle‑drag with Mouse Buttons: Blender)
C	over thumbnail	Recenter (reset the pan, keep the zoom and angle)
V	active node / over thumbnail	Cycle outputs → All
P	active node / over thumbnail	Pin before / after; again to unpin
Left‑drag	across a pinned thumbnail	Move the before / after divider
Shift + `	over thumbnail	Free‑fly the camera
A / D, Q / E	in free‑fly	Orbit
W / S, wheel	in free‑fly	Closer / further
R	in free‑fly	Reset the view
Esc / click / Shift + `	in free‑fly	Leave free‑fly
Esc / right‑click	during a drag	End the rotate / pan
Tab	on a node group	Enter it: thumbnails inside
Ctrl + Space	Shader Editor	Pie menu
Shift + W	Shader Editor / Pop‑Out	Object Shape: Material Faces → Textured Others → Gray Others
Left‑click	on an object in the 3D Viewport	Make the clicked part's material slot active (Edit Mode: the active face's)

The keys in bold above are the defaults. C, V, P, Shift + `, Ctrl + Space and Shift + W can each be set to any key you like in Preferences → Add‑ons → Loupe Shader → Shortcuts (or the panel's Shortcuts & Help section), with Restore Default Shortcuts to bring this table back — see §6.

19. Notes & limitations

The add‑on never edits your node connections. The Organize Nodes tools change only node positions, labels, and Frames; per‑thumbnail view settings live in small sp_* custom properties on the node (with Rotate Together on, the shared view is on the node tree; see §1); everything else it touches is temporary render files outside your .blend.
A pinned thumbnail keeps its pinned frame for the session only (not saved in the file) and its view is frozen until you unpin it; the before can't be turned to a new angle, since it is a picture of values you have since changed.
Switching engines does not relaunch the worker.
Playback of animated previews runs at the render rate, not real time.
Non‑NVIDIA GPU backends are supported but benefit from testing on your specific hardware.
The Pop‑Out is a split area only; there is no separate floating window (removed — a second OS‑level Blender window could crash on drivers lacking OpenGL 4.3, with nothing an add‑on could do about it).
Resolution tops out at 256 px per thumbnail; the rendered Pop‑Out is 512 px.
Inside a node group, the Group Input and Group Output nodes have no thumbnail, and thumbnails show the instance you entered.
Object and View Layer attributes copy the object's custom properties and viewport color onto the preview shape; other object settings (its location, say) are not copied.
An Attribute set to Instancer reads the object that uses the material; the thumbnail has no instancer.
Material Lighting nodes (Blender 5.3+) respond only to lamps: the preview's sun, or in Studio lighting the sun taken from the HDRI. In Cycles they render black until Cycles supports them.
Script (OSL) nodes need Cycles on the CPU; they are the one kind of thumbnail that never uses the GPU.
Closures, bundles, Repeat zones, menus and text (Blender 5): a Closure, Bundle or Menu output has no picture, nor does the text output of a string node (Blender 5.3), and neither do the nodes inside a closure or Repeat zone (their values only exist while the zone runs), so they get no thumbnail. Evaluate Closure, Separate Bundle, Repeat Output and String Length / String to Value outputs are previewed like any other value.
Engine‑only nodes render as the engine renders them: Shader to RGB and the Specular BSDF are EEVEE only (black in Cycles), and an IES Texture in a material is Cycles only (black in EEVEE). The hover tooltip says so. A Raycast node casts rays at your scene, and the preview shape stands alone, so it has little to hit.
The rendered Pop‑Out (worlds, lights, groups) is a still picture that re‑renders on each change; spin the thumbnail to turn it.

20. License, privacy & disclaimer

License. Loupe Shader is free software under the GNU General Public License v2.0 or later. You may use it on any number of computers, for any purpose, and study, change and share it under the same license. Your renders, materials and .blend files are your own. The full text is in LICENSE, and the terms of sale (updates, support, refunds) are in TERMS.md. Both ship inside the extension folder.

Privacy. Loupe Shader runs entirely on your computer. It never connects to the internet and collects nothing: no accounts, license check, analytics or telemetry. It writes a thumbnail cache and working copies of the material you preview to your system's temporary folder (§6 Performance sets the cache limits and clears it), and stores small sp_* settings in your .blend. Copy Diagnostics only fills your clipboard, and Email Support only opens a new message in your own mail app; nothing is sent until you send it. Its report includes your graphics card, a temporary-folder path that can contain your user name, and log lines that can name your materials and nodes, so read it before you share it. The details are in PRIVACY.md.

Disclaimer. Thumbnails and the Pop‑Out are previews: low resolution, few samples, and often a different engine, shape or lighting than your final render. The Value Readout and Range Check are guides, not measurements. Check the look in a real render before relying on it for client, print or production work. Preview speed depends on your computer: the graphics card first, then the scene and the material. On a laptop or an older card previews take longer, and Cycles previews on the CPU take a lot longer. Loupe Shader runs extra background copies of Blender that work your graphics card hard, and Blender or a driver can crash on heavy scenes, so save often and keep backups. Loupe Shader is provided as is, without warranty of any kind, and our liability is limited as set out in TERMS.md (sections 8 and 9), as far as the law where you live allows. Nothing there takes away your consumer rights.

Loupe Shader is an independent product, not made, endorsed or supported by the Blender Foundation. Blender is a registered trademark of the Blender Foundation.

Loupe Shader — live shader‑node thumbnails for Blender. Happy shading.

Terms of sale · Privacy · Compatibility and known issues · Support and FAQ