ResVR · ResOS · a simplified Higharc, built on what we own

Builder CAD in. A shoppable 3D home out — with a live price.

Take the CAD a builder already ships — interior and exterior — and turn every option combination into a priced, walkable home in the Visualizer. Higharc's buyer experience, minus the machinery we don't need.

from builder CAD (DWG) interior + exterior live pricing reuses the Visualizer

Executive Summary ONE PAGE · READ THIS FIRST

The problem

Every builder plan hides thousands of variations — interior structural options (deck, porch, sunroom, 4th bedroom…) and exterior elevations (styles, brick, side-load garage). One real plan (Bridgeport) already ships ~9 first-floor × 3 second-floor × 5 basement interior variants and 5 exterior styles. We can't hand-model each, and buyers can't see or price their choices.

The idea

A simplified, Higharc-style single source of truth. Take the builder's CAD (the DWG set they already produce); AI classifies it — interior (structural) vs. exterior (elevation), mapped to the option tree in Production Tracker. We build the home from reusable snap-on 3D pieces (base + option modules, interior and exterior). The Visualizer shows every combination live — with a running price from PT as the buyer toggles.

Why now

Higharc just raised a $95M Series C (June 2026) selling exactly this to builders. The category is validated — and we already own the hardest, flashiest piece (the 3D configurator). We take that slice; we skip the rest.

Why it fits us

The Visualizer is the buyer configurator. PT already has the rulebooks — structural_options (interior) and elevations (exterior) — both with unreal_path columns sitting empty. The builder already produces the CAD. And PT's catalog already stores prices. We're finishing a loop, not starting one.

The honest limit

No "point an API at a floorplan, get a finished house" button exists today. The accurate path is a pipeline with a quick human check at the front. But because we build pieces, cost is per-plan, not per-variation.

The ask

Approve a small ~1–2 week proof-of-concept: AI reliably reads a Schell plan into structured data. If it lands, we fund the pipeline — and the live-price overlay is a cheap early win.

Higharc, and the slice we're taking

Take the buyer-facing pillar. Skip the enterprise tail.

Higharc turns one plan into shoppable 3D, plan-based estimating, and permit-ready construction docs. We don't need all three — we need the one buyers touch, and we're already most of the way there.

✓ already own it

Shoppable 3D configurator

Real-time 3D where buyers toggle options and watch the home change. This is what the Visualizer already does.

~ simplified

Plan-based pricing

Not full estimating & takeoffs — just a buyer-facing running price, read live from PT's catalog. Higharc's headline number, the lightweight way.

✕ not building

Permit-ready construction docs

Structural drawings, permits, full BOM. Huge scope, not our business. We stop at the shopping experience.

$95M

Higharc's Series C (June 2026), $170M+ raised total. The market has already decided builders want this. Our edge: we're not building the platform — we're extending the Visualizer we already ship.

The whole idea in one picture

It's a LEGO house kit — with a price tag.

📦
The floorplan is the picture on the front of a LEGO box.
🤖
The AI is a super-fast helper who looks at the picture and writes down which pieces go where — and which are extras you can add or skip (the deck, the porch).
🏠
We build the base house once, and make each extra a snap-on piece.
🧩
Picking "Deck 1 + Screen Porch 2" just snaps on two pieces — and the price tag adds up as you go.
🎮
The Visualizer is the toy town where the finished house gets walked around.

Two models, one home

Interior and exterior — both from the same CAD.

A home is really two coordinated model families. The builder's CAD contains both, so the pipeline generates both the same way.

interior · structural options

The inside

The rooms you walk through, built from the DWG floor / ceiling / section / framing set.

walls · floors · ceilings
windows · doors · baseboard

Maps to PT structural_options. Bridgeport: 9 first-floor · 3 second-floor · 5 basement variants.

exterior · elevations

The outside

The facade — the curb-appeal look a buyer picks first. Also CAD-derived.

CraftsmanSchell ASchell BSchell CSouthern

…each × Brick / Side-load garage / 4th bedroom. Maps to PT elevations.

1 level

In Unreal both live in the same level, separated by layers (interior / exterior). They must stay in sync — a "4th bedroom" or side-load garage changes both the inside and the facade. Keeping them consistent is exactly what a single source of truth buys you.

How it works · 5 steps

Drawing in, walkable priced home out.

🤖

Ingest + classify

Read the CAD

Geometry comes straight from the DWG. AI classifies it: interior vs. exterior, and which option each piece belongs to.

👀

Review

Human checks

A person fixes anything the AI got wrong. The safety net that builds trust.

🧱

Extrude

Build the pieces

Deterministic code turns the plan into accurate walls, a base, and snap-on modules.

🎮

Assemble

Into the Visualizer

Base + modules load into Unreal; option toggles wire to the existing config.

💲

Price + Publish

Live cost, then GDN

Each toggle pulls its price from PT and updates the total; ships via NVIDIA GDN.

Because the input is real CAD, the geometry is deterministic — accurate, repeatable, auditable. AI's job is the tedious human step: classifying which piece is which option (interior or exterior) and matching it to the PT rulebook. Not guessing shapes.

The handoff · how a piece reaches the Visualizer

Into the Visualizer — the honest version.

The pieces don't magically appear in the Visualizer. They cross a real boundary: we produce the assets and the option/price data; the Unreal team brings them into the project, wires the toggles, and ships the build. It reuses the exact pipeline that ships every Visualizer build today.

Export

Interior + exterior modules from the CAD as Datasmith / FBX / glTF, plus the option & price data.

Import

Pulled into one Unreal level as static meshes — interior and exterior on separate layers.

Wire toggles

Each module bound to an in-engine option toggle, keyed to the PT option ID. unreal_path written back to PT.

Cook

Baked into the map & packaged — BuildCookRun.

