editor README

The project's README from github.com/pascalorg/editor. As one markdown file: README.md.

Pascal Editor — open-source 3D architecture software for AECO

Create and edit 3D building models in your browser, run Pascal locally with its CLI, or connect AI agents through the Model Context Protocol (MCP).

Pascal Editor is a local-first, MIT-licensed building editor for architecture, engineering, construction, and operations (AECO) work. Model sites, buildings, levels, walls, slabs, roofs, openings, rooms, and furniture; bring 3D scans in as reference layers for scan-to-BIM workflows and model editable building elements over them; and let an agent read, edit, validate, and save the same scenes. Built with React Three Fiber and WebGPU.

MIT License npm @pascal-app/core npm @pascal-app/viewer npm @pascal-app/cli Discord X (Twitter)

https://github.com/user-attachments/assets/063c0891-9ae5-4173-bd08-a101d9c3352b

Start here

Connect an AI agent (MCP)

MCP is an open protocol that lets AI assistants call tools in other applications; Pascal's MCP server gives an agent tools to inspect, edit, validate, and save building scenes.

Choose where the projects live:

The local commands below need the pascal command on your PATH (Node.js 22.23.4+ on 22.x, 24.22.1+ on 24.x, or 26.12.1+):

npm install --global @pascal-app/cli

[!IMPORTANT] Use one active agent client per local CLI service. The standalone local HTTP runtime shares active scene state between clients; use separate PASCAL_HOME directories and service processes when independent concurrent work is required. The hosted endpoint uses a separate session-isolated bridge.

Claude Code

Register the local server (this runs claude mcp add --scope user pascal -- pascal mcp connect):

pascal mcp setup claude

Or install the plugin, which bundles the skills, the local pascal server, and a hosted pascal-hosted server that prompts for an optional Pascal API key and stores it in the OS keychain (leave it empty to stay local-only):

/plugin marketplace add pascalorg/editor
/plugin install pascal-agent-skills@pascal

Use one or the other. Claude Code 2.1.258 loads both the user-scoped pascal server created by pascal mcp setup claude and the plugin-provided server. Remove the manual entry before reloading or restarting Claude Code so only the plugin owns the connection lifecycle:

claude mcp remove --scope user pascal

Use /mcp to remove or disable any project- or local-scoped Pascal connection too. Leaving both connections active violates the one-active-agent-client-per-local-service requirement.

Cursor

Install Pascal from the Cursor marketplace. It adds the skills, a local pascal server launched through npx (no global install needed), and a hosted pascal-hosted server. For hosted work, open Customize → MCPs and choose Authenticate beside pascal-hosted; Pascal opens in your browser to sign in and choose a workspace. No API key is needed. Leave pascal-hosted disconnected for local-only work.

Without the plugin, add the servers you want to .cursor/mcp.json:

{
  "mcpServers": {
    "pascal": {
      "type": "stdio",
      "command": "npx",
      "args": ["--yes", "--package=@pascal-app/cli", "pascal", "mcp", "connect"]
    },
    "pascal-hosted": {
      "type": "http",
      "url": "https://editor.pascal.app/api/mcp",
      "auth": {
        "CLIENT_ID": "pascal-cursor",
        "scopes": ["openid", "profile", "offline_access", "scene:read", "scene:write", "architect:run"]
      }
    }
  }
}

The plugin's own configuration is .cursor-plugin/mcp.json.

Codex

Register the local server (this runs codex mcp add pascal -- pascal mcp connect):

pascal mcp setup codex

Or install the plugin, which adds the skills and the same local server:

codex plugin marketplace add pascalorg/editor
codex plugin add pascal-agent-skills@pascal

For a hosted workspace, register the endpoint with an API key held in an environment variable (Codex stores the variable name, not the key):

codex mcp add pascal-hosted \
  --url https://editor.pascal.app/api/mcp \
  --bearer-token-env-var PASCAL_API_KEY

Other MCP clients

Print the generic configuration with pascal mcp config:

