DOSSIER-STANDALONE/docs/HAUPTINSTANZ-BRIEFING.md

HAUPTINSTANZ-BRIEFING: Tauri + wgpu (Korrigiert)

Stand: 2026-07-01 — KORREKTUR (vorherige Dokumente waren unvollständig)

---

Die Entscheidung (FINAL)

Browser-CAD (alt) → Desktop Tauri-App mit Rust-Backend + wgpu-Rendering (neu)

Aspekt	Alt	Neu
App-Form	Browser-Tab	Desktop Tauri-Window
Frontend	React/Vite (TS)	React/Vite (TS) — UNVERÄNDERT
2D-Rendering	SVG-Plan	SVG-Plan — UNVERÄNDERT
3D-Rendering	three.js/WebGL	wgpu (Vulkan/Metal/DX12)
Rechenintensive Ops	TS in Browser	Rust im Backend
Betriebssystem	cross-platform browser	Windows/macOS/Linux Desktop App

---

Warum dieser Umstieg?

Problem mit three.js/WebGL:

• komplexe Möbel = 100k+ Polygone
• mehrere parallele Ops (kernel2d, bool-Ops, DXF-Parser, SIA-Raumerkennung)
• WebGL hat harte Limits (GPU VRAM, draw calls, single-threaded)
• → Laggy, nicht skalierbar für Professional CAD

Lösung: Tauri + wgpu + Rust

• wgpu = low-level GPU API (direkt zu Vulkan/Metal/DX12, nicht WebGL)
• Rust = rechenintensive Ops parallelisiert + native performance
• Desktop = native App, nicht Browser (bessere Kontrolle, bessere Perf)
• React-Frontend bleibt = UI/Sketching/Panels unverändert (wgpu nur für 3D-Display)

---

Der neue Stack (FINAL)

┌─────────────────────────────────────────────────────┐
│ Desktop Tauri-Window                                │
├─────────────────────────────────────────────────────┤
│                                                     │
│  React/Vite (UI-Shell, State, Panels)              │
│  ├─ SVG 2D-Plan (Grundriss)                        │
│  └─ wgpu 3D-Viewport (3D-Ansicht + Rendering)      │
│                                                     │
│              ↓ invoke (IPC) ↓                       │
│                                                     │
│  Rust-Backend (src-tauri/)                         │
│  ├─ computeJoins() — Wand-Eckverbindungen          │
│  ├─ kernel2d() — Offset/Trim/Extend/…             │
│  ├─ parseShapeFromDwg() — Geometrie-Import         │
│  ├─ detectRooms() — SIA-Raumerkennung              │
│  └─ booleanOps() — Union/Differenz/Schnitt         │
│                                                     │
└─────────────────────────────────────────────────────┘

Nicht verändert:

• App.tsx, state/, commands/, panels/, model/types.ts
• UI-Logik, Befehlssystem, Sketching-Tools

Neu/geändert:

• src-tauri/ — Rust-Crate für Backend
• src/compute/index.ts — Boundary (invoke + TS-Fallback)
• Rendering-Engine: three.js → wgpu
• Build: npm run tauri:build statt npm run build

---

Die Aufgabe (vier Agents)

Siehe: docs/design/tauri-migration-plan.md

Vier parallele Agents:

1. Agent: Tauri-Shell Setup → src-tauri/ + Cargo.toml + main.rs (Tauri window registrieren)
2. Agent: Compute-Boundary (TS) → src/compute/index.ts (invoke-Wrapper + TS-Fallbacks)
3. Agent: Rust compute_joins Impl → src-tauri/src/geometry.rs (erste Op, Proof-of-Concept)
4. Agent: Vite/Package-Integration → vite.config.ts + package.json (Tauri-Plugins, scripts)

Deliverable: lauffähige Desktop-App, wand-Edit triggert Rust-Op, Output identisch TS-Version.

---

Dev-Workflow (post-Tauri)

# Dev: Terminal 1 (Vite)
npm run dev  # localhost:5173

# Dev: Terminal 2 (Tauri)
npm run tauri:dev  # öffnet Desktop-Window, zeigt auf localhost:5173

# Build
npm run tauri:build  # → Windows .exe / macOS .app / Linux .deb

---

Rendering: three.js → wgpu (Wichtig!)

3D-Viewport wird NEU implementiert in wgpu:

• Nicht: "drei.js mit Rust-Fallback"
• Ja: wgpu als native GPU-Renderer (skaliert auf 100k+ Polygone)

2D-Plan bleibt SVG (keine Änderung).

Timeline für wgpu-Impl:

• Milestone 1 (jetzt): Tauri-Shell + Rust-Compute-Ops
• Milestone 2 (nächst): wgpu 3D-Viewport-Impl (ersetzt drei.js/WebGL)
• Milestone 3: Live clipping/sectioning in wgpu

---

Migration-Reihenfolge

Phase 1 (Tauri-Shell + Proof-of-Concept):

• computeJoins (Wand-Ecken) → Rust

Phase 2 (Rendering-Umbau):

• wgpu Viewport-Impl (ersetzt drei.js)
• Instancing/LOD für Möbel-Geometrie

Phase 3 (weitere Ops):

• kernel2d (Offset/Trim) → Rust
• DXF/DWG-Parser → Rust
• detectRooms → Rust
• booleanOps → Rust

---

Was sich NICHT ändert

• src/App.tsx, src/state/, src/commands/
• UI-Panels, Zeichenwerkzeuge, Befehlssystem
• Semantisches Modell (types.ts)
• i18n, Styling

Was ändert sich

• Engine: three.js/WebGL → wgpu
• Backend: TS-Only → Tauri + Rust
• Distribution: Browser → Desktop App
• Build-Prozess: npm run build → npm run tauri:build

---

Fehlerquellen (zur Klarheit)

❌ FALSCH: "Wir bleiben bei three.js"
✅ RICHTIG: "three.js → wgpu, Rust-Compute + Desktop Tauri"

❌ FALSCH: "Tauri + three.js als Frontend-Engine"
✅ RICHTIG: "Tauri-Shell + React UI + wgpu 3D-Rendering + Rust-Compute"

---

Nächste Schritte (für Hauptinstanz)

1. Lesen: docs/design/tauri-migration-plan.md (technisch, konkret)
2. Spawn: vier Agents (parallel, unabhängig)
3. Verifizieren: npm run tauri:dev → App läuft, erste Op in Rust funktioniert
4. Aktualisieren: HANDOVER.md mit Milestone-1-Status

---

Fragen?

• "Warum Desktop statt Browser?" → Skalierbarkeit (native GPU + Rust-Compute)
• "Warum wgpu statt drei.js?" → wgpu skaliert auf 100k+ Polygone, three.js/WebGL hat Limits
• "Bleibt React?" → Ja, React/Vite UI bleibt, nur 3D-Engine wechselt
• "Wann ist wgpu-Impl fertig?" → Milestone 2 (nach Tauri-Shell)