FORGED BY SIN/ HOURGLASS PROCESS PROOF

4:55 output · 4,432 screen captures · 25 Blender checkpoints

The look is authored before the renderer presents it.

We retained the recording one frame at a time, investigated how it was captured, executed the exact Blender 5.1.0 and Ucupaint 2.4.5 pair, and rebuilt the visible process as 25 downloadable checkpoints.

  • 4,432 frames retained one-for-one
  • Original-resolution UI audit
  • Exact media and tool hashes
  • Blender 5.1.0 + Ucupaint 2.4.5 executed
  • 25 real `.blend` stages
  • No renderer migration
SquareAnon's completed low-poly hourglass with warm painted wood, pale sand, and blue glass on black
SquareAnon’s completed hourglassSource post ↗

The direct answer

It is not one magic renderer.

For this asset, SquareAnon deliberately paints form light, edge light, wood grain, trim shine, contact shadow, ornament, glass opacity, and sand variation into different asset channels. The material then combines those channels. A renderer switch alone would not invent those decisions.

First: what the recording contains

A one-second UI microscope—not continuous mouse telemetry.

The final recorded screen shows Chronolapse set to one second between captures. Those screenshots were encoded at 15 frames per output second: a 4:55 video compresses roughly 74 minutes of work.

SquareAnon's Blender interface at source frame F3333, showing the glass mask image dialog at 128 by 128 pixels
F3333 · original UI excerptThe dialog visibly reads 128×128 and Closest. The separate 1024 value at right belongs to a baker panel.
01 · observed

Pixels and persistent UI state

Modes, active panels, field values, menus, object names, brush headers, and the Blender-drawn paint circle can be read directly when visible.

02 · reconstructed

Operations executed in the exact tools

We replayed the recoverable modeling, Ucupaint layer, mask, material, sand, UV, and parenting operations in Blender 5.1.0 with Ucupaint 2.4.5.

03 · inferred

Input between snapshots

Chronolapse captured the screen through a desktop bitmap copy and did not composite the operating-system arrow. A state change can prove an operation occurred without preserving its exact click or key path.

Five-frame worked example

How a UI transition becomes an honest process step.

Swipe the table to reveal the claim boundary →

FrameVisible stateWhat it supportsWhat it cannot prove
F3330New Image dialog, 1024×1024, ClosestInitial mask-image settings are visible.The precise mouse path, click coordinates, and keystrokes between one-second captures were not recorded.
F3331Width field is being editedA dimension change is underway.
F3332Width 128; height field activeThe first exact replacement value is visible.
F3333Width 128, height 128, ClosestThe final dialog contract is directly observed.
F3334Dialog closed; white mask layer existsCreation succeeded between adjacent snapshots.

Bit-by-bit Blender reconstruction

Scrub through 25 actual saved scenes.

Each stage is a separate `.blend`, rendered from one fixed camera. The replay follows visible source states; it is not SquareAnon’s original file and does not fabricate hidden brush telemetry.

Loading checkpoint…Our evidence-linked Blender replay
SquareAnon's completed hourglass reference
SquareAnon final resultTarget process reference—not our output

Swipe to reach every reconstruction phase →

Checkpoint

Loading…

Source evidence
Claim level

The checkpoint manifest is loading.

Do not settle for screenshots

Open every stage yourself.

The archive contains 25 ordered `.blend` files, the three tiny texture images, and the replay manifest. The final file opens directly in Blender.

Download final `.blend` Download all 25 stages Inspect replay manifest

Original-resolution micro audit

Interrogate the UI event ledger yourself.

This is the forensic layer beneath the 33-step teaching summary. Search exact controls, objects, modes, brush values, visible cursor evidence, and the before/after state recorded across the main timelapse and companion result.

Literal evidence boundary

The ledger preserves every recoverable visible Blender brush circle. It cannot recover an operating-system pointer, tablet pressure, click, key, or movement that occurred between Chronolapse’s one-second screenshots. The published native-visual receipt list enumerates every original PNG and proves exact coverage.

Loading event ledger…
Observed UIObserved resultInferredUnresolved

Loading the micro-event ledger…

What actually makes the image

Eight coordinated channels. One final read.

The video’s unusual quality comes from breaking the standard physically based division of labor. The artist keeps visual authority close to the asset.

01

Low-poly silhouette

Bulbs, plates, one turned post, radial repetition, and a bulb-derived sand pile establish the big read.

Geometry
02

Manual UV allocation

Shells, strips, caps, rings, and collars are packed by hand so the tiny atlas spends pixels intentionally.