{
  "mcpServers": {
    "pascal": {
      "command": "pascal",
      "args": ["mcp", "connect"]
    }
  }
}

The connector discovers the local service's port and private token itself. Check it with pascal mcp status or pascal doctor. For hosted access, point a Streamable HTTP client at https://editor.pascal.app/api/mcp with an Authorization: Bearer <api key> header.

Agent skills

Install with skills

The plugins above include Pascal's public agent workflows. To install only the skills with skills.sh:

npx skills add pascalorg/editor \
  --skill pascal-3d \
  --skill furniture-fit

pascal-3d covers safe local or hosted MCP setup and verified scene work. furniture-fit produces a bounded, evidence-based footprint assessment. OpenClaw installation becomes available after the skills are published under Pascal's ClawHub publisher.

More on agents

Run the editor locally

Create a persistent local Pascal installation without cloning this repository:

npx @pascal-app/cli editor

The CLI starts the editor and an authenticated MCP service in the background, selects collision-free loopback ports, and keeps projects in ~/.pascal/data/pascal.db. The web editor runtime is downloaded once per version on the first command that starts the editor and verified against a digest published inside the package; pascal mcp connect needs no download. See Run Pascal locally for pnpm/Bun commands, project management, updates, offline installs, storage paths, and troubleshooting.

Self-host it

The editor ships as one container, ghcr.io/pascalorg/pascal-editor, tagged with the same version as the npm packages (latest follows stable releases). Projects live in SQLite under /data; one admin password protects the instance; PASCAL_PUBLIC_URL is read at runtime, so the same image serves any domain.

docker run -d -p 3000:3000 -v pascal-data:/data \
  -e PASCAL_ADMIN_PASSWORD=change-me \
  -e PASCAL_PUBLIC_URL=https://pascal.example.com \
  ghcr.io/pascalorg/pascal-editor:latest

See SETUP.md, "Self-hosting" for the compose file, the variables, agent access and public embeds.

To have the container hosted and managed for you, deploy it on Elestio:

Deploy on Elestio

Use the published packages

Install the full built-in viewer set, then load the built-in plugin once before mounting <Viewer>:

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)

See the @pascal-app/viewer quick start for a React example, and @pascal-app/editor to embed the full editor. Capture sessions ship as the optional @pascal-app/core/capture and @pascal-app/viewer/capture subpaths. @pascal-app/ifc-converter converts IFC files into Pascal scene graphs.

Develop from source

