Pascal Editor: Open-Source 3D Building Editor (React Three Fiber + WebGPU)

Pascal Editor (~18.7k★, MIT) is the open-source answer to “can I ship a real building editor in the browser?” — not a grey-box BIM toy, but a WebGPU + React Three Fiber stack with walls that miter, doors that CSG-cut, and an npm surface you can embed.

Hosted product: editor.pascal.app. Repo: pascalorg/editor.

If Pascal is the structure layer, bunpav.com is the AI prop layer explainx.ai already covers — text/photo-to-3D, Primitive Lab, and img2threejs code-first meshes. Use Pascal for the building; use bunpav when you need furniture, set dressing, or jam props without a modeling career.

TL;DR

What people actually ask

Is this another closed “AI architecture” SaaS?

No. Pascal’s pitch on the product site is blunt: the viewer, editor, and scene engine are published on npm and developed in the open. You can embed, fork, or let agents drive scenes. That is closer to a platform SDK than to a black-box room sketcher.

Do I need BIM / Revit knowledge?

No for the happy path. The node model is a flat Record<id, Node> with parentId — Site → Building → Level → Wall / Slab / Zone / Item. Architects will want IFC workflows; indie builders and game level designers can start from walls and zones in the browser.

WebGPU — will my laptop choke?

Pascal targets WebGPU via Three.js. Expect modern Chromium. If you are shipping to older Safari or locked-down enterprise browsers, test early — this is not a Canvas2D floorplan.

How is this different from “just use Blender”?

Blender is a DCC. Pascal is a domain editor: hierarchical selection (site → building → level → zone → items), dirty-node geometry systems, spatial placement validation, and shareable projects. Different job.

Architecture in one screen

Turborepo packages (from the README):

Data flow that matters: tool click → useScene.createNode / updateNode → node marked dirty → React mounts renderer + useRegistry → useFrame system rebuilds mesh → dirty cleared.

That dirty-node loop is why wall thickness changes do not re-triangulate the whole site every frame.

Why agents care about a scene graph

Flat Record<id, Node> with parentId is LLM-friendly: tools can create/update/delete by id without learning Blender’s outliner. Combined with @pascal-app/mcp, a host like Claude can drive walls and zones as structured edits instead of freeform mesh soup. That is the bridge from MCP 2026-07-28 to spatial products — headless servers that mutate domain state, not only fetch JSON docs.

Builder checklist for agent-driven scenes:

1. Keep node schemas Zod-validated so bad tool args fail closed.
2. Expose idempotent create/update tools (same id → same result).
3. Log dirty-node rebuilds when debugging “agent built nothing.”
4. Prefer zone/item edits over raw triangle edits for LLM plans.
5. Version shareable projects so human review can diff scenes.

Embed the viewer (copy-paste)

npm install @pascal-app/core @pascal-app/viewer @pascal-app/editor @pascal-app/nodes

import { loadPlugin } from '@pascal-app/core'
import { builtinPlugin } from '@pascal-app/nodes'

await loadPlugin(builtinPlugin)
// then mount <Viewer> from @pascal-app/viewer

Always run bun dev from the monorepo root when developing packages — root watchers rebuild core/viewer so Next hot-reloads correctly.

MCP: let agents reshape the building

@pascal-app/mcp (public since v0.8.0, still updating through Jul 2026) drives @pascal-app/core without a browser. Official release notes advertised tools for scene query/mutation, undo/redo, export, validation, and vision — plus prompts like from_brief and renovation_from_photos.

Honest limit from the package docs: headless mode does not regenerate derived geometry (mitered walls, CSG cutouts). Agents mutate node data; open the scene in @pascal-app/viewer for mesh truth.

For MCP protocol context, see explainx.ai’s MCP guide and the 2026-07-28 stateless spec.

Suggested agent loop

1. from_brief / natural-language plan → create Site/Building/Level skeleton
2. Tool calls to place walls/zones with validated dimensions
3. validation tool → fix collisions / missing parents
4. Human opens viewer for mesh truth and aesthetic pass
5. Export / share project id for review

If you skip step 4, you will ship node graphs that look correct in JSON and wrong in 3D — the documented headless geometry limit.

bun add @pascal-app/mcp
# then wire pascal-mcp into Claude Code / Cursor like any MCP server

Plugins without a secret internal API

Pascal’s extensibility story matches the README: a plugin ships node kinds (schema, 2D/3D render, placement tools, inspector) and left-rail panels through the same Plugin manifest builtins use. Starter example: pascalorg/plugin-trees.

