layerling README

项目的 README,来自 github.com/henmedia/layerling。合并为一个 markdown 文件:README.md。

layerling logo

layerling

Easy 3D CAD for 3D printing

Drop a shape, cut a hole, round an edge, print it. In your browser, with no account and no CAD background.

GNU AGPLv3 license No account needed Made for 3D printing Drivable by AI

English · Deutsch · Español · Nederlands · Polski · Svenska · العربية · 日本語 · 简体中文 · 繁體中文

layerling in the browser

layerling in the browser

User guide, step by step and with pictures

Who It Is For

You own a 3D printer. You want a part that fits something, not a career in CAD.

layerling works the way you already think: put a shape on the plate, drag it to size, turn a second shape into a hole, group the two, export, print. There is nothing to learn before you start and nothing to sign up for – open the page and build. Your designs stay in your own browser by default: no account, no cloud, nothing uploaded anywhere. If you run your own copy, they can live in a folder on your server instead, so every device in the house sees the same ones.

Coming From Tinkercad?

layerling sits a step beyond Tinkercad towards Fusion 360: it is operated the same way, so you will recognise everything – the plate, the shapes, solids and holes, group and ungroup, bundle, Alt-drag for a copy – but it does not stop where Tinkercad does. Things you have been missing are waiting for you:

It is not a full CAD package: there is no parametric timeline and no assemblies. And you can run it yourself: install it as an app (it then starts without internet), or host your own copy on Windows, a NAS or a home server – see Getting Started.

An AI can build along with you. layerling ships an MCP server. An AI client such as Gemini, Claude or Codex sees an open editor tab and works in it: add shapes, change measurements, group, cut, round edges, read the scene back, take pictures of the viewport. You describe the part, the AI builds it, you watch it happen and step in whenever you want. This runs locally, with nothing leaving the browser – see layerling MCP Skill for the setup.

What It Does

Building

Refining

Files

Viewing

Videos

Made by others, not by this project:

Getting Started

The shortest way is the hosted version. Nothing to install, nothing to sign up for – open it and build:

https://layerling.com/

The rest of this section is about running your own copy: on your computer, or on a machine in the workshop that everyone opens in their browser. Wherever the app is served from, nothing is sent to anyone else: designs stay in the browser they were made in (or in the server folder you set up yourself), and exports download straight to the person's own computer.

Windows Quickstart

Never used a terminal before? On a Windows 11 (or current Windows 10) machine with nothing installed yet, open PowerShell (search for it in the Start menu, no administrator rights needed) and paste this one line:

irm https://raw.githubusercontent.com/henmedia/layerling/main/scripts/windows-quickstart.ps1 | iex

It installs Git and Node.js if they are missing, downloads layerling into %USERPROFILE%\layerling, and opens it in your browser at http://127.0.0.1:3000/. Leave the PowerShell window open while you use layerling; Ctrl+C in that window stops it.

Run the very same line again whenever you want to update layerling – it notices the existing folder and pulls the latest version instead of downloading it a second time. The script itself lives at scripts/windows-quickstart.ps1, so you can read exactly what it does before running it, or download it and run it locally instead of piping it into PowerShell.

Opening It Again Later

The one-liner above also leaves a shortcut named “Start layerling” on your desktop. Double-click it whenever you want to open layerling again – no PowerShell, no re-installing, no re-downloading, just the server starting and your browser opening on its own. It also updates layerling first (when the folder has no changes of your own) and opens the browser only once the server is really ready. If layerling is already running, it starts no second server and does not update underneath the running one - it just opens the page. Wanted layerling somewhere else, say on another drive? Run the script with the folder you want:

& ([scriptblock]::Create((irm https://raw.githubusercontent.com/henmedia/layerling/main/scripts/windows-quickstart.ps1))) -InstallPath "D:\3DPrinter\Layerling"

If your shortcut was made by an older version of the script, run the one-liner once more; it replaces the shortcut with the new one.

Prefer doing it by hand? Open PowerShell and run:

cd $env:USERPROFILE\layerling
npm run dev

then open http://127.0.0.1:3000/ yourself. Ctrl+C in that window stops it either way.

macOS Quickstart

On a Mac, open the Terminal app (press Cmd+Space, type Terminal, press Enter) and paste this one line:

curl -fsSL https://raw.githubusercontent.com/henmedia/layerling/main/scripts/mac-quickstart.sh | sh

It needs Git and Node.js 22.18 or newer. If one is missing, the script says what to install (macOS offers the developer tools with Git in a window, Node.js comes as an installer from nodejs.org; with Homebrew it installs them itself) and stops, so you can run the same line again. Then it downloads layerling into ~/layerling, puts "Start layerling" on your desktop and opens layerling in your browser at http://127.0.0.1:3000/. Leave the Terminal window open while you use layerling; Ctrl+C in that window stops it.

Run the same line again whenever you want to update: the existing folder is kept, and starting layerling pulls the latest version first. The script lives at scripts/mac-quickstart.sh, so you can read what it does before you run it. For another folder: LAYERLING_DIR=~/3D/layerling sh mac-quickstart.sh (after downloading the script). It has not been tried on a real Mac yet; if something goes wrong, please tell us in the discussions.

Docker

To run layerling on a computer, NAS (Synology, Unraid, etc.) or home server without installing Node.js, use the ready-made image henmedia/layerling on Docker Hub (also at ghcr.io/henmedia/layerling, the same image). Every release publishes it for amd64 and arm64 (Raspberry Pi, ARM NAS) under its version number and as latest. The app listens on port 3000.

New to Docker? Running layerling in Docker, step by step starts from nothing on Windows, macOS or Linux: it installs Docker, starts layerling and saves your designs as files in a folder on your computer.

The quickest way is a single command:

docker run -d --name layerling -p 3000:3000 -v layerling-thumbnails:/app/.codex/project-thumbnails --restart unless-stopped ghcr.io/henmedia/layerling:latest

The -v option keeps the preview pictures of the start page in a Docker volume named layerling-thumbnails, so they survive an update; without it they are inside the container and gone each time it is created again (the designs themselves are not affected: they live in the browser or in the server folder). On a NAS with a container manager (Synology Container Manager, Unraid, Portainer), search for henmedia/layerling in its registry (Docker Hub) or enter henmedia/layerling:latest, map port 3000, and add a volume for /app/.codex/project-thumbnails. To update, pull the image again and recreate the container (or let Watchtower do it). On Unraid, layerling is also in the Community Applications store: search for “Layerling” and install it with a few clicks; the template, maintained by jbat66, already sets up server storage on an Unraid share.

The image tags are plain version numbers without a "v": ghcr.io/henmedia/layerling:1.42.0, while the GitHub release is called v1.42.0. A pull only fetches the new image; a container that already exists keeps running the old one until it is removed and created again:

docker pull ghcr.io/henmedia/layerling:latest
docker stop layerling
docker rm layerling
docker run -d --name layerling -p 3000:3000 -v layerling-thumbnails:/app/.codex/project-thumbnails --restart unless-stopped ghcr.io/henmedia/layerling:latest

docker inspect layerling | grep image.version shows which version the container really runs. If you mounted a folder for the server storage, add the same -v option again.

To build the image yourself instead, use the included Dockerfile and compose.yml:

  1. Install Docker. On Windows or macOS, install and start Docker Desktop. On Linux or a NAS you need Docker with Compose (docker compose or the standalone docker-compose).
  2. Get the files. Either download the repository as a ZIP (Code → Download ZIP) and extract it, or clone it:
    git clone https://github.com/henmedia/layerling.git
    cd layerling
    
  3. Start it. In the project folder, open a terminal (e.g. PowerShell on Windows) and run:
    docker compose -f docker/compose.yml up -d --build
    
    With the older standalone binary, write docker-compose instead of docker compose. Docker builds the image and runs the container in the background (-d); the first build takes about 2–3 minutes. Without --build, the same command pulls the ready-made image instead.
  4. Open it. On the same computer at http://localhost:3000/, from other devices on your network at http://<YOUR-SERVER-IP>:3000/.

Everyday commands:

Installing as an app and offline use need https, and the static export. A browser installs an app and keeps it for offline use only on https:// or on localhost; on a plain http://192.168.x.x:3000 address it offers neither (layerling hides its install hint there). Even with https, the offline files (sw.js) are written only into the static export (see Static Hosting), not into this image, which runs the server version. For installing and offline use on a network, serve the static export over https; for an https address in front of the container, use a reverse proxy such as Caddy or nginx with a certificate (for example from mkcert).

The image runs node apps/web/server.js in production mode, so the MCP bridge is off there unless you switch it on (see Letting an AI client reach a copy on a NAS or server). To offer a shared project folder, bind a writable directory and set LAYERLING_SHARED_PROJECTS_DIR in compose.yml to the path inside the container where it is mounted, for example ./shared-projects:/shared-projects with LAYERLING_SHARED_PROJECTS_DIR: "/shared-projects" (see Shared Designs on a Network). The container runs as the user with the number 999, so that user must be allowed to write to the folder: sudo chown 999:999 ./shared-projects, or add user: "1000:1000" to the service (your own user and group numbers, id -u and id -g show them) so that the container runs as you. Without it the folder shows up on the start page but nothing can be saved there. After changing it, run docker compose up -d: docker compose restart keeps the old setting. docker exec <container> printenv LAYERLING_SHARED_PROJECTS_DIR shows the one in use.

To keep every design in that folder and none in the browser, there is a complete guide in English and German with its own compose file and an update script that checks the configuration, backs up the folder and rolls back a failed update: docs/docker, written by Jürgen Keller. With LAYERLING_NEW_DESIGNS_ON_SERVER: "always", everything that makes a design goes to the server folder: the tile, opening or importing a file, restoring a backup (with its folders), duplicating and a state taken from the history, and New folder on the start page makes a server folder.

To choose the colour theme people get on their first visit, set LAYERLING_DEFAULT_THEME to system, light, dark or graphite (the same way, in compose.yml or in the environment of npm run start). Anyone who has opened layerling before keeps the theme their browser already has, and anyone can still change it with the theme switch. Without the setting the theme follows the system. A copy served as plain files has no server to read it, so it does not apply there.

For a class or a workshop with children, LAYERLING_SIMPLE_MODE starts layerling in its simple mode: the ribbon keeps the tools a workshop uses, the shape library a short list, the buttons are larger, and the start page shows the designs and no news, no welcome text and no links out of layerling. true is the start for people who have not chosen (the settings have a switch, and leaving the mode there takes a press held for two seconds), always holds for everyone and takes the switch away. A link ending in ?mode=simple switches it on for the device that opens it, and ?mode=full off again. It is set the same way as the others, and a copy served as plain files has no server to read it (the link and the setting still work there).

With the shared folder on, LAYERLING_NEW_DESIGNS_ON_SERVER makes new designs start on the server: true is the start for people who have not chosen (they can untick New designs on the server on the start page), always holds for everyone and locks the tick. It is set the same way, and a copy served as plain files has no server to read it.

Behind a reverse proxy with a domain, the proxy has to pass on the original Host and X-Forwarded-Proto (nginx: proxy_set_header Host $host; and proxy_set_header X-Forwarded-Proto $scheme;), otherwise saving to the server is refused with "Shared projects only accept requests from this site.". If the proxy rewrites the host and you cannot change that, list the address people use in LAYERLING_ALLOWED_ORIGINS (comma-separated, for example https://layerling.example.com).

Static Hosting: Plain Files on a Web Server

Any web server can serve layerling as plain files; no Node.js runs on it. Build the files once on a computer that has Node.js (see What You Need):

npm install
npm run export

The finished site is in apps/web/.next-export/. Copy the contents of that folder (not the folder itself) into the web server's document root, so that index.html lies directly in it.

Four things to know:

Editor profiles

An optional editor profile changes the 3D ribbon and selected tool options for this page. To try the example profile in a local checkout:

LAYERLING_EDITOR_PROFILE="$(cat docs/examples/editor-profile.json)" npm run dev

Open the editor, add a box, and select it. The simple ribbon uses the usual icon size. Print check is visible and Lid and Flexi joints are hidden. Open Fillet to see a starting radius of 2 mm on a box large enough for it. The Only visible edges option is hidden and on.

LAYERLING_EDITOR_PROFILE is read by the layout when the HTML is generated. Set it before starting the development server or building production HTML, including a static export. Hosts that generate HTML themselves may instead provide one <script type="application/json" id="layerling-editor-profile">…</script> in the document head before Layerling's scripts. Escape literal < in the serialized JSON as \u003c. Profiles are independent of project files and browser settings and are read once per page load. For per-account profiles, serve the personalized HTML from a private, uncached page outside the static service worker’s offline cache, such as a PHP entry point.

Shared Designs on a Network

layerling itself is only files, so the shared folder needs something on the server that can write. There are two ways, and you need just one of them: Node or Docker (this section, with LAYERLING_SHARED_PROJECTS_DIR), or a plain web server with PHP (the store folder, further down). A web server that serves the files without either of them – npx serve, nginx or Apache without PHP – shows layerling fine, but has no server folder.

If you run layerling with npm run dev or npm run start on a machine other people open in their browser, it can offer a shared folder for .lyl designs. npm run start serves what npm run build made, so run that once first. Point LAYERLING_SHARED_PROJECTS_DIR at a directory the user who starts layerling may write to (a folder under /srv often belongs to root, make one of your own or change its owner) and start:

LAYERLING_SHARED_PROJECTS_DIR=/srv/layerling-projects npm run start

The start page then shows the designs in two tabs, Server for the shared folder and Browser for the designs of this browser. With the Server tab open, Create new 3D design starts a design in the server folder you are in, New folder makes a subfolder, and a trail under the tabs says where you are and leads back out. Designs move by dragging them onto a folder or onto a step of the trail – or through Move to … in their menu. A design from your browser goes onto the server by dragging its card onto the Server tab, or with Put on the server in its menu; a folder goes the same way, with everything in it, and stays a folder on the server. The way back is Put in this browser in the menu of a server design, or dragging its card onto the Browser tab: the design then lives only in this browser and leaves the server folder, also for the others.

Two buttons on the start page save the trouble of moving designs one by one: Put all on the server moves every design of this browser into the server folder in one go, in the same folders, and the tick New designs on the server makes each new design start in the server folder, so it is saved there from the first change on. A design whose name is already taken on the server stays in the browser.

The search box at the top searches the whole server folder, not just the one you are standing in. Every hit says which folder holds it, and that folder is a button: one click and you are there, with the search cleared. Folders are found by name too. While you are searching, the server tile on the start page says how many matches are waiting over there.

Duplicate in a design's menu makes a copy of it. On the server the file itself is copied, next to the original and under a free name, picture and all – nothing is repacked, so the copy carries exactly the geometry of the original. In your browser the copy becomes a design of its own, with the same shapes, the same history and its own preview picture, and it belongs to nobody on the server.

Open a copy in the same menu does the same and opens the copy right away, for trying something out: the original stays as it was, whatever you do in the copy.

A design that lives on the server saves itself back there, five seconds after the last change and when you leave the editor. Thumbnails land beside the files in .thumbnails. Designs that are only in your browser stay there, untouched.

Custom shapes saved to the server go into a folder named Custom shapes at the top of the store, one .lyl with its picture each. layerling creates it with the first such shape; it is an ordinary folder, so it shows on the start page and a shape in it opens and saves like any design. Neither the Node route nor store.php needs anything extra for it.

The settings saved with "Make default" in the workspace settings are kept in the store too, as .settings/default.json (a hidden folder the start page does not list). A browser that has lost its own, because its data was cleared or it is another browser, picks them up when the start page loads, so a new design starts with them again. There is one default for the whole store; the last one saved in any browser wins. Delete the file to go back to each browser's own.

Opening a design from the server gives you a private local working copy. Saving back checks the revision on the server first; if someone else changed the file in the meantime, layerling refuses to overwrite it and asks you to reload or save under a different name. This is shared file storage, not simultaneous editing.

Behind an authenticating reverse proxy (such as Authelia, oauth2-proxy, Cloudflare Access, or HTTP Basic Auth), set LAYERLING_USER_HEADER to the header your proxy sets (e.g. LAYERLING_USER_HEADER=X-Forwarded-Email or in Apache SetEnv LAYERLING_USER_HEADER Remote-User) to isolate each user's designs into .users/<user>/. This is only safe when layerling can be reached through the proxy alone, so nobody can send arbitrary headers directly to the server.

Without Node: the store Folder

An installation served as a static export – plain files on a web server – cannot write anything by itself. For that case store.php travels with the export. Create a folder named store next to index.html that the web server may write to, and layerling offers the same shared storage as above, folders and all. Without the folder the feature stays invisible, and the short guide in the editor explains how to switch it on. The web server needs PHP.

PHP limits uploads by default (upload_max_filesize and post_max_size, a few megabytes), and a large design or a backup of many designs can be bigger. store.php then says which limit it ran into and what it stands at; raise both in php.ini, or in the Docker image with a file such as uploads.ini in /usr/local/etc/php/conf.d/ (upload_max_filesize = 512M, post_max_size = 512M).

The folder has no login: whoever can reach the page can read, write and delete what is in it. On a home network or in a workshop that is the point; on a publicly reachable site, protect it or leave it out.

Nothing in the folder is meant to be opened by its address: layerling reads and writes it only through store.php. On Apache, store.php writes a .htaccess into the folder that refuses every direct request. Apache reads it only where AllowOverride lets it (Debian's default for /var/www is None, which ignores it), and nginx and other servers never do, so deny access to store/ there yourself (in Apache: <Directory /var/www/html/store> Require all denied </Directory>, in nginx: location /store/ { deny all; }). store.php also checks every export it saves, so a file that could run in a browser is refused either way.

The folder can also live outside the web root, where no address reaches it at all, .htaccess or not: set LAYERLING_SHARED_PROJECTS_DIR, the same setting the Node server reads, to its path – in Apache with SetEnv LAYERLING_SHARED_PROJECTS_DIR /var/layerling-projects, in nginx with fastcgi_param LAYERLING_SHARED_PROJECTS_DIR /var/layerling-projects;, in Docker as an environment variable of the container. That folder then takes the place of store; it too has to exist and be writable for the web server.

One thing to remember when deploying: if you mirror the export with an option that removes anything extra – rsync --delete, robocopy /MIR, WinSCP -delete – exclude store explicitly, or every update will wipe the projects.

Working on layerling

Take this path if you want to change the code.

What You Need

Check your versions with node -v and npm -v. If those commands do not work, install Node.js from the official Node.js website and reopen your terminal.

Install and Run

git clone https://github.com/henmedia/layerling.git
cd layerling
npm install
npm run dev

No Git? Press the green Code button on the GitHub page, choose Download ZIP, extract it, open a terminal in the extracted folder and start with npm install.

Then open http://127.0.0.1:3000/. Leave the terminal open while you use the app; Ctrl+C stops the development server.

To open the development server from another computer by a name, such as http://myhost.local:3000/, list that name in the environment variable LAYERLING_ALLOWED_DEV_ORIGINS before you start (several names separated by commas, *.local for every name ending in .local). Without it, the development server answers only to localhost and 127.0.0.1. The static export and npm run start do not need it.

On Linux and macOS, scripts/start-layerling.sh does the daily start for you: it updates the checkout first (skipped if you changed files in it), starts the server, waits until it answers and then opens the browser. Run it from anywhere, for example ~/layerling/scripts/start-layerling.sh. It needs Git and Node.js, as above. If layerling already runs on that port, it only opens the browser instead of starting a second server. Port 3000 taken by something else? Start it with PORT=3100 scripts/start-layerling.sh. It has been tried on Debian Linux (without a desktop, so the browser step only prints the address) and in a Windows shell; macOS is untested – if it misbehaves on your system, please tell us in the discussions.

Developing in a Container

Prefer not to install Node.js? Develop in a container instead. You need a container engine with Compose – docker compose or podman compose (rootless Podman on SELinux works too; the :z flag in the compose file handles the file labels):

docker compose -f docker/compose.dev.yml up

Open http://127.0.0.1:3000/. The first start installs dependencies; later starts go straight to the dev server with hot reload. Stop it with Ctrl+C. If you update dependencies and something looks stale, delete node_modules/ in the project folder and start again.

Running the production container from docker/compose.yml at the same time? It uses port 3000 as well – change the host-side port on one of them (e.g. "3100:3000").

Useful Commands

Command What it does
npm run typecheck TypeScript checks
npm run test Unit tests
npm run test:e2e End-to-end tests
npm run build Production build (npm run start serves it)
npm run export Static export for plain web hosting
npm run guide Build the user guide pages from docs/guide (the export and npm run dev do this too)
npm run guide:images Retake the guide's pictures from the running program (needs npm run dev -- -p 3010; see docs/guide/README.md)
npm run printers:update Refresh the printer presets from OrcaSlicer's profiles
npm run mcp:layerling Start the MCP server for AI clients (see below)

layerling MCP Skill

layerling includes a local MCP server for AI clients that support MCP tools. It lets an agent inspect and control a live editor tab: list open editors, read the scene, create, update and select objects, group, cut and separate parts, list CAD edge ids, apply chamfer or fillet, hollow a body, inspect errors and capture viewport images.

It works against a local development server. In production builds and static hosting the MCP route is disabled, unless the server switches it on with an access token (see below); on layerling.com it is always off.

  1. Start layerling from the project folder with npm run dev (see Install and Run).
  2. Open an editor tab, e.g. http://127.0.0.1:3000/?editor=1 - or leave it out: when no editor is open, the first tool that needs one starts your browser with an editor (not for a copy on a NAS or server; LAYERLING_MCP_OPEN_EDITOR=0 switches it off).
  3. Connect your AI client as described below. It starts the MCP server itself with node scripts/layerling-mcp-server.mjs.

The main tool names are layerling_list_editors, layerling_read_scene, layerling_list_objects, layerling_create_shape, layerling_update_object, layerling_list_edges, layerling_apply_edge_treatment, layerling_hollow_object, layerling_make_lid, layerling_offset_object, layerling_cut_out, layerling_punch, layerling_array_objects, layerling_set_section_view and layerling_capture_image.

Claude Code

Nothing to install: the repo already ships .mcp.json, which registers the MCP server for this project, and a copy of the skill at .claude/skills/layerling-mcp-skill, which is where Claude Code looks for one. Open the layerling folder in Claude Code and ask:

Use the layerling MCP tools to list my open layerling editors and inspect the current scene.

Claude Desktop

Claude Desktop does not read a project's .mcp.json or skill files, but it can use the same MCP server through its own config. Add the server there, using docs/mcp/claude-desktop-config.example.json as the template and replacing the script path with the absolute path on your machine. After restarting Claude Desktop, ask:

Use the layerling MCP tools to list open editors, inspect the scene, and modify the selected object.

Codex

Copy the skill from docs/skills/layerling-mcp-skill into your Codex skills folder.

Windows PowerShell:

New-Item -ItemType Directory -Force "$env:USERPROFILE\.codex\skills" | Out-Null
Copy-Item -Recurse -Force "docs\skills\layerling-mcp-skill" "$env:USERPROFILE\.codex\skills\layerling-mcp-skill"

macOS or Linux:

mkdir -p ~/.codex/skills
cp -R docs/skills/layerling-mcp-skill ~/.codex/skills/

Then add an MCP server entry to your Codex config, using docs/mcp/codex-config.example.toml as the template and replacing the script path with the absolute path on your machine. Restart Codex and ask:

Use $layerling-mcp-skill to list my open layerling editors and inspect the current scene.

Gemini & Antigravity

For Antigravity, the repo ships a copy of the skill at .agents/skills/layerling-mcp-skill, which Antigravity discovers automatically. For Gemini CLI, copy the skill from docs/skills/layerling-mcp-skill into your global skills folder.

Windows PowerShell:

New-Item -ItemType Directory -Force "$env:USERPROFILE\.gemini\skills" | Out-Null
Copy-Item -Recurse -Force "docs\skills\layerling-mcp-skill" "$env:USERPROFILE\.gemini\skills\layerling-mcp-skill"

macOS or Linux:

mkdir -p ~/.gemini/skills
cp -R docs/skills/layerling-mcp-skill ~/.gemini/skills/

Then add the server to your Gemini CLI settings.json or Antigravity mcp_config.json, using docs/mcp/gemini-config.example.json as the template and replacing the script path with the absolute path on your machine. Restart the client and ask:

Use the layerling MCP tools to list my open layerling editors and inspect the current scene.

Letting an AI client reach a copy on a NAS or server

A copy you host yourself (the Docker image on a NAS, a home server) can let an AI client drive its open editors over the network. It is off by default, because whoever can drive the bridge can read and change the open designs. Switch it on with two settings on the server, read when it starts - the ready-made image needs no rebuild:

environment:
  LAYERLING_MCP_REMOTE: "true"
  LAYERLING_MCP_TOKEN: "a-long-random-secret-of-at-least-16-characters"

Without a token of at least 16 characters the bridge stays closed. Then:

  1. Open an editor tab of that copy in a browser, e.g. http://nas:3000/?editor=1, and keep it open.
  2. Give the MCP client the address and the same token: set LAYERLING_URL=http://nas:3000 and LAYERLING_MCP_TOKEN=<the token> in its configuration (see the examples in docs/mcp).

The token protects the commands: only a client that sends it can list or drive the editors. The editor pages need none, but they only count when they are pages of that copy, opened by an address or a name that only someone in your own network can use (an IP address, a name without a dot, or one ending in .local or .lan). This keeps a web page on the internet from reaching your NAS through your browser. If you open the copy under a real domain, for example behind a reverse proxy, list it in LAYERLING_MCP_ALLOWED_HOSTS (comma-separated). Use this on a network you trust, and use HTTPS for anything beyond it: the token travels in a header.

Contributing

Contributions are welcome, and you do not have to be a 3D printing person to help – a clearer sentence in this README counts. Good places to start:

Read .github/CONTRIBUTING.md before opening a pull request. What changed in each version is in the changelog.

Security

Please do not open public issues for security-sensitive reports. Read .github/SECURITY.md for the reporting process.

Where This Comes From

layerling is a fork of SketchForge-3D by Formsmith746 and the SketchForge contributors. The fork started on 16 September 2026 from SketchForge 1.0.9. SketchForge remains an excellent project and the reason this one exists.

Trademarks

Tinkercad is a trademark of Autodesk, Inc. layerling is an independent project and is not affiliated with, endorsed or sponsored by Autodesk.

License

Copyright (C) 2026 layerling contributors. Copyright (C) 2026 SketchForge contributors.

layerling is a modified version of SketchForge-3D and is licensed under the GNU Affero General Public License v3.0 only (AGPL-3.0-only) – the same licence as the original. See LICENSE.

If you modify layerling and let people use the modified version over a network, section 13 of the licence requires you to offer them the corresponding source code. The dashboard carries a Source link for exactly that: set NEXT_PUBLIC_SOURCE_CODE_URL at build time to the public URL of the source your build came from.

layerling (henmedia/layerling)

正在搜索数据库…

这是什么?Layerling 是一款免费的、基于浏览器的 3D CAD 工具,用于设计 3D 打印零件。你可以把形状拖到打印平台上,挖孔、圆化边缘、编组零件并导出,无需账户,也不需要 CAD 基础。
这是像 Fusion 360 那样的完整 CAD 软件,还是更简单的工具?它介于 Tinkercad 和 Fusion 360 之间:操作方式与 Tinkercad 相同(平台、形状、编组、捆绑),但增加了倒角、圆角、抽壳、草图、螺纹和齿轮功能,并保留真实的 CAD 几何体,而不只是网格模型。它并不是完整的 CAD 软件包,没有参数化时间线,也不支持装配体。
如何开始设计?需要安装什么吗?只需在浏览器中打开页面即可开始建模。你也可以把它安装为应用,这样没有网络时也能启动;或者在 Windows、NAS 或家庭服务器上自托管自己的副本。
如果想自托管而不只是在浏览器中使用,需要准备什么?自托管需要 Node.js 来构建文件(也支持通过 compose.yml 使用 Docker)。如果希望离线使用或应用安装功能正常工作,则必须使用 HTTPS。
与完整的 CAD 软件相比,layerling 有哪些做不到的?它没有参数化时间线,也不支持装配体,因此无法像 Fusion 360 那样回溯并编辑设计历史。
使用它需要有 CAD 经验吗?不需要。它面向拥有 3D 打印机、只想打印出合适零件的人,而不是专业 CAD 工程师,开始之前无需学习任何东西。
我的设计存储在哪里?默认情况下,设计完全保存在你自己的浏览器中,不会上传任何内容,也无需注册账户。
AI 能帮我建模吗?可以。Layerling 提供了 MCP 服务器,因此 Gemini、Claude 或 Codex 等 AI 客户端能看到已打开的编辑器标签页,并在你观看的同时添加形状、修改尺寸、编组、切割和圆化边缘。所有操作都在本地运行,数据不会离开浏览器。
它有哪些与打印机相关的功能?你可以从 220 多款常见打印机中选择,以设置打印平台尺寸;还能查看悬垂警告,标出倾斜角度超过 45° 、需要支撑的面;切片前可以预览模型的体积、重量和耗材长度。
能制作螺纹零件和齿轮吗?可以。支持公制、UNC/UNF 和惠氏管螺纹,用于螺钉、螺母和攻丝孔;还支持直齿、斜齿、人字齿和锥齿轮,模数、齿数、压力角和侧隙均可调节。
可以导出哪些文件格式?可导出 STL、3MF 和 OBJ(多色编组的颜色会保留,适用于多耗材打印),以及用于完整 CAD 软件的 STEP 格式。
作者
henmedia
大小
176.9 MB
星标
472
时长
2个月
提交 · 90 天