📐

Loomis Quest

New: 2026-07-24Updated: 2026-07-24

Build an art-study engine — recover the construction hiding in a photo

The origin story of Loomis — Dad's own art-study engine, the drawing sibling of the image engine Ember and the music engine Bonfire. Why you build an answer key for deliberate practice instead of eyeballing your own drawings, and how deterministic projective geometry — not a generative model — recovers the construction hiding inside a reference photo.

8 tracks · 35 lessons · ~7h · difficulty: intermediate-to-advanced

Level 0Blank Page

0 XP0/35 lessons0/12 achievements

0/100 XP to next level100 XP to go0% complete

Loomis is not a generator, not a tracing tool, not an autopilot that draws for you. It is an independent art-study engine that owns reference analysis, deterministic construction, grading, and an API — with a built-in React/Konva web UI as its first client. This quest walks that engine end to end: the founding reframe (inverse construction is a geometry problem, not a generation problem — a generative model can imitate construction marks but can never guarantee the geometry), Andrew Loomis's ball-and-plane method it recovers, the camera solve at its core (a pinhole model, solvePnP, a deliberately bounded focal sweep, and why the pose solve must never flip chirality), the fitting stage where machine learning proposes a fit but geometry alone defines the answer key, the four constructions (portrait, pose, hand, and the universal object box) that are one pipeline over four subjects, the grader that closes the loop by scoring in construction space — Procrustes alignment removes position, size, and tilt, so it grades your construction and not your tracing, and it estimates your exaggeration instead of punishing it — the collections, boards, and croquis decks that organize a practice archive you never prune, and the engine doctrine that holds it together (API-first, office-native, Eagle owns the originals). It is the art-study engine telling its own origin story — conceptual open-sourcing, not a repo you clone.

Tracks

01🗝️The Answer Key
0/4 lessons
What Loomis is, the loop it closes, and why geometry — not generation
Before any geometry, the orientation. Loomis is an art-study engine — it recovers the construction hiding inside a reference photo so a deliberate-practice loop can finally close. This track shows you that loop, the founding reframe that makes it possible (inverse construction is a geometry problem, not a generation one), and the single hardest 'no' the engine says out loud: it analyzes, it never generates.
Lesson list (4)
Quiz · 4 questions→
02✏️Construction
0/4 lessons
The human method the engine is built to recover
Before you can automate construction, you have to understand it as a craft. This track covers the human system Loomis recovers: Andrew Loomis's ball-and-plane head, why you construct a solid instead of tracing an outline, the single calibration unit that makes one profile hold across every photo, and the perspective box that turns a flat face into a thing you can rotate in your head.
Lesson list (4)
Quiz · 4 questions→
03📷The Camera Solve
0/5 lessons
How a flat photo gives up the 3-D angle hiding inside it
This is the deterministic heart of Loomis. A photo is a projection — a 3-D scene flattened by a camera — and the camera solve runs that flattening backward. You'll meet the pinhole model that turns points into pixels, solvePnP that recovers the pose, the bounded focal sweep that keeps a face-only solve honest, the chirality trap that near-symmetric faces set, and the reproducibility that lets the output be called an answer key.
Lesson list (5)
Quiz · 4 questions→
04🎯The Fitting Stage
0/4 lessons
Where machine learning lives, and exactly where it stops
Loomis uses machine learning — but on a very short leash. Detectors find where a face, body, or hand landed in the photo; that's the fitting stage. This track draws the leash precisely: the landmark models and the topology lock that makes their output usable, the shared role face/pose/hand detectors all play, the hard rule that ML may propose a fit but never define the answer, and why detector results are frozen while corrections live as separate layers.
Lesson list (4)
Quiz · 4 questions→
05🧩Four Constructions
0/5 lessons
One pipeline, four subjects — portrait, pose, hand, object
Now the polymorphism pays off. The same fitting-then-geometry pipeline specializes into four subjects: the portrait's Loomis head, the figure's boxes and limb volumes, the hand's palm box and phalanx frustums, and the universal object box that honestly claims no orientation it can't justify. Four constructions, one shared spine — and each one's design choices teach something about matching your model to what the subject actually is.
Lesson list (5)
Quiz · 4 questions→
06⚖️The Grader
0/5 lessons
The loop closes — grade the construction, never the tracing
This is where everything pays off. You draw the construction, upload it, and the engine grades it — but the design of that grade is the whole art. It preserves your attempt append-only, aligns away position, size, and tilt with Procrustes so it scores your construction and not your tracing, breaks the result into angle/proportion/placement sub-scores instead of one opaque number, estimates your exaggeration rather than punishing it, and then shows you exactly where you drifted. The grader is the answer key, finally doing its job.
Lesson list (5)
Quiz · 4 questions→
07🗂️Organizing the Practice
0/4 lessons
Collections, smart albums, boards, and croquis — the archive around the loop
A thousand sessions need a place to live. This track covers the organization layer built around the practice loop: a collections meta-overlay that never touches the session files it organizes, smart albums whose membership is a query rather than a move, reference boards that arrange originals without copying them, and croquis decks that turn a board into a timed warm-up. The theme throughout: organize by reference, never by moving or deleting the truth.
Lesson list (4)
Quiz · 4 questions→
08🏛️Engine Doctrine
0/4 lessons
How the engine is built to be owned — and how you build your own
The closing track pulls the design rules together into a doctrine you can carry to your own tools: an API-first engine with its UI as merely the first client, a deployment right-sized to exactly where it's used and nowhere else, a clean ownership map where each system holds one thing and references the rest, and the final thesis the whole quest was building toward — that the highest-leverage tool you can own is the answer key you build for your own practice loop.
Lesson list (4)
Quiz · 4 questions→

Spotted a bug or have feedback on this page?Report an Issue

Comments 0

🔔 Reply notifications (sign in)

No comments yet — be the first.

Tracks

01🗝️The Answer Key

02✏️Construction

03📷The Camera Solve

04🎯The Fitting Stage

05🧩Four Constructions

06⚖️The Grader

07🗂️Organizing the Practice

08🏛️Engine Doctrine