open-pencil-cloud is a free, open source design & prototyping project written in TypeScript and released under MIT. It has 1,104 GitHub stars, 5 forks and 4 open issues, and was last pushed 3 days ago. On this registry it ranks #59 of 68 tracked projects in Design & Prototyping, with 5 head-to-head comparisons available.

What is open-pencil-cloud?

OpenPencil (Yoohoo fork) is an AI-native, open-source Figma alternative design editor for teams that want a self-hosted .fig-capable editor with cloud document storage, built on a React frontend and a Spring Boot backend.

What it is

OpenPencil (Yoohoo fork) is a productized fork of the upstream OpenPencil design editor, keeping the upstream engine intact — .fig / .pen file I/O, SceneGraph, CanvasKit rendering, Yoga layout, components and instances, and the programmable @open-pencil/core packages — while replacing the upstream Vue 3 app with a React product shell under packages/react and adding a Java server/ backend for cloud documents. The project lives in the design and prototyping ecosystem alongside tools like Figma, and it is explicitly positioned as an open-source Figma alternative; it also draws on Rust, Skia, Tauri, Spring Boot and TypeScript in its stack.

The concrete problem it addresses is that upstream OpenPencil is local-first with no required account and no backend, which suits individual use but not business deployment. This fork adds cloud open/save, Aliyun OSS object storage, internal deployment, and performance overrides such as lazy .fig page loading — implemented through *.override.ts product diffs so upstream sources are not patched in place.

Key capabilities

  • Opens and saves .fig and .pen files with the upstream SceneGraph, CanvasKit rendering and Yoga layout engine.
  • Runs a Spring Boot API in server/ providing cloud documents, JWT authentication with refresh tokens, and OAuth sign-in through GitHub and Google.
  • Stores documents either locally or in Aliyun OSS, configured via STORAGE_TYPE=local or oss, with presigned URLs controlled by OSS_PRESIGN_EXPIRATION_SECONDS.
  • Deploys as a static React build behind nginx plus a Docker Compose API, with APP_ENV selecting config.local.ts, config.dev.ts or config.prod.ts.
  • Builds per environment with bun run start, bun run build:test and bun run build:prod under packages/react.
  • Handles email verification through SMTP, and logs verification codes to the API console when MAIL_HOST is left empty.
  • Persists state in PostgreSQL through DATABASE_URL and Redis via REDIS_HOST, REDIS_PORT, REDIS_PASSWORD and REDIS_DATABASE.

Who uses it and how

  • Teams that need an internally deployed design editor: the fork's stated focus is business use with React app shell and backend integration.
  • Operators running a self-hosted stack with Docker Compose for the API, a PostgreSQL database, Redis, and nginx serving the built packages/react dist.
  • Organisations that already live in the Aliyun ecosystem, given the oss-cn-shanghai.aliyuncs.com endpoint example and OSS bucket configuration.
  • Users who want a purely local workflow: without the API, the editor still opens local .fig files, with cloud open/save requiring the server or a remote API URL in config.
  • Contributors and users who track upstream OpenPencil development while carrying product overrides that prefer *.override.ts files.

Getting started

Install from the repository root with bun install, start the editor with bun run start inside packages/react and open http://localhost:8000, and optionally run the API with Maven from server/ or via Docker Compose against a published image configured through server/.env.

How it compares

The facts describe upstream OpenPencil as the reference point rather than a competing product: upstream ships a Vue 3 app, a local-first backend-free workflow, and official web and desktop releases, while this fork keeps the same engine packages and MIT licence but contributes a React shell, cloud open/save, Aliyun OSS storage, and Docker Compose hosting. It stands alongside the upstream project rather than replacing it.

When to use it — and when not

Self-hosters must operate a PostgreSQL database, Redis, an SMTP mail service, an object storage backend (local or OSS), JWT secret management, and CORS configuration, which is a materially heavier footprint than upstream's local-first mode. It is a poor fit for anyone who wants the upstream Vue app, desktop releases, or a zero-backend setup, and the fork's README is explicit that it is a product fork — four open issues and a sparse fork README relative to upstream suggest checking activity and documentation depth before committing.