Mapping
03

128×128 painted atlas

Closest filtering preserves hard, chunky pixel decisions. Blue glass and warm wood share one image.

Texture
04

Painted illumination

White centers, cobalt rims, warm edge light, wood grain, contact shadow, and trim shine are authored into color.

Texture
05

Vertex-color gradients

Separate attributes darken wood undersides and add another controllable glass gradient.

Attribute
06

128×128 glass mask

Black, grey, and white strokes art-direct where the painted glass appears transparent.

Mask
07

Transparent + emission mix

The visible material summary mixes Transparent BSDF and Emission with a Ucupaint-derived factor.

Shader
08

64×64 sand and UV reuse

A tiny painted sand image covers the piles; the falling stream reuses it by moving its UVs.

Texture + UV

Executed Blender proof

Remove a channel. Watch the scene change.

This is our deterministic channel-equivalent reconstruction, not SquareAnon’s original `.blend` and not a claim about an unseen node graph. It exists to make each responsibility visible.

Our Blender channel-equivalent reconstruction of the low-poly hourglass SquareAnon's completed hourglass reference SquareAnon source Our mechanism proof

Honest visual verdict

Mechanism proven; beauty match not claimed.

The reconstruction reproduces the channel structure and a related thumbnail read. It does not reproduce SquareAnon’s hand, exact topology, precise brushwork, or hidden settings. Its two-value aid also shows that our dark wood merges too much with black; this is evidence, not a concealed miss.

Scene
22 meshes · 922 base vertices · 712 polygons
Textures
128² color · 128² mask · 64² sand
Repeatability
Fresh reopen is pixel-identical
Final channel-equivalent reconstruction Final authored stack
Hold geometry and camera fixed; change one responsibility

All authored channels enabled.

What your eye should notice

The intended reconstruction read: warm wood, painted glass, mask, vertex color, sand, and unlit presentation.

Upscaled nearest-filtered reconstruction color texture with warm wood and blue highlight fields
128×128 colorPainted material and form-light authority
Upscaled greyscale reconstruction glass opacity mask
128×128 maskAuthored glass visibility
Upscaled nearest-filtered reconstruction sand texture in beige pink and ochre
64×64 sandSeparate surface and stream reuse

Frame-indexed field notes

Thirty-three observable steps.

Filter by responsibility. Every card cites exact frames and time. “Strongly inferred” and “unknown” are never silently promoted to fact.

Swipe to reach every process filter →

Loading the action ledger…

Layman’s repeatable plan

How we would use this on a Forged by Sin asset.

Do not copy the hourglass literally. Copy the division of artistic responsibility, then test it on one approved focal asset before any renderer migration.

  1. Lock the silhouette.Judge the object as a black shape. No texture can repair a confused primary read.
  2. Choose the deliberate facets.Spend polygons where profile and highlight breaks matter; stop smoothing everything automatically.
  3. Budget texels by meaning.Give faces, trims, focal marks, and repeated modules explicit space in a tiny atlas.
  4. Paint value before hue.Place the white center, dark edge, contact shadow, and midtone masses in greyscale first.
  5. Break color without breaking value.Add warm/cool variation, grain, and brush irregularity while keeping the large light-dark design intact.
  6. Separate secondary controls.Use vertex color for broad gradients and masks for visibility; do not bury every decision in one image.
  7. Choose lighting ownership.If paint owns directional light, runtime light must be restrained. If runtime owns it, remove incompatible baked cues.
  8. Ablate every channel.Capture neutral paint, no vertex color, no mask, unlit, runtime lit, and rotated-light arms on one camera.
  9. Audit at thumbnail and greyscale.Check primary read, background separation, and whether detail survives distance.
  10. Stop for the Creative Director.Only a visual verdict can authorize adapting this recipe to the goblin or production renderer.

Boundaries

What the recording does not show.

Still unknown

  • Render engine and final render settings
  • World, HDRI, lights, exposure, and color management
  • The complete material node graph and exact socket values
  • Whether the visible Pixelate compositor or V.G. baker ever ran
  • The exact 128→64 sand-image transition
  • Export, game-engine shader, temporal behavior, and performance

Not demonstrated

  • No outline or Sable-like line system
  • No screen-space post-processing stack
  • No physically accurate glass/refraction proof
  • No claim that one texture size fits every asset
  • No evidence that a renderer alone creates SquareAnon’s style
  • No authorization to migrate Forged by Sin’s renderer

Audit trail

Hashes, coverage, corrections, and source boundaries are public.

Open the evidence ledger Open machine-readable steps