Ship to GDN

Uploaded to NVIDIA GDN, pixel-streamed to buyers. Build-monitor watches it.

ResOS · our pipeline (steps 1) Unreal team · Plastic SCM → GDN (steps 2–5)

Reality check: the Visualizer is baked — every content change needs a cook + GDN redeploy (not instant like a web app), and the in-engine toggle wiring is owned by the Unreal team. Want "edit in PT, appears instantly, no rebuild"? That's a separate runtime-loading rework — a future fork, not part of this plan.

Why this approach

Build pieces, not combinations.

✕ The hard way — model every combo

Bridgeport, one plan:
9 × 3 × 5 interior variants
× 5 styles × ~4 exterior variants …

1,000s full 3D homes to model by hand

…for a single plan. Impossible by hand.

✓ The LEGO way — snap pieces together

1 base + interior option modules
+ a handful of exterior styles/variants
= the same thousands of combos

~dozens of reusable pieces

Cost is per-plan, not per-variation.

Build a few dozen pieces, get thousands of priced variations for free.

It plugs into what we already have

The data — and the prices — are already sitting there.

PT already stores each plan's options as a structured tree, with the 3D columns in place. The catalog already stores prices. The pipeline just fills the blanks and reads the numbers. No new source of truth.

production-tracker · structural_options · elevations · catalog_options

INTERIOR — structural_options
   "Rear Structural Option Location 1"   ← choice group (parent)
     ├─ Deck 1  ├─ Screen Porch 1  ├─ Sunroom   ← pick ONE
     └─ each stores: floor · room · render_url · unreal_path  ◄ EMPTY

EXTERIOR — elevations  (same shape)
   Craftsman · Schell A/B/C · Southern          ← style (parent)
     └─ Brick · Side-load · 4th bedroom · unreal_path  ◄ EMPTY

catalog_options.price  + community/region overrides   ◄ live total

The pricing overlay

Watch the price move as you choose.

Your home · Cassidy plan live

Base planschell · cassidy $412,000

+ Deck 1rear structural · loc 2 + $18,500

+ Screen Porch 2rear structural · loc 1 + $24,000

+ Gourmet Kitchencatalog · appliances + $12,750

Total $467,250

◦ Illustrative numbers — not real Schell pricing.

How it works

✓ As the buyer toggles an option in the Visualizer, its price is read from PT and the total re-computes instantly — the same option data that drives the 3D also drives the number.

✓ Finish/catalog options are priced in PT today — catalog_options.price, with community & region overrides. This half works right now.

⚠ Structural options and elevations aren't priced yet — each needs one new price column (structural_options, elevations). Small, honest add; called out so nobody's surprised.

Scope discipline

What we're deliberately not building.

This is what keeps it "simplified."

Construction & permit docs

Structural drawings, code-compliant permit sets. Huge, regulated, not our lane.

Full estimating / BOM

Line-item material takeoffs and bids. We show a buyer price, not a builder's cost sheet.

Generative "AI house" mesh

Meshy / Tripo-style guesswork. Not dimensionally trustworthy for real homes.

The plan · crawl → walk → run

Phased, with a go/no-go gate up front.

Phase	What we do	Rough effort	Skills
0 · Prove the AI gate	Ingest the real Bridgeport DWG set; AI classifies interior vs. exterior and tags each piece to PT structural_options / elevations. Measure accuracy.	~1–2 wks · 1 eng	AI / vision
1 · Trust layer	Scaffold a ResOS app (from orgchart). A review screen to correct scale, walls, and option tags. D1 for jobs, R2 for files.	~4–6 wks · 1–2 eng	React / TS + platform
2 · Build the pieces	Headless pipeline: CAD → accurate geometry → base + interior option modules and exterior style/variant modules. Export to the Visualizer's format.	~4–6 wks · 1 eng	3D / Blender
2.5 · Live pricing	Wire toggles to PT prices; running total in the Visualizer. Add a price column to structural options and elevations. Cheap early win, high visibility.	~1–2 wks · 1 eng	platform / PT
3 · Into the Visualizer	Import into one Unreal level (interior/exterior on separate layers); wire option toggles to PT IDs; publish via GDN. Reuses the existing config.	~6–8 wks · 1 eng	Unreal (existing team)
4 · ResOS automation	A new community or plan auto-kicks the pipeline → review → publish, kept in sync with PT. The single-source payoff.	ongoing	platform / PT

End-to-end (1 builder)

~4–6 months to a working, priced configurator for Schell, then scale to other builders & plans.

Team

~1 AI/vision eng + 1 3D/Blender eng + the existing Unreal engineer + part-time platform/PT.

⚠ Effort figures are best-guess bands to refine with the team — not commitments. Phase 0 is deliberately tiny so we learn cheaply before investing.

Straight talk

What AI can and can't do here.

Real leverageAI shines

Classifying the CAD. Which layer/block is which option, interior vs. exterior, and matching each to the PT rulebook (structural_options / elevations). The tedious human step — now the AI's job.

Assist onlyAI helps

Untangling messy CAD. Layer names and how variations are encoded differ plan-to-plan and builder-to-builder; AI helps reconcile them, a human confirms. This is the real risk — not the geometry.

Not AI at alland that's good

The geometry, and the pricing. Geometry is read straight from the CAD; prices come straight from PT. Deterministic — accurate, reproducible, auditable. Even less generative than reading a floorplan image would be.

The ask

Let's spend two weeks proving the hard part.

Fund a small Phase 0 proof-of-concept: show that AI can reliably read a Schell floorplan into structured data our tools already understand. Low cost, clear go/no-go. If it works, we've got a simplified Higharc — built on the Visualizer and PT we already own.

Approve Phase 0 → ~1–2 weeks, 1 engineer

Everything after the gate is optional and sequenced.