project readme (upstream, from github) — read inline

OpenPencil (Yoohoo fork)

A product fork of the open-source OpenPencil design editor. It keeps the upstream engine (.fig / .pen, CanvasKit rendering, SceneGraph) and adds a React shell, cloud documents, and internal deployment.

Upstream OpenPencil is under active development. This fork focuses on a React app shell and backend integration for business use.

Live preview → · Upstream demo · Upstream docs


Relationship to upstream OpenPencil

Upstream OpenPencil This fork (Yoohoo)
Focus Open-source editor + CLI / MCP / Vue SDK Productized editor on the same engine
App UI Vue 3 app under src/ Primary shell: packages/react
Backend Local-first, no required account Java server/ + cloud docs / OSS
Hosting Official web / desktop releases Static web app + Docker Compose API
Engine @open-pencil/core and related packages Same packages; product diffs prefer *.override.ts
License MIT MIT (upstream) + fork-owned config / deploy

Same: .fig I/O, SceneGraph, CanvasKit, Yoga layout, components/instances, and the programmable core.

Different: React product shell, cloud open/save, Aliyun OSS, and performance overrides (for example lazy .fig page load) without patching upstream sources in place.


Live preview

Environment URL
Dev preview http://pencil.dev.yoohoo.cn/
imageimageimage

Local development

Requirements

  • Bun (latest stable recommended)
  • Optional: Docker (to run the API locally via Compose)

Install

From the repo root:

bun install

Start the React editor

cd packages/react
bun run start
# NODE_ENV=development APP_ENV=local rspack server