Who should adopt Pascal this quarter

WebGPU requirement means Chromium-first demos; budget a fallback message for locked-down Safari enterprise fleets.

Pascal vs bunpav — structure vs AI assets

explainx.ai’s read: Pascal’s own product surface already advertises Generate with AI, Capture, Studio, and MCP. That is in-scene AI. bunpav.com is the complementary stack when you want game-ready or mockup meshes (credits from ~$9, no subscription required for packs) to drop into Unity, Unreal, Blender — or beside a Three.js building viewer. Structure in Pascal; bake the furniture on bunpav.

Getting started checklist

1. Open editor.pascal.app and walk a community project.
2. Clone pascalorg/editor → bun install → bun dev.
3. Skim packages/core/src/schema/ and use-scene.ts before writing a plugin.
4. If you want agent edits, install @pascal-app/mcp and point your host at pascal-mcp.
5. If you need props/SFX/levels for a game or furnished demo, open bunpav.com and export GLB / MP3 / JSON as needed.

What to Decide Before You Adopt Pascal

The post describes several different ways to use Pascal, and they carry different risks. Sorting out which one you are doing first saves time.

Embedding the viewer or editor. You depend on the npm packages (core, viewer, editor, nodes) and on WebGPU support in your users' browsers. The upstream tracker is active, so pin versions rather than floating on latest.

Letting agents edit scenes. You depend on @pascal-app/mcp, which mutates node data without a browser. The package docs say headless mode does not regenerate derived geometry such as mitered walls and CSG cutouts. Plan a human or viewer step to confirm what the scene actually looks like.

Writing a plugin. You add node kinds through the same manifest the builtins use. Read the schema folder and use-scene.ts first, as the getting-started checklist suggests.

Pairing with bunpav for props. Keep the division of labor clear: Pascal holds the building graph, bunpav supplies furniture and set dressing.

Whichever path you pick, the common requirement is the same: test your target browsers early, pin versions, and treat the first two-room scene as the real acceptance test before you make promises to a client.

Limitations (read before you star-farm)

• WebGPU dependency — verify target browsers.
• MCP headless ≠ rendered geometry until a viewer host runs systems.
• Issue tracker is active (15+ open issues / 16+ PRs at time of writing) — treat as a fast-moving monorepo, pin npm versions in production.
• Pascal is architecture-first; it is not a general sculptor. For organic / stylized props, use bunpav or Blender.

Local tryout script

git clone https://github.com/pascalorg/editor
cd editor && bun install && bun dev
# open localhost:3002 — build a two-room level, then wire @pascal-app/mcp

Push an agent to create walls from a brief, then open the viewer to confirm meshes. If headless validation passes but walls look wrong, you hit the documented derived-geometry limit — that lesson is the point of the first afternoon with Pascal.

FAQ

IFC import? Not the day-one story — node graph first; AEC bridges later. Mobile editing? Viewer may work; treat editor as desktop Chromium. Multiplayer? Check upstream roadmap; do not assume OT/CRDT yet. Why bun? Monorepo tooling — follow upstream; npm consumers still get packages. Agent geometry wrong? Headless skips derived meshes — open viewer.

Pascal is an open building OS for agents and humans. Start with a two-room scene before you promise digital-twin miracles to a client.

Closing note for explainx.ai readers

This launch moves fast; verify primary docs before you standardize tooling or brief a client. Re-check availability, pricing, and model IDs on the official pages linked above, then tell us what broke in production so we can update the guide. Follow @explainx_ai for follow-ups when the vendors ship the next patch — and prefer measured evals on your own traffic over screenshot economics. If you only needed a headline, you already have it; if you are implementing, the checklists above are the part that saves a weekend.

Related on explainx.ai

• bunpav — procedural 3D, Game Lab, Audio Lab
• img2threejs — photo to procedural Three.js + bunpav
• What is MCP?
• MCP 2026-07-28 — stateless core
• LingBot-Map — streaming 3D reconstruction
• What are agent skills?
• NVIDIA SIGGRAPH 2026 — Blender MCP & physical AI
• Grok Build Mode — prompt-to-app

Sources

• pascalorg/editor on GitHub
• editor.pascal.app
• @pascal-app/viewer on npm
• @pascal-app/mcp on npm
• v0.8.0 — MCP on npm
• bunpav.com

Star counts, package versions, and product features change quickly. Snapshot as of July 29, 2026.