Quick Start with docker

[zhuyifeiRuichuang]

If you want to quick start and join in devlopment, you can use to docker fast make it.

git clone https://github.com/pascalorg/editor.git
cd editor

create Dockerfile

# Build stage
FROM node:20-alpine AS builder

WORKDIR /app

# Install bun package manager
RUN npm install -g bun

# Copy root configuration
COPY package.json bun.lock ./
COPY turbo.json ./
COPY biome.jsonc ./

# Copy packages
COPY packages ./packages
COPY tooling ./tooling

# Copy apps
COPY apps ./apps

# Install dependencies and build
RUN bun install --frozen-lockfile
RUN bun run build

# Production stage
FROM node:20-alpine

WORKDIR /app

# Install bun and curl for health check
RUN npm install -g bun && apk add --no-cache curl

# Copy package managers
COPY package.json bun.lock ./

# Copy built applications and packages
COPY --from=builder /app/packages ./packages
COPY --from=builder /app/tooling ./tooling
COPY --from=builder /app/apps ./apps
COPY --from=builder /app/node_modules ./node_modules

# Set working directory to editor app
WORKDIR /app/apps/editor

EXPOSE 3000

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
  CMD curl -f http://localhost:3000 || exit 1

# Use next start for production
CMD ["bun", "run", "start"]

create .dockerignore

node_modules
npm-debug.log
.git
.gitignore
.next
.env
.env.local
.env.*.local
.DS_Store
dist
build
coverage
.turbo
.vscode
.cursor
.claude

create docker-compose.yaml

services:
  pascal-editor:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: pascal-editor
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - NEXT_PUBLIC_GOOGLE_MAPS_API_KEY=${NEXT_PUBLIC_GOOGLE_MAPS_API_KEY:-}
      - PORT=3000
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:3000"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    # opetion: limit
    # deploy:
    #   resources:
    #     limits:
    #       cpus: '2'
    #       memory: 2G
    #     reservations:
    #       cpus: '1'
    #       memory: 1G

create .env ,if you want to use Google Maps API,

NEXT_PUBLIC_GOOGLE_MAPS_API_KEY=your_api_key_here

all start

docker compose up -d

[Aymericr]

Thanks for documenting this. This recipe now carries stale operational assumptions: the editor runs on port 3002, the verified development-container path is #520, and the production Docker proposal remains #268 pending a multi-stage/non-root/health-check proof against current main. Closing this historical copy-paste recipe so it is not mistaken for supported current deployment guidance.

[Aymericr]

Closing note updated: Docker is official now. #268 merged today, so git clone && docker compose up -d builds and runs the editor on http://localhost:3000, with saved scenes persisted in a pascal-data volume.

That makes this recipe fully superseded rather than just stale — thanks for writing it, it carried people for four months. Two of its assumptions turned out to matter, and both are worth recording since anyone writing their own Dockerfile will hit them:

• node:20-alpine + npm i -g bun is actually the safer base than oven/bun. The official image uses oven/bun:1.3.14-alpine, where node is a shim that re-execs bun — and next build invokes node, which segfaults inside Next 16 on both arm64 and amd64. The fix is apk add --no-cache nodejs. Your instinct to start from a real Node base sidestepped that entirely.
• The port is 3000 in a container, not 3002. I said 3002 above, which is the dev-server port and wrong for this context — the container runs bun run start. It also has to stay 3000, because /scenes resolves its API base URL at build time via NEXT_PUBLIC_APP_URL and a remapped port makes that page 500.

Full details in #263. Leaving this closed and pointing at the supported path.