Uses config.local.ts (API defaults to http://localhost:8080). Open http://localhost:8000.

Useful builds:

cd packages/react
bun run build:test   # APP_ENV=test (dev preview build)
bun run build:prod   # APP_ENV=prod

Start the API locally (optional)

Point Compose at a published image (adjust the tag as needed):

DATABASE_URL=jdbc:postgresql://xxx:5432/open-pencil
DATABASE_USERNAME=open-pencil
DATABASE_PASSWORD=xx
JWT_SECRET=your-super-secret-jwt-key-change-in-production-min-32-chars
SPRING_PROFILES_ACTIVE=dev

REDIS_HOST=xx
REDIS_PORT=xxx
REDIS_PASSWORD=xxx
REDIS_DATABASE=0

CORS_ALLOWED_ORIGINS=http://localhost:3000,http://localhost:1420,http://localhost:8000


JWT_EXPIRATION=8640000000
JWT_REFRESH_EXPIRATION=604800000


OAUTH_GITHUB_CLIENT_ID=xx
OAUTH_GITHUB_CLIENT_SECRET=xx
OAUTH_GOOGLE_CLIENT_ID=xx
OAUTH_GOOGLE_CLIENT_SECRET=xxx


# SMTP (leave MAIL_HOST empty to log verification codes in the API console)
MAIL_HOST=xxx
MAIL_PORT=xx
MAIL_USERNAME=xx
MAIL_PASSWORD=xx


# Storage: local / oss
STORAGE_TYPE=local

OSS_ENDPOINT=oss-cn-shanghai.aliyuncs.com
OSS_ACCESS_KEY=xx
OSS_SECRET_KEY=xx
OSS_BUCKET=xx
OSS_BASE_PATH=xx/
OSS_PRESIGN_EXPIRATION_SECONDS=900

cd server

Maven run Springboot

Without the API, the editor still opens local .fig files; cloud open/save needs the server (or a remote API URL in config).


Cloud deployment

Frontend (React static app)

Build and publish the packages/react dist (for example via .github/workflows/react-ui-deploy.yml), then serve it behind nginx. Dev preview: http://pencil.dev.yoohoo.cn/.

APP_ENV Config Typical use
local config.local.ts Local rspack
test config.dev.ts Dev preview site
prod config.prod.ts Production site

Backend (Docker Compose)

Run the API with Docker Compose on the host (same shape as local):

DATABASE_URL=jdbc:postgresql://xxx:5432/open-pencil
DATABASE_USERNAME=open-pencil
DATABASE_PASSWORD=xx
JWT_SECRET=your-super-secret-jwt-key-change-in-production-min-32-chars
SPRING_PROFILES_ACTIVE=dev

REDIS_HOST=xx
REDIS_PORT=xxx
REDIS_PASSWORD=xxx
REDIS_DATABASE=0

CORS_ALLOWED_ORIGINS=xxx,http://pencil.dev.yoohoo.cn


JWT_EXPIRATION=8640000000
JWT_REFRESH_EXPIRATION=604800000


OAUTH_GITHUB_CLIENT_ID=xx
OAUTH_GITHUB_CLIENT_SECRET=xx
OAUTH_GOOGLE_CLIENT_ID=xx
OAUTH_GOOGLE_CLIENT_SECRET=xxx


# SMTP (leave MAIL_HOST empty to log verification codes in the API console)
MAIL_HOST=xxx
MAIL_PORT=xx
MAIL_USERNAME=xx
MAIL_PASSWORD=xx


# Storage: local / oss
STORAGE_TYPE=oss

OSS_ENDPOINT=oss-cn-shanghai.aliyuncs.com
OSS_ACCESS_KEY=xx
OSS_SECRET_KEY=xx
OSS_BUCKET=yoohoo-oss
OSS_BASE_PATH=xx/
OSS_PRESIGN_EXPIRATION_SECONDS=900

services:
  open-pencil-server:
    image: registry.cn-hangzhou.aliyuncs.com/jongwong/open-pencil-server:0.0.1-beta.28
    container_name: open-pencil-server
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=dev
      - LOCAL_STORAGE_PATH=/app/storage
    volumes:
      - /data/docker-mnt/open-pencil-server/.env:/app/.env
      - /data/docker-mnt/open-pencil-server/storage:/app/storage
    restart: unless-stopped
    networks:
      - app-network

networks:
  app-network:
    external: true
# Ensure app-network exists, then:
docker compose pull open-pencil-server
docker compose up -d open-pencil-server

Update the image tag when releasing a new server build. Mount a real .env and persistent storage directory on the host. Use SPRING_PROFILES_ACTIVE=prod for production if that profile is configured in server/.

Image source: server/Dockerfile (multi-stage Maven → JRE).


Repository layout (excerpt)

packages/
  scene-graph/   graph model (may include index.override.ts)
  fig/           .fig parse / instances (*.override.ts)
  core/          engine / renderer / editor (performance overrides)
  react/         React product shell + cloud integration (primary app)
  cli/ mcp/ …    upstream programmable tooling
server/          cloud API (Java)

Prefer *.override.ts for product/engine diffs so upstream files stay mergeable; rspack remaps overrides at build time.


Upstream capabilities

Upstream still ships CLI (@open-pencil/cli), MCP, desktop AI agents, P2P collab, and token analysis. See:

This fork’s day-to-day path is the React shell + Compose API.


Checks

bun run check        # full gate
bun run test:unit    # unit tests
bun run format       # format

License

MIT License (upstream).

Upstream copyright belongs to OpenPencil contributors. Fork-owned React shell, cloud config, and deploy compose belong to this project’s maintainers.

Frequently asked questions

Is open-pencil-cloud free to use?

open-pencil-cloud is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does open-pencil-cloud do?

AI-native design editor, open-source Figma alternative with Spring Boot and React.

What is open-pencil-cloud written in?

open-pencil-cloud is primarily written in TypeScript. Its source is publicly available at https://github.com/yoohoo360/open-pencil-cloud, and it has 1,104 GitHub stars.