Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
docs(modly): document every Modly integration, how to install the three.ws Modly extensions and how to list them in Modly's registry
nirholas35f0ceea7673
diff --git a/NOTICE b/NOTICEindex 3780e1c11..47e4b3078 100644--- a/NOTICE+++ b/NOTICE@@ -16,4 +16,18 @@ Those notices live alongside the code they cover:public/club/**/LICENSES.md per-asset attributioncontracts/lib/** third-party Solidity dependencies+Modly (https://github.com/lightningpixel/modly), MIT License,+Copyright (c) 2026 Lightning Pixel. three.ws builds on it in these places,+each carrying the notice in its header or folder:++ apps/forge-desktop/LICENSE fork of the Modly desktop app+ src/modly-local.js client for Modly's local HTTP API+ src/modly-page.js the /modly page+ src/forge-workflows/ workflow graph and runner+ src/mesh-ops/core.js mesh repair, smoothing, decimation+ src/slicer-handoff.js open-in-slicer links+ api/_lib/print/slicer.js print-ready STL/3MF preparation+ workers/modly/ Modly backend on a GPU worker+ integrations/modly/tests/host/ copy of Modly's BaseGenerator for tests+Nothing in this NOTICE modifies the terms of the Apache License, Version 2.0.diff --git a/STRUCTURE.md b/STRUCTURE.mdindex cce581ab0..e60df86a1 100644--- a/STRUCTURE.md+++ b/STRUCTURE.md@@ -45,6 +45,8 @@ bottom.| Scene Studio (3D scene editor) | [src/scene-studio/](src/scene-studio) `→ /scene`: boot [main.js](src/scene-studio/main.js), shared GLB loader [loader.js](src/scene-studio/loader.js), action bar [actions.js](src/scene-studio/actions.js), first-run overlay [empty-state.js](src/scene-studio/empty-state.js), icon-button labels [toolbar-a11y.js](src/scene-studio/toolbar-a11y.js), chrome [studio.css](src/scene-studio/studio.css) | Vendored [mrdoob/three.js](https://github.com/mrdoob/three.js) r184 editor, MIT, see [src/scene-studio/vendor/README.md](src/scene-studio/vendor/README.md) | Import GLBs, compose scenes, edit materials/lights, export. The sibling modules never touch `vendor/**`: they add the Import-from-Forge / Export-presets / Share bar (which docks beside the resizable sidebar rather than over its tabs), the empty-state card a brand-new scene needs, accessible names plus `aria-pressed` on the icon-only translate/rotate/scale buttons and names on the animation timeline's play/pause/stop transport, and toast-based failures in place of native `alert()`/`prompt()`. Below 600px the sidebar dock drops the vendored `.TabbedPanel` 335px floor so it fits a 320px screen instead of hanging 15px off it, and the empty-state card starts below the action bar and caps itself at the viewport region. Pinned under the nav by `--nav-h` (the real injected-header height), not `--header-h`. Deep links: `?model=<glb_url>`, `?handoff=1` from `/pose`, `#file=<url>`. Docs: [docs/scene-studio.md](docs/scene-studio.md), [src/scene-studio/README.md](src/scene-studio/README.md). Tests: [tests/scene-studio-actions.test.js](tests/scene-studio-actions.test.js) || Diorama (text → 3D world) | [src/diorama/](src/diorama) `→ /diorama` | In-repo · backend [api/diorama.js](api/diorama.js) | One sentence → an explorable 3D diorama: Claude composes the scene, each object is forged to a real GLB, assembled live, saved to a public gallery + shareable permalink || Workbench (image → 3D workflows) | Page [pages/workbench.html](pages/workbench.html) `→ /workbench` + [src/workbench/](src/workbench): controller [main.js](src/workbench/main.js), viewport [viewport.js](src/workbench/viewport.js), in-browser mesh ops [mesh-tools.js](src/workbench/mesh-tools.js), node model [workflows.js](src/workbench/workflows.js), runner [runner.js](src/workbench/runner.js), graph editor [graph-editor.js](src/workbench/graph-editor.js), API client [api.js](src/workbench/api.js) | Live | A desktop-style workspace: icon rail (Generate, Workflows, Extensions, Settings), a workflow panel of node cards, and a viewport with undo/redo, import, GLB/OBJ/STL/PLY export, smooth, decimate and free memory. Workflows are typed image/mesh chains saved per browser and edited in a node graph; they run against the real Forge endpoints (`/api/forge`, `/api/forge-rembg`, `/api/forge-remesh`, `/api/forge?action=rig`, `/api/material-studio`), checkpointing in-browser edits to durable storage before any server step. Extensions reads the live engine catalog and lane health. Docs: [docs/workbench.md](docs/workbench.md) |+| Modly (local GPU generation + Modly app integrations) | Hub page [pages/modly.html](pages/modly.html) `→ /modly` + [src/modly-page.js](src/modly-page.js); shared local client [src/modly-local.js](src/modly-local.js); Forge "Use your GPU" lane [src/forge-modly.js](src/forge-modly.js) wired in [src/forge.js](src/forge.js) `→ /forge`; desktop app [apps/forge-desktop/](apps/forge-desktop); Modly extensions [integrations/modly/](integrations/modly) | Live (web); desktop app and extensions in-repo | Builds on Modly (MIT, Lightning Pixel). Browser surfaces talk to the visitor's own Modly on localhost only after Connect, run its image-to-3D models with real progress and cancel, and copy results to storage so rig/optimize/AR work. Modly users get three.ws cloud nodes and publishing. Docs: [docs/modly.md](docs/modly.md). Tests: tests/modly-local.test.js, integrations/modly/tests/ |+| Mesh tools + slicer handoff | [src/mesh-ops/](src/mesh-ops) (worker repair/smooth/decimate, panel in Forge Optimize and `/m/:id`), [src/slicer-handoff.js](src/slicer-handoff.js), route [api/slicer/model.js](api/slicer/model.js) `→ /api/slicer/:id/[Nmm/]model.stl\|3mf` over [api/_lib/print/slicer.js](api/_lib/print/slicer.js) | Live after deploy; adapted from Modly (MIT) | In-browser mesh repair, Taubin/Laplacian smoothing and decimation with undo, plus Open in OrcaSlicer / Bambu Studio and print-ready STL/3MF downloads. Docs: [docs/forge.md](docs/forge.md). Tests: tests/mesh-ops.test.js, tests/slicer-handoff.test.js || CAD Forge (text → parametric CAD) | Page [pages/cad.html](pages/cad.html) + [src/cad/](src/cad) `→ /cad` and `→ /cad/:id` (controller [main.js](src/cad/main.js), viewer [viewer.js](src/cad/viewer.js), shared parameter contract [params.js](src/cad/params.js)), API [api/cad.js](api/cad.js) `→ /api/cad` over [api/_lib/cad/](api/_lib/cad) (writer ladder, write/build/repair loop, store, service), MCP tools [api/_mcp3d/tools/cad.js](api/_mcp3d/tools/cad.js) (`cad_generate`, `cad_rebuild`), sandboxed kernel worker [workers/cad-forge/](workers/cad-forge) | Built and verified locally · worker deploy pending (deploy it before the API image that carries `/cad`) | A sentence becomes a build123d program the OpenCascade kernel has accepted: kernel errors go back to the writer (Kimi K3 on NIM first) until it builds, and the page streams each real stage. Key dimensions are annotated constants that become sliders; each value set rebuilds on the kernel and is cached under its own link. Downloads STEP, STL, GLB (true scale), a four-view SVG drawing and the Python program; handoffs to AR, Materialize and Scene Studio; refinements are linked designs. Parts join cross-entity search as type `part`. The worker runs model-written code with a static policy, seccomp, an unprivileged uid and rlimits, under a zero-role service account. Docs: [docs/cad-forge.md](docs/cad-forge.md). Tests: [tests/cad-forge.test.js](tests/cad-forge.test.js) plus the worker's in-image gate || Scene Composer (dress an avatar) | [pages/compose.html](pages/compose.html) `→ /compose` + [src/scene-compose.js](src/scene-compose.js) | Live | Forge props from text and parent them to a rigged avatar's skeleton bones, then Export GLB or save them back onto the avatar record as `appearance.attachments`. Bones are grouped into readable regions and stripped of rig prefixes; transform gizmos, 50-deep undo, grid snap, camera presets. Feeds off [api/forge.js](api/forge.js), [api/forge-gallery.js](api/forge-gallery.js) (own creations, falling back to the community showcase for a first-time visitor), [api/explore.js](api/explore.js) `?source=avatar&only3d=1` for the avatar picker, and `PATCH /api/avatars/:id` for Save outfit. Below 900px the scene panel becomes a drawer. Docs: [docs/compose.md](docs/compose.md) || Splat Viewer (photoreal Gaussian avatars) | [pages/splat.html](pages/splat.html) `→ /splat` + page module [src/splat-viewer.js](src/splat-viewer.js), renderer [src/splat-stage.js](src/splat-stage.js) | Live | Renders Gaussian-splat and radiance-field scenes in the browser, the photoreal output of capture engines like GaussianAvatars and HumanGaussian. Loads a `.ply`, `.spz`, `.splat`, `.ksplat` or `.sog` by URL, by upload, by drag-and-drop onto the stage, or from a `?src=` deep link, plus two procedurally generated samples; decoding is entirely client-side and nothing is uploaded. The format is sniffed from the bytes rather than the filename, and the URL loader rewrites GitHub `blob`/`raw`, Hugging Face `/blob/` and Dropbox links to their CORS-enabled raw form so a pasted human-facing link still fetches. [src/splat-stage.js](src/splat-stage.js) is shared with the Forge Studio Lab ([src/forge-studio/lab/mesh-to-splat.js](src/forge-studio/lab/mesh-to-splat.js)) and wraps [Spark](https://github.com/sparkjsdev/spark) (`@sparkjsdev/spark`, MIT), lazy-loaded on first render and torn down explicitly (the WebGL context is released by hand on every scene swap, which Spark's own dispose stops short of). Every state is designed: idle/drop, engine load, fetch, decode, sort, error, and a live HUD carrying the scene label, its real splat count, a recenter control and a download of the loaded buffer. Docs: [docs/splat.md](docs/splat.md) |@@ -308,7 +310,7 @@ bottom.| Walk Avatar browser extension | [extensions/walk-avatar/](extensions/walk-avatar) — MV3 `manifest.json`, `background.js` | In-repo · Chrome Web Store release checklist staged ([RELEASE.md](extensions/walk-avatar/RELEASE.md)) | Walks your three.ws avatar across any site and reads pages aloud — a browsing companion built on the same rig as the [walk-sdk](walk-sdk). Ships its own store-required [PRIVACY.md](extensions/walk-avatar/PRIVACY.md), [PERMISSIONS.md](extensions/walk-avatar/PERMISSIONS.md), and [TERMS.md](extensions/walk-avatar/TERMS.md). || Checkout companion browser extension | [extensions/checkout-companion/](extensions/checkout-companion) (MV3: [extract.js](extensions/checkout-companion/extract.js), [content.js](extensions/checkout-companion/content.js), [panel.js](extensions/checkout-companion/panel.js), [background.js](extensions/checkout-companion/background.js)), analysis [api/_lib/companion/checkout.js](api/_lib/companion/checkout.js), endpoint [api/companion/checkout.js](api/companion/checkout.js) | In-repo | The companion at the moment money moves: on a checkout page it reports the total against the price you were shown, money the page did not itemise, fees named and summed, whether the charge repeats, and the cancellation terms. **Arithmetic is never the model's job** (integer minor units, computed server-side) and **no finding is ever a legal verdict** (`sanitizeModelFindings()` drops any that claims an amount or calls something illegal). With no model reachable the arithmetic findings still stand. The extension **never reads an input**: `collectText`/`collectAmounts` refuse form fields, iframes and editable regions structurally, and redaction runs in the browser before anything is sent; only the hostname travels and nothing about the page is stored. Docs: [docs/checkout-companion.md](docs/checkout-companion.md). Tests: [tests/companion-checkout.test.js](tests/companion-checkout.test.js), [tests/checkout-extract.test.js](tests/checkout-extract.test.js) || Desktop companion app | [apps/desktop/](apps/desktop). Electron main [src/main.js](apps/desktop/src/main.js), preload [src/preload.cjs](apps/desktop/src/preload.cjs), stage [src/renderer/](apps/desktop/src/renderer) | In-repo · packaged with electron-builder (`npm run dist`), not yet published | A transparent, click-through, always-on-top character that strolls across the bottom of the desktop and walks over to deliver what cleared the user's bar. Subscribes to `/api/companion/stream` with the same bridge token the CLI stores, and drives the published [walk embed](pages/walk-embed.html) over its postMessage contract, so it carries no 3D code of its own. Not an npm workspace: it installs and builds on its own (see [apps/desktop/README.md](apps/desktop/README.md)). |-| DCC tool integrations (Blender, ComfyUI) | [integrations/](integrations) — [integrations/blender/](integrations/blender), [integrations/comfyui/](integrations/comfyui), shared Python client [integrations/_pyclient/](integrations/_pyclient) | In-repo | First-party plugins that drive the public Forge pipeline (`/api/forge`) from inside the tools artists already use, so a model is generated without leaving the DCC. Docs: [integrations/README.md](integrations/README.md) |+| DCC tool integrations (Blender, ComfyUI, Modly) | [integrations/](integrations): [integrations/blender/](integrations/blender), [integrations/comfyui/](integrations/comfyui), Modly extensions [integrations/modly/](integrations/modly) (`three-ws/` cloud nodes, `three-ws-publish/` publish node), shared Python client [integrations/_pyclient/](integrations/_pyclient) | In-repo; Modly extensions install by linking the folder, one-click GitHub install is owner-gated ([SUBMITTING.md](integrations/modly/SUBMITTING.md)) | First-party plugins that drive the public Forge pipeline (`/api/forge`, rig, remesh, publish) from inside the tools artists already use, so a model is generated without leaving the DCC. Docs: [integrations/README.md](integrations/README.md), [integrations/modly/README.md](integrations/modly/README.md) || Base58 difficulty model (the honest math) | [src/solana/vanity/base58-distribution.js](src/solana/vanity/base58-distribution.js), dispatch in [src/solana/vanity/validation.js](src/solana/vanity/validation.js); ported copies in [solana-agent-sdk/src/vanity/verify.ts](solana-agent-sdk/src/vanity/verify.ts) and [mcp-server/src/lib/base58-distribution.js](mcp-server/src/lib/base58-distribution.js), held in agreement by [tests/vanity-model-parity.test.js](tests/vanity-model-parity.test.js) | In-repo | The exact probability that a random Solana address matches a vanity pattern, and the single source of truth behind every quote, price, rarity tier, bounty payout and signed receipt. Base58 is a positional encoding of a 256-bit integer, so the *leading* character is not uniform: the 40 symbols `K`-`z` are 17.2x harder to lead with than `5`-`H`, a 58x spread the old flat 58ⁿ model erased. Models are versioned (`base58-exact/v2`, superseding `58^effectiveLength`) and receipts name theirs, so attestations issued before the correction still verify. Spec: [docs/PROTOCOL-vanity.md](docs/PROTOCOL-vanity.md#41-difficulty-model-versioning) || Vanity address grinder (Rust → WASM) | [crates/vanity-grinder/](crates/vanity-grinder) → compiled to [src/solana/vanity/wasm/](src/solana/vanity/wasm); consumed by [src/agent-vanity-grinder.js](src/agent-vanity-grinder.js), [src/agent-eth-vanity-card.js](src/agent-eth-vanity-card.js) | In-repo | The Rust source behind in-browser Solana/EVM vanity-address mining. Compiled to WebAssembly so grinding runs on the visitor's machine, never the server. Surfaced as the `vanity_grinder` MCP tool and the premium pre-ground inventory (`vanity_premium`). || x402 payment modal (drop-in UI) | [x402-payment-modal/](x402-payment-modal) | Published as `@three-ws/x402-payment-modal` | A drop-in payment modal for any x402 paid endpoint — one ES import turns a 402 challenge into a wallet-connect + pay flow. Has a build step, so it sits outside the zero-dependency `packages/*` SDK family. |diff --git a/data/changelog.json b/data/changelog.jsonindex a81d4f8a2..6845d9f9b 100644--- a/data/changelog.json+++ b/data/changelog.json@@ -29342,6 +29342,27 @@"summary": "Photo to 3D in the Forge now starts with TRELLIS.2, an open-source model that makes textured assets with full material detail and keeps transparency for glass and leaves. You can pick a detail level of 512, 1024 or 1536 when you generate. We also made sure that requests from the European Union, the United Kingdom and South Korea never use models whose license does not cover those regions, and that a request with no location signal takes the safe path too. The engine switches on as soon as its GPU worker is deployed, and until then the existing engines keep serving every request.","tags": ["feature", "improvement"],"link": "/forge"+ },+ {+ "date": "2026-10-09",+ "title": "Generate 3D models on your own graphics card in the Forge",+ "summary": "The From photos tab now has a Use your GPU panel. Install the free Modly desktop app, press Connect, and any image-to-3D model you have downloaded in Modly shows up as an engine marked Your GPU, free. Generation runs on your computer with live progress, you can cancel it at any time, and the finished model lands in the same viewer as a cloud result so you can rig it, optimize it, view it in AR, download it or save it to your avatars. Nothing on your computer is contacted until you press Connect.",+ "tags": ["feature"],+ "link": "/forge"+ },+ {+ "date": "2026-10-09",+ "title": "three.ws nodes for the Modly desktop app",+ "summary": "Modly users can now add three.ws to their workflow editor. Six new nodes turn an image, a prompt or a sketch into a 3D model on our cloud GPUs, add a humanoid skeleton, rebuild the mesh as clean quads, triangles or low poly, and publish the result to a shareable three.ws page. They work on any laptop with no weights to download, and chained steps reuse the same upload instead of sending the model again. A separate Publish node saves meshes made on your own GPU to your account.",+ "tags": ["feature"],+ "link": "/modly"+ },+ {+ "date": "2026-10-09",+ "title": "Fix, smooth and slim any model in your browser, then send it straight to your 3D printer",+ "summary": "Every finished model now has mesh tools: repair welds cracks and fixes inside-out faces, smoothing softens blocky surfaces without tearing textures, and decimate cuts the triangle count to a number you choose, with undo and a before and after count. Nothing is uploaded. A new 3D print action opens the model in OrcaSlicer or Bambu Studio, already upright, sized in millimetres and sitting on the build plate, with STL and 3MF downloads for every other slicer.",+ "tags": ["feature"],+ "link": "/forge"}]}diff --git a/data/pages.json b/data/pages.jsonindex 699bce826..d1f45915a 100644--- a/data/pages.json+++ b/data/pages.json@@ -3536,6 +3536,14 @@"changefreq": "monthly","added": "2026-10-09"},+ {+ "path": "/docs/modly",+ "title": "Docs · Modly and three.ws",+ "description": "Every way three.ws works with Modly, the free open-source 3D app: generate on your own GPU from /modly or the Forge, add three.ws cloud nodes and publishing to Modly, the desktop app, and the mesh tools and slicer handoff built from Modly ideas.",+ "priority": 0.6,+ "changefreq": "monthly",+ "added": "2026-10-09"+ },{"path": "/docs/scene-studio","title": "Docs · Scene Studio",diff --git a/docs/modly.md b/docs/modly.mdnew file mode 100644index 000000000..a0f0a9144--- /dev/null+++ b/docs/modly.md@@ -0,0 +1,137 @@+# Modly and three.ws++[Modly](https://github.com/lightningpixel/modly) is a free, open-source desktop+app by [Lightning Pixel](https://github.com/lightningpixel) that turns images+into 3D models on your own graphics card. It is MIT licensed, and three.ws+builds on it in both directions: three.ws can use the Modly running on your+computer, Modly users get three.ws cloud GPUs as Modly nodes, and several+Modly ideas (the workflow builder, mesh cleanup, the slicer handoff) now live+on the platform for everyone.++This page maps every piece and points to its full docs.++## Which one do I want?++| You have | You want | Use |+|---|---|---|+| Modly installed and a decent GPU | to generate on your own hardware from a browser | [/modly](https://three.ws/modly), or the **Use your GPU** panel in [/forge](https://three.ws/forge) |+| Modly installed, but a small GPU or none | cloud generation, rigging and remeshing inside Modly | the [three.ws Cloud extension](#threews-cloud-inside-modly) |+| Modly making models locally | to put them on a shareable three.ws page | the [Publish node](#publish-to-threews) |+| no Modly, just a browser | to chain steps (prompt or photo, generate, remesh, rig) in one run | [/forge/workflows](https://three.ws/forge/workflows) or [/workbench](https://three.ws/workbench) |+| a finished model | to clean it up or 3D print it | [mesh tools and the slicer handoff](./forge.md#mesh-tools-repair-smooth-decimate) |++## Your GPU from three.ws++Modly runs a local server on `http://localhost:8765` that accepts requests from+web pages. three.ws talks to it directly from your browser through one shared+client, [src/modly-local.js](../src/modly-local.js) (`probeModly`,+`detectModly`, `listModlyModels`, `generateWithModly`, `modlyMeshOp`). Nothing+on your computer is contacted until you press **Connect**, because probing+loopback makes Chrome ask for local network access.++**The /modly page** ([/modly](https://three.ws/modly)) is the hub. It detects+Modly and explains every failure it can hit (not running, the browser blocked+local network access, a custom port), lists the models you have downloaded in+Modly, runs image-to-3D on your GPU with Modly's real progress and cancel, and+applies Modly's own mesh tools with undo. Typed prompts go through a three.ws+concept image first, since Modly's local models take images. The result+downloads as a GLB or saves to your account.++**The Forge lane.** In [/forge](https://three.ws/forge), the photos tab has a+**Use your GPU** panel. After Connect, each Modly model you have downloaded+joins the engine picker marked "Your GPU, free". A run shows Modly's percent+and step text in the timeline, Cancel stops Modly's job, and the finished GLB+is copied to three.ws storage so rigging, optimize, AR and embeds work on it+like on any cloud result. It can be saved to your avatars.++Browser notes: Chrome asks once for local network access; if it was denied,+the panel shows where to re-enable it. Safari blocks an `https` page from+calling `http://localhost`, and the panel says so. Modly takes one image per+run, so with several photos the first one is used.++## three.ws Cloud inside Modly++The [three.ws Cloud extension](../integrations/modly/README.md) adds six nodes+to Modly's workflow editor. They run on three.ws GPUs, so they work on any+laptop, need no weights and no setup, and generation needs no account.++| Node | What it does |+|---|---|+| Image to 3D | A photo to a textured GLB on a free hosted lane (Hunyuan3D, TRELLIS) or, with your own key, Meshy, Tripo, Rodin, Stability or Replicate |+| Text to 3D | A prompt to a GLB, through a reference image (free) or native text-to-3D (your key) |+| Sketch to 3D | A line drawing plus a short description to a GLB |+| Auto-Rig | Adds a Mixamo-compatible humanoid skeleton |+| Remesh | Quad, triangle or low-poly retopology with a texture bake, or simplify, or repair |+| Publish | Saves the mesh to your three.ws account and opens its page |++Nodes chain: Image to 3D into Auto-Rig into Remesh uploads nothing after the+first step, because the extension remembers the three.ws URL of every mesh it+has handled. A mesh made by a local Modly model is uploaded once and reused.++Install it with Modly's **Link local folder** (steps in the+[extension README](../integrations/modly/README.md#install)). One-click install+from GitHub and Modly's trusted badge are described in+[SUBMITTING.md](../integrations/modly/SUBMITTING.md).++Every node uses the same Python client as the Blender add-on and the ComfyUI+nodes, [integrations/_pyclient/three_ws_client.py](../integrations/_pyclient/README.md),+which now also covers GLB upload, auto-rig, remesh and publishing.++## Publish to three.ws++[`integrations/modly/three-ws-publish/`](../integrations/modly/three-ws-publish/README.md)+is a standalone Modly process node that saves the mesh from any Modly node to+your account and outputs the page URL. Use it when the rest of your workflow+runs locally; the Cloud extension's Publish node is the same step at the end of+a three.ws chain. Both take an API key with the `avatars:write` scope from+[three.ws/dashboard/api](https://three.ws/dashboard/api).++## three.ws Forge desktop app++[`apps/forge-desktop/`](../apps/forge-desktop/README.md) is Modly's desktop app+in three.ws colors, with a three.ws account built in: sign in from Settings,+publish a result from the Generate screen, and browse your three.ws library+without leaving the app. The Publish node ships inside it, already signed in.+Downloads are on [/forge-desktop](https://three.ws/forge-desktop).++## Ideas from Modly, built into the platform++- **Workflow builder** at [/forge/workflows](https://three.ws/forge/workflows):+ link a prompt or photo to any live engine, then remesh, rig, segment, restyle+ or make it game-ready, in one run, like Modly's workflow editor but on+ three.ws GPUs.+- **Mesh tools** on every finished model in the Forge and on `/m/:id`: repair,+ Taubin or Laplacian smoothing and decimation in a browser worker, with undo.+ See [Forge: mesh tools](./forge.md#mesh-tools-repair-smooth-decimate).+- **Slicer handoff**: **Open in OrcaSlicer** and **Open in Bambu Studio** send a+ print-ready STL or 3MF (upright, in millimetres, on the bed) from+ `/api/slicer/<id>/model.stl`. See+ [Forge: open in a slicer](./forge.md#open-in-a-3d-printing-slicer) and the+ [API reference](./api-reference.md).++## Developers++| Piece | Where | Tests |+|---|---|---|+| Browser client for a local Modly | [src/modly-local.js](../src/modly-local.js) | `npx vitest run tests/modly-local.test.js` |+| /modly page | [pages/modly.html](../pages/modly.html), [src/modly-page.js](../src/modly-page.js) | |+| Forge lane | [src/forge-modly.js](../src/forge-modly.js), wired in [src/forge.js](../src/forge.js) | |+| Cloud extension | [integrations/modly/three-ws/](../integrations/modly/three-ws/) | `python3 -m unittest discover -s integrations/modly/tests -p 'test_*.py'` |+| Publish node | [integrations/modly/three-ws-publish/](../integrations/modly/three-ws-publish/) | see its README |+| Shared Python client | [integrations/_pyclient/](../integrations/_pyclient/) | `python3 -m unittest discover -s integrations/_pyclient -p 'test_*.py'` |+| Desktop app | [apps/forge-desktop/](../apps/forge-desktop/) | see its README |+| Mesh tools | [src/mesh-ops/](../src/mesh-ops/) | `npx vitest run tests/mesh-ops.test.js` |+| Slicer handoff | [api/slicer/model.js](../api/slicer/model.js), [api/_lib/print/slicer.js](../api/_lib/print/slicer.js), [src/slicer-handoff.js](../src/slicer-handoff.js) | `npx vitest run tests/slicer-handoff.test.js` |++## Credit++Modly is MIT licensed, Copyright (c) 2026 Lightning Pixel. Code adapted from it+carries that notice in its header, and the repository [NOTICE](../NOTICE)+lists every such file.++## Related++- [Forge](./forge.md): the cloud generator these surfaces share+- [Workbench](./workbench.md): a desktop-style workspace in the browser+- [integrations/README.md](../integrations/README.md): Blender, ComfyUI and Modly plugins+- [STRUCTURE.md](../STRUCTURE.md): where every surface livesdiff --git a/docs/nav.json b/docs/nav.jsonindex cf96dd8cc..52666fd61 100644--- a/docs/nav.json+++ b/docs/nav.json@@ -173,6 +173,10 @@"label": "Workbench","path": "workbench"},+ {+ "label": "Modly (your own GPU)",+ "path": "modly"+ },{"label": "Scene Studio","path": "scene-studio"diff --git a/docs/start-here.md b/docs/start-here.mdindex 5294d05b8..d1d5eaa14 100644--- a/docs/start-here.md+++ b/docs/start-here.md@@ -66,6 +66,8 @@ Generations don't need a babysitter, either: start a forge job, close the tab, aWant to choose the steps yourself? [Workbench](./workbench.md) runs a photo through a visual workflow you can edit (background removal, generation, remeshing, rigging, material restyle), then lets you smooth, decimate and export GLB, OBJ, STL or PLY from a desktop-style viewport.+Have a graphics card? [Modly and three.ws](./modly.md) covers generating on your own GPU through the free Modly app (from [/modly](https://three.ws/modly) or the Forge's **Use your GPU** panel), plus the three.ws nodes for Modly that bring cloud generation, auto-rigging, remeshing and publishing into Modly itself.+Curious what happens between the prompt and the model? [How the Forge works](./how-forge-works.md) tells the story in plain language; [the Forge pipeline](./forge-pipeline.md) is the full engineering deep dive.Need a functional part rather than a sculpture, such as a bracket, an enclosure, a gear or a knob? [CAD Forge](./cad-forge.md) turns a sentence into real parametric CAD that the OpenCascade kernel has built, with exact dimensions you can drag, STEP and STL downloads, and a drawing sheet.diff --git a/integrations/README.md b/integrations/README.mdindex b79691e50..2ffad5251 100644--- a/integrations/README.md+++ b/integrations/README.md@@ -8,6 +8,7 @@ generated without leaving the DCC.|---|---|---|| Blender extension | [`blender/three_ws/`](blender/three_ws/) | Blender 4.2+ || ComfyUI nodes | [`comfyui/three_ws_nodes/`](comfyui/three_ws_nodes/) | ComfyUI |+| Modly extensions | [`modly/`](modly/) (`three-ws/` cloud nodes, `three-ws-publish/` publish node) | [Modly](https://github.com/lightningpixel/modly) |Driving Blender from an **agent** rather than by hand is a different job, and ithas its own package: [`packages/blender-mcp/`](../packages/blender-mcp) is an MCP@@ -16,12 +17,17 @@ inspect, convert, render, and script 3D files, and pull a Forge generationstraight into a scene. The add-on below is the artist-facing surface; the twoinstall side by side.-Both speak to the same auth-free endpoints:+All of them speak to the same auth-free endpoints:- `POST /api/forge` — text→3D and image→3D- `GET /api/forge?job=<id>` — poll- `GET /api/forge?catalog` — tier/backend matrix- `POST /api/forge-upload` — presigned image upload (image→3D)+- `POST /api/scene-glb-upload`: presigned GLB upload, so a local mesh can be rigged or remeshed+- `POST /api/forge?action=rig` and `POST /api/forge-remesh`: auto-rig and remesh a GLB by URL++Publishing to an account (`POST /api/avatars`) is the one call that needs a+three.ws API key.The **image pipeline** (FLUX→TRELLIS) is free and platform-keyed. The**geometry pipeline** (Meshy/Tripo) is BYOK — supply your own provider key in@@ -41,6 +47,8 @@ edit the canonical file and re-copy:```bashcp integrations/_pyclient/three_ws_client.py integrations/blender/three_ws/three_ws_client.pycp integrations/_pyclient/three_ws_client.py integrations/comfyui/three_ws_nodes/three_ws_client.py+cp integrations/_pyclient/three_ws_client.py integrations/modly/three-ws/three_ws_client.py+cp integrations/_pyclient/three_ws_client.py integrations/modly/three-ws-publish/three_ws_client.py```## Tests@@ -53,6 +61,9 @@ python -m unittest discover -s integrations/_pyclient -p 'test_*.py'# comfyui nodes( cd integrations/comfyui/three_ws_nodes && python -m unittest test_nodes )++# modly extensions (loads generator.py the way Modly does)+python -m unittest discover -s integrations/modly/tests -p 'test_*.py'```The Blender add-on is import-guarded on `bpy` (only present inside Blender); itsdiff --git a/integrations/_pyclient/README.md b/integrations/_pyclient/README.mdindex cd9e44174..9050b582a 100644--- a/integrations/_pyclient/README.md+++ b/integrations/_pyclient/README.md@@ -5,10 +5,11 @@ the public Forge generation contract (`api/forge.js` + `api/forge-upload.js`).It is stdlib-only (`urllib`), so it runs unmodified inside Blender's bundledPython and inside ComfyUI without a `pip install` into either host.-The [Blender add-on](../blender/) and the [ComfyUI nodes](../comfyui/) each-vendor a byte-identical copy of this file. Edit the canonical copy here, then-re-copy it into both plugins; [test_no_drift.py](./test_no_drift.py) fails the-suite if any vendored copy diverges.+The [Blender add-on](../blender/), the [ComfyUI nodes](../comfyui/) and the two+[Modly extensions](../modly/) each vendor a byte-identical copy of this file.+Edit the canonical copy here, then re-copy it into every plugin;+[test_no_drift.py](./test_no_drift.py) fails the suite if any vendored copy+diverges.## Contract wrapped@@ -19,6 +20,10 @@ suite if any vendored copy diverges.| Poll a job | `GET /api/forge?job=<id>` returning `{status, glb_url?, error?, backend?, ...}` || Tier/backend/cost matrix | `GET /api/forge?catalog` || Image upload presign | `POST /api/forge-upload` with `{content_type, size_bytes, checksum_sha256?}` |+| GLB upload presign | `POST /api/scene-glb-upload` with `{content_type, size_bytes}` (200 MB cap) |+| Auto-rig | `POST /api/forge?action=rig` with `{glb_url}`, polled on `GET /api/forge?job=<id>` |+| Remesh | `POST /api/forge-remesh` with `{mesh_url, remesh_mode, operation, target_faces, texture_size, output_format}`, polled on `GET /api/forge-remesh?job=<id>` |+| Publish to an account | `POST /api/avatars/upload` or `/api/avatars/presign`, then `POST /api/avatars`, with a bearer API key carrying `avatars:write` |Generation is auth-free (IP rate-limited, scoped to an anonymous client handlesent as `x-forge-client`). The geometry path (Meshy/Tripo) is BYOK: pass@@ -29,10 +34,16 @@ sent as `x-forge-client`). The geometry path (Meshy/Tripo) is BYOK: pass- `ThreeWSClient(base_url="https://three.ws", *, provider_key=None, client_handle=None, timeout=30.0)`- `generate_text_to_3d(prompt, *, tier, backend, path, aspect_ratio, on_progress, should_cancel, poll_timeout) -> glb_url`- `generate_image_to_3d(image_bytes, content_type, *, prompt, tier, backend, path, ...) -> glb_url`- - Lower-level steps: `submit_text_to_3d(...)`, `submit_image_to_3d(...)`, `upload_image(image_bytes, content_type) -> public_url`, `poll(job_id, ...) -> glb_url`, `download(url, dest_path)`, `get_catalog()`+ - `rig(glb_url, *, on_progress, should_cancel, poll_timeout) -> rigged_glb_url`+ - `remesh(mesh_url, *, remesh_mode, operation, target_faces, texture_size, on_progress, should_cancel, poll_timeout) -> result_url`+ - `upload_glb(glb_bytes) -> public_url`: puts a local GLB where rig and remesh can read it+ - `publish_glb(glb_bytes, *, api_key, name, description, visibility, tags, source_meta) -> avatar`, and `avatar_page_url(avatar)`+ - Lower-level steps: `submit_text_to_3d(...)`, `submit_image_to_3d(...)`, `submit_rig(glb_url)`, `submit_remesh(mesh_url, ...)`, `upload_image(image_bytes, content_type) -> public_url`, `poll(job_id, ...) -> glb_url`, `download(url, dest_path)`, `get_catalog()`+ - Polling retries a 502, 503 or 504 from the poll endpoint instead of failing the job, since a long GPU job outlives the odd gateway hiccup.- `ThreeWSError`: every failure path raises this with a user-safe `message`, a machine `code` (`needs_key`, `unconfigured`, `timeout`, `cancelled`, `failed`, ...), and the HTTP `status` when applicable.- `content_type_for_path(path)`: maps `.png` / `.jpg` / `.jpeg` / `.webp` to the content type Forge accepts, or raises.-- Constants mirroring `api/_lib/forge-tiers.js`: `TIERS`, `PATHS`, `BACKENDS`, `ASPECT_RATIOS`.+- Constants mirroring the server: `TIERS`, `PATHS`, `BACKENDS`, `ASPECT_RATIOS` (from `api/_lib/forge-tiers.js`), and `REMESH_MODES`, `REMESH_OPERATIONS`, `REMESH_TEXTURE_SIZES`, `MAX_SCENE_GLB_BYTES`.+- HTTPS uses `certifi`'s CA bundle when it is importable, which fixes certificate errors in hosts whose bundled Python has no system CA store; otherwise the platform default is used.## Example@@ -61,13 +72,16 @@ python integrations/_pyclient/test_no_drift.py```- [test_three_ws_client.py](./test_three_ws_client.py) runs a real in-process HTTP server that mimics the Forge contract (no live network) and exercises submit, upload, poll, download, and every error path end to end.-- [test_no_drift.py](./test_no_drift.py) byte-compares the vendored copies in `integrations/blender/three_ws/` and `integrations/comfyui/three_ws_nodes/` against this canonical file and prints the exact `cp` command to fix a drift.+- [test_no_drift.py](./test_no_drift.py) byte-compares the vendored copies in `integrations/blender/three_ws/`, `integrations/comfyui/three_ws_nodes/`, `integrations/modly/three-ws/` and `integrations/modly/three-ws-publish/` against this canonical file and prints the exact `cp` command to fix a drift.## Editing workflow1. Change `three_ws_client.py` here.-2. Copy it over both vendored paths:- `cp integrations/_pyclient/three_ws_client.py integrations/blender/three_ws/three_ws_client.py`- and- `cp integrations/_pyclient/three_ws_client.py integrations/comfyui/three_ws_nodes/three_ws_client.py`+2. Copy it over every vendored path:++ ```bash+ for d in blender/three_ws comfyui/three_ws_nodes modly/three-ws modly/three-ws-publish; do+ cp integrations/_pyclient/three_ws_client.py "integrations/$d/three_ws_client.py"+ done+ ```3. Run the tests above.diff --git a/integrations/modly/README.md b/integrations/modly/README.mdnew file mode 100644index 000000000..3d16f3963--- /dev/null+++ b/integrations/modly/README.md@@ -0,0 +1,109 @@+# three.ws for Modly++[Modly](https://github.com/lightningpixel/modly) is a free, open-source desktop+app (MIT, by [Lightning Pixel](https://github.com/lightningpixel)) that turns+images into 3D models on your own graphics card, with a node-based workflow+editor. This folder holds the two Modly extensions three.ws ships:++| Extension | Folder | Type | What it adds to Modly |+|---|---|---|---|+| three.ws Cloud | [`three-ws/`](three-ws/) | model | Six nodes that run on three.ws GPUs: image, text and sketch to 3D, auto-rig, remesh, publish. No GPU, no weights, no setup. |+| Publish to three.ws | [`three-ws-publish/`](three-ws-publish/) | process | One node that saves any mesh, from any generator, to your three.ws account. See its [README](three-ws-publish/README.md). |++The other direction (three.ws using a Modly install) lives outside this folder;+[docs/modly.md](../../docs/modly.md) maps every Modly integration on the+platform.++## three.ws Cloud: the nodes++Every node talks to the public Forge API (`https://three.ws/api/forge` and+friends) through the shared, stdlib-only+[`three_ws_client.py`](../_pyclient/three_ws_client.py). Generation is free and+needs no account.++| Node | Input | Parameters | Output |+|---|---|---|---|+| **three.ws Image to 3D** | image | Engine (Auto, Hunyuan3D, TRELLIS on NVIDIA, TRELLIS self-host, TRELLIS.2, Hugging Face Spaces, or Meshy, Tripo, Rodin, Stability, Replicate with your key), Quality, optional prompt hint, provider key | GLB |+| **three.ws Text to 3D** | text | Route (reference image then 3D, free; or native text-to-3D with your key), Engine, Quality, aspect ratio, provider key | GLB |+| **three.ws Sketch to 3D** | image + text | What the sketch shows (required unless a text node is wired in), Quality | GLB |+| **three.ws Auto-Rig** | mesh | none | GLB with a Mixamo-compatible humanoid skeleton |+| **three.ws Remesh** | mesh | Topology (quads, triangles, low poly), Operation (retopology with texture bake, simplify, repair), target faces, texture size | GLB |+| **three.ws Publish** | mesh | API key, name, visibility, open the page when done | the same mesh, plus a three.ws page |++Behavior worth knowing:++- **Engines are checked against the live catalog.** If the engine you picked is+ not serving right now, the node falls back to the server's default lane and+ says so in the progress line instead of failing.+- **Chains do not re-upload.** Every GLB the extension downloads is remembered+ with its three.ws URL (keyed by the file's SHA-256). Wire Image to 3D into+ Auto-Rig into Remesh and only the first step sends anything; the rest hand+ the existing URL to the next job. A mesh made locally in Modly is uploaded+ once, then reused.+- **Progress is real.** Each node reports the Forge job's status and elapsed+ seconds; Cancel in Modly stops polling and the node ends as cancelled.+- **Outputs land in your Modly workspace** like any other node's, named+ `<time>_<id>_three-ws-<node>.glb`, so Modly's viewer, export and optimize+ tools work on them.++### Install++The extension lives inside the three.ws repository, so link it as a local+folder (Modly's **Install from GitHub** button needs `manifest.json` at a+repository's root; see [SUBMITTING.md](SUBMITTING.md) for that route).++1. Copy the folder somewhere permanent:++ ```bash+ git clone --depth 1 https://github.com/nirholas/three.ws /tmp/three.ws+ cp -r /tmp/three.ws/integrations/modly/three-ws ~/modly-three-ws+ ```++2. In Modly open **Models**, click **Link local folder**, and pick+ `~/modly-three-ws`. Modly links it in place, so keep the folder.+3. The six nodes appear in the workflow editor under **three.ws Cloud**. There+ are no weights to download; the extension reports itself ready.++Instead of linking you can copy the folder into Modly's extensions directory+(`<Modly user data>/extensions/three-ws`) and restart Modly.++### Configuration++All optional. Set them in the environment Modly starts from.++| Variable | Used by | Meaning |+|---|---|---|+| `THREE_WS_PROVIDER_KEY` | Image, Text | Your own Meshy, Tripo, Rodin, Stability or Replicate key, for the engines marked "your key". The node's field wins over the variable. It travels only as the `x-forge-provider-key` header. |+| `THREE_WS_API_KEY` | Publish | A three.ws API key with the `avatars:write` scope, from [three.ws/dashboard/api](https://three.ws/dashboard/api). Prefer this over the node field so the key never ends up in a shared workflow. |+| `THREE_WS_BASE_URL` | all | Point the extension at another three.ws deployment. Default `https://three.ws`. |++The extension keeps one small file next to Modly's models folder,+`three-ws-state.json`: an anonymous client handle (so Forge rate limits and job+ownership stay stable across restarts) and the URL index for chain reuse,+capped at the 500 most recent meshes.++## Tests++No live network: the tests run a real in-process HTTP server that speaks the+Forge contract, and load `generator.py` by file path the way Modly does, against+a copy of Modly's own `BaseGenerator`+([`tests/host/services/generators/base.py`](tests/host/services/generators/base.py)).++```bash+python3 -m unittest discover -s integrations/modly/tests -p 'test_*.py'+```++`three_ws_client.py` in each extension folder is a byte-identical copy of the+canonical client; `integrations/_pyclient/test_no_drift.py` fails if it+drifts. After editing the canonical client:++```bash+cp integrations/_pyclient/three_ws_client.py integrations/modly/three-ws/three_ws_client.py+cp integrations/_pyclient/three_ws_client.py integrations/modly/three-ws-publish/three_ws_client.py+```++## Licenses++The extensions are Apache-2.0 like the rest of three.ws ([`three-ws/LICENSE`](three-ws/LICENSE)).+Modly itself is MIT, Copyright (c) 2026 Lightning Pixel; the test host's+`base.py` is a copy of Modly's and carries that attribution.diff --git a/integrations/modly/SUBMITTING.md b/integrations/modly/SUBMITTING.mdnew file mode 100644index 000000000..eee7e6dcb--- /dev/null+++ b/integrations/modly/SUBMITTING.md@@ -0,0 +1,76 @@+# Shipping the three.ws Cloud extension to Modly users++Today the extension installs by linking a local folder (see [README.md](README.md)).+Two further steps make it a one-click install with Modly's "trusted" badge.+Both publish under the project's name on GitHub, so both are owner-approved+actions; nothing here runs automatically.++## How Modly installs and trusts extensions++Read from Modly's own source (`electron/main/ipc-handlers.ts`):++- **Install from GitHub** takes `https://github.com/<owner>/<repo>`, downloads+ `https://api.github.com/repos/<owner>/<repo>/tarball/HEAD`, and requires+ `manifest.json` (and, for a model extension, `generator.py`) at the root of+ that tarball. A subfolder of a larger repository is not accepted, which is+ why the extension needs a repository of its own.+- On install Modly overwrites the manifest's `source` with the repository URL+ it downloaded from.+- **Trust** is a lookup: Modly fetches+ `https://raw.githubusercontent.com/lightningpixel/modly-official-extension/main/registry.json`+ (cached five minutes), whose shape is+ `{"trusted_repos": ["https://github.com/<owner>/<repo>", ...]}`, and marks an+ extension trusted when its `source` is in that list.++## Step 1: a public repository for the extension (owner-gated)++Split the folder out with its history, so the new repository's root is the+extension:++```bash+git subtree split --prefix=integrations/modly/three-ws -b modly-three-ws-ext+gh repo create nirholas/modly-three-ws --public \+ --description "three.ws Cloud for Modly: image, text and sketch to 3D, auto-rig, remesh and publish on hosted GPUs"+git push https://github.com/nirholas/modly-three-ws.git modly-three-ws-ext:main+git branch -D modly-three-ws-ext+```++Then, in this repository, set `source` in+[`three-ws/manifest.json`](three-ws/manifest.json) to+`https://github.com/nirholas/modly-three-ws` so a linked local copy and a+GitHub install report the same origin.++Check the result from a clean Modly: **Models**, **Install from GitHub**,+paste `https://github.com/nirholas/modly-three-ws`. All six nodes should load+with no download step.++To ship an update later, re-run the split and push; it fast-forwards because+the split is deterministic for the same history.++## Step 2: ask to be listed as trusted (owner-gated)++Open a pull request against+[lightningpixel/modly-official-extension](https://github.com/lightningpixel/modly-official-extension)+adding one line to `registry.json`:++```json+"https://github.com/nirholas/modly-three-ws"+```++Suggested description for the pull request:++> three.ws Cloud adds hosted 3D generation to Modly for users without a large+> GPU: image, text and sketch to 3D, a humanoid auto-rigger, a quad remesher and+> publishing to a shareable page. It is a direct-mode extension (no setup.py,+> no venv, no weights; stdlib-only Python), so installing it runs no install+> scripts. Generation is free and needs no account. Source and tests:+> https://github.com/nirholas/three.ws/tree/main/integrations/modly++Merging that is Lightning Pixel's decision; until then the extension installs+from GitHub without the trusted badge.++## The standalone publish node++[`three-ws-publish/`](three-ws-publish/) can follow the same two steps under+its own repository name (for example `nirholas/modly-three-ws-publish`) with+`--prefix=integrations/modly/three-ws-publish`.