Run from the repository root so the package watchers hot-reload changes in packages/*:

bun install
bun dev   # builds the packages, watches them, and serves the editor at http://localhost:3002

Build everything with turbo build, or one package with turbo build --filter=@pascal-app/core. See SETUP.md for prerequisites and environment variables, docs/architecture.md for how the packages fit together, and docs/releasing.md for npm, container, and MCP Registry publishing.

Build a plugin

A plugin ships node kinds (schema, 3D/2D rendering, placement tools, inspector parametrics) and left-rail panels through the same Plugin manifest the built-ins use. Start with the plugin guide and the worked example pascalorg/plugin-trees.

A first look at Pascal Next

Explore the live demo — a real home reconstructed in detail, from its rooms and finishes to the structure and systems behind the walls. This hosted preview explores the direction of the next Pascal editor; the experience shown here is not yet part of the open-source editor release.

Exploded view — see how the home fits together Cut view — slice through the building
Roof lifted above the reconstructed home A section cut reveals the roof framing and interior
X-ray — reveal the modeled systems Walkthrough — step inside at eye level
Building systems isolated with the walls hidden Walking through the home toward the pool terrace
Interactions — open doors and explore Environment — change the light and atmosphere
Interacting with doors in the reconstructed home Changing the lighting around the reconstructed home

We are exploring what this could make possible for facility management, home services, architecture, home building, and infrastructure. Join the discussion on X and tell us where you would use it.

Making a video, tutorial, article, or social post about Pascal? You are welcome to use and edit this footage, including in monetized content, under CC BY 4.0. Credit Pascal, link the license, and note your edits; no separate permission is needed. Download the six original videos and see the creator guide.

FAQ

What is Pascal Editor? An open-source 3D building editor for architecture, engineering, construction, and operations. It runs in the browser, locally through its CLI, or self-hosted, and exposes the same scenes to AI agents over MCP.

Is it free and open source? Yes. The editor, packages, CLI, and MCP server in this repository are MIT-licensed. Hosted services at editor.pascal.app are separate from the open-source release and have their own account terms.

Does it work offline? The local CLI keeps projects on your machine, and its MCP service needs no network download. Starting the editor downloads its web runtime once per version; for a host without network access, pass --runtime <directory-or-archive>. See the local editor documentation.

How do AI agents connect? Through MCP. Local agents run pascal mcp connect with no account; hosted workspaces use https://editor.pascal.app/api/mcp with the client's sign-in or API key. See Connect an AI agent (MCP).

Does it support IFC? IFC import is provided by @pascal-app/ifc-converter, which converts IFC files into Pascal scene graphs. Sites, buildings, levels, walls, doors, windows, slabs, columns, and spaces become native Pascal nodes when their parameters can be recovered; other elements are kept as selectable imported meshes.

Contributing

Bug fixes, features, docs and ideas are all welcome. Start with CONTRIBUTING.md for setup, code style and the PR flow.

Contributors

Aymeric Rabot Wassim Samad Sudhir


pascalorg/editor | Trendshift

editor (pascalorg/editor)

bim
Searching Database…

25.6K ·GitHub
What is this?Pascal Editor is an open-source, local-first 3D building editor: you sketch walls, floors, zones and furniture in a browser-rendered scene, and AI agents can drive that same scene through MCP.
Is it a website I visit, or something I install?Both. The editor UI runs in the browser, while a local CLI service launches the editor plus an authenticated MCP service in the background and keeps your work on disk.
How do I get it running on my machine?Install the @pascal-app/cli from npm — you need Node.js 22.13 or newer, and no repo clone is required. The CLI sets up a persistent local install, and 'pascal editor' starts the editor and its background MCP service.
Which AI agents can connect to it, and how?Any MCP-compatible host. Claude Code and Codex have one-command setup ('pascal mcp setup claude' or 'pascal mcp setup codex') plus marketplace plugins, and the pascal-3d and furniture-fit agent skills install via skills.sh.
Is it stable enough to rely on?It is beta: the npm beta tag (1.0.0-beta.1) predates the newest features — the read-only furniture candidate check and hosted agent claim/status commands — so use the verified GitHub prerelease for those. Also run only one active agent client per local CLI service.
Does anything leave my machine?No account or API key is needed and nothing uploads automatically: projects live in a local database at ~/.pascal/data/pascal.db, and scenes persist to IndexedDB with 50-step undo/redo.
What can I actually model in it?Buildings: walls generated with automatic door and window cutouts (CSG boolean geometry), floor slabs, ceilings, roofs, zones, and furniture placed on walls, ceilings or floors. Levels can be viewed stacked, exploded, or solo.
Can I add my own object types and tools?Yes — a plugin ships node kinds, placement tools, inspector parametrics, and left-rail panels through the same Plugin manifest the built-in tools use, with no separate internal API. The pascalorg/plugin-trees repo is a worked example you can clone as a starting point.
What are the pascal-3d and furniture-fit skills for?They are agent workflows to install alongside the MCP server. pascal-3d covers safe local or hosted scene work; furniture-fit produces a bounded, evidence-based footprint assessment of whether an item fits, without claiming unsupported height, swing, or delivery checks.
What is it built with?React 19 + Next.js 16, Three.js with its WebGPU renderer via React Three Fiber, Zustand stores with Zundo undo/redo, Zod schemas, three-bvh-csg for boolean geometry — organized as a Turborepo monorepo managed with Bun.
Creator
pascalorg
Size
188.6 MB
Stars
25.6K
Age
1y
Commits · 90 Days