Free, open-source 3D sculpting for Linux, macOS and Windows: dense meshes, remeshing, painting, built-in AI (image/text to 3D), Send to Unreal, game-ready LODs, Gaussian splats and OpenUSD.
SculptForge for studios
SculptForge is built to drop into animation, VFX and game studios that run their own pipelines: native on Linux, scriptable, standards-based, with no licence server and nothing that phones home. This chapter is for pipeline TDs and IT: the VFX Reference Platform builds, Rez deployment, shared brush libraries, environment variables, headless use, licensing and IT deployment (a managed policy, the AI audit log, single sign-on, AI gateways and air-gapped use).
VFX Reference Platform builds
SculptForge tracks the VFX Reference Platform. Every commit is built and tested in the platform's reference environments:
| CY2026 | CY2027 | SculptForge | |
|---|---|---|---|
| Linux compiler | GCC 14.2 | GCC 14.2 | Built and tested with gcc-toolset-14 |
| glibc | 2.28 (EL8) | 2.34 (EL9) | Rocky Linux 8 and 9 builds; CI checks that no newer glibc symbols are used |
| C++ | C++20 | C++20 | C++20 |
| Python | 3.13 | 3.13 | The sculptforge module is built and tested against 3.13 |
| Windows | VS 2022 17.6+ | VS build tools 14.44+ | Visual Studio 2022 |
| macOS minimum | 14.0 | 14.0 | Universal binary with deployment target 11.0 |
| FBX | 2020.x | 2020.x | Writes FBX 7.4 binary, which FBX SDK 2020 reads |
SculptForge doesn't depend on Qt, OpenEXR, Boost, TBB or other platform libraries, so it can't conflict with the versions your other tools load. Its few dependencies (SDL3, Dear ImGui, GLM, ufbx) are linked into the binaries.
Each release includes SculptForge-<version>-linux-<arch>-vfx2026.tar.gz (Rocky 8, glibc 2.28) and
...-vfx2027.tar.gz (Rocky 9, glibc 2.34), for x86_64 and ARM64, with the Python module under
lib/sculptforge/python.
Deploy with Rez
packaging/rez/package.py in the source tree builds and installs a Rez package:
cd packaging/rez
SCULPTFORGE_PYTHON=$(which python3.13) rez-build --install # or --release for your release repository
rez-env sculptforge -- sculptforge # the app
rez-env sculptforge -- sculptforge-cli --list # every pipeline command
rez-env sculptforge python-3.13 -- python -c "import sculptforge"
The package puts bin/ on PATH and the Python module on PYTHONPATH, and sets SCULPTFORGE_ROOT. The
Python module is built for the first python3 found unless SCULPTFORGE_PYTHON names an interpreter.
Studio brush libraries
Each artist's own brushes live in their user brush library, one .sfbrush file per brush (see
Brush Lab and sharing brushes). To give a whole team the same brushes, put .sfbrush files on
a share and list it in SCULPTFORGE_BRUSH_PATH:
export SCULPTFORGE_BRUSH_PATH=/studio/brushes:/show/troll/brushes # ';' between folders on Windows
sculptforge-cli -c 'brush_library' # every brush, where it comes from and its file, plus the folders
- The app,
sculptforge-cliand the Python module load these folders at start-up, read-only: SculptForge never writes into them, so the share can be mounted read-only. - Studio brushes show a
studiotag in the Custom brushes list. - When brushes share a name, the artist's own wins over a studio one, which wins over a built-in. Among studio folders, the first one listed wins.
- Refining a studio brush in Brush Lab saves the artist's own version (tagged
yours) without touching the share. Deleting that version brings the studio brush back. - To publish a brush, copy its
.sfbrushfile into the share: right-click it in the Custom brushes list > Save .sfbrush..., or take it from an artist's user library.
With Rez, set the share once for everyone: when SCULPTFORGE_STUDIO_BRUSHES is set as the package resolves
(in a site package, your rezconfig or the launcher), it is appended to SCULPTFORGE_BRUSH_PATH.
export SCULPTFORGE_STUDIO_BRUSHES=/studio/brushes
rez-env sculptforge -- sculptforge
Environment variables
| Variable | Effect |
|---|---|
SF_AI |
off: every AI feature off and locked (app, sculptforge-cli, MCP, Python); on: on whatever was saved. --no-ai does the same as off for one start |
SF_STUDIO_PROFILE |
A studio profile (studio.json) to start in studio mode with, like --studio (see Your studio build) |
SF_OFFLINE |
1: studio mode with nothing allowed, like --offline |
SF_POLICY |
A policy file, when there is no system-wide one (see The policy file) |
SF_KEYCHAIN |
none: don't use the OS keychain (render nodes, CI); keys last for the session or come from the environment |
SCULPTFORGE_BRUSH_PATH |
Read-only studio brush folders (:-separated, ; on Windows) |
SCULPTFORGE_STUDIO_BRUSHES |
With the Rez package: appended to SCULPTFORGE_BRUSH_PATH |
SCULPTFORGE_BRUSH_GALLERY |
Use another community brush gallery index (a URL or a folder), for example an in-house mirror |
HF_TOKEN (or HUGGING_FACE_HUB_TOKEN) |
Hugging Face token for the free image-to-3D models |
FAL_KEY, MESHY_API_KEY |
Keys for the paid generation services |
ANTHROPIC_API_KEY, OPENAI_API_KEY, OPENROUTER_API_KEY |
Keys for Brush Lab providers |
XDG_DATA_HOME (Linux), APPDATA (Windows) |
Move the settings folder (see where settings live) |
Keys from the environment are used when none is saved in the app (keys saved in the app live in the OS keychain), so a launcher can supply them without storing them for each artist.
Headless and farm use
sculptforge-cliruns every editing operation without a display: imports, remeshing, decimation, LOD chains, FBX, USD and glTF export, splat conversion and AI generation. See Scripting and automation.sculptforge --render out.png --turntable 8renders review images and turntables offscreen. It needs an OpenGL 3.3 context; on a headless Linux node, run it under Xvfb.sculptforge-cli --mcpexposes the same operations to AI agents through the Model Context Protocol.import sculptforgegives Python the same commands plus NumPy arrays of the mesh, for your own tools.
A typical farm job turns incoming scans into game-ready assets:
sculptforge-cli --set in=/ingest/scan_042.ply --set usd=/assets/scan_042.usda --set glb=/assets/scan_042.glb -c '
open path=$in
splat_transform rotate_x=180 fit=true
splat_clean
splat_to_mesh detail=320 preset=game color=texture
export_usd path=$usd
export_lods path=$glb levels=4 ratio=0.5
'
A --set variable replaces a whole value, so pass complete paths (with their extensions) as variables.
Formats in a pipeline
| Format | Read | Write | Notes |
|---|---|---|---|
OpenUSD (.usda, .usdz) |
Yes | Yes | Meshes, xform ops, Z-up stages, UsdSkel blend shapes, ParticleField Gaussian splats, textures; checked with OpenUSD's validators |
| FBX | Yes (any version) | Yes (7.4 binary) | LOD groups, blend shapes, centimetre units, textures; checked with ufbx's strict mode |
| glTF / GLB | Yes | Yes | Morph targets, vertex colours, KHR_gaussian_splatting, embedded textures; checked with the Khronos validator |
| OBJ | Yes | Yes | Objects as Parts, groups as face groups, vertex colours, textures through .mtl |
| PLY | Yes | Yes | Meshes with vertex colours, Gaussian splats |
| STL | Yes (binary and ASCII) | Yes (binary) | |
| Bridge | Yes | Yes | Face Groups, mask, vertex paint, UVs |
SculptForge project (.sfproj) |
Yes | Yes | Everything; a documented ZIP of JSON and binary arrays |
Binary .usdc files and USD references or payloads aren't read yet; convert with usdcat in.usd -o out.usda.
The project format is described in docs/project-format.md in the source tree, so pipeline tools can read it
without SculptForge.
Licensing
SculptForge is free software under the GNU General Public License, version 3 or later. In practice:
- Using it is unrestricted, commercially or otherwise, on any number of machines. There are no seats, licence servers or accounts.
- Your artwork belongs to you. The GPL covers the program, not the models you make with it.
- You can modify it in-house. The GPL only requires you to share source if you distribute the modified program outside your organisation. Internal use, including across your own facilities and farm, is generally not considered distribution. (This is the common reading of the GPL, not legal advice; check with your counsel.)
- SculptForge has no telemetry and no servers of its own. AI features are optional and talk only to the service each artist chooses, or to your own ComfyUI server.
Studio membership
SculptForge is free for any number of artists, and nothing in the app is ever paywalled. A Studio membership is a flat $300 a month for the whole studio, any number of artists. The first 10 studios become Founding Studios at a flat $150 a month, locked for as long as they stay subscribed. Each artist gets everything in Member, and the studio gets:
- Its own build with its brushes, alphas, Lit Spheres, keymaps, macros, preferences, paths and logo built in.
- Isolation: a private release channel, and no outside connections by default (see Offline deployment).
- A pinned version: you choose when to move. Security fixes are backported to the current release and one long-term support (LTS) line, and your studio is always on one of those two.
- An offline signed installer with checksums for IT.
- Support: a first response within 2 business days (a response, not a fix), up to 3 custom items a month (bigger features are quoted separately), your requests first on the roadmap, and a private Discord channel.
Every release stays free for everyone; bug-fix and security releases go out to everyone the same day. Join at sculptforge.app/studios.html or ask on the SculptForge Discord.
What stays private, and what doesn't. SculptForge is GPL-3.0, and so is your studio build: its source comes with it and is yours to share. There are no exclusive or secret features. What stays private is yours: the brushes, alphas, settings and files you send are never put in public builds or packs, and your build never reaches out of your network.
Your studio build
Your build is SculptForge with a studio profile baked in: one studio.json and a folder beside it.
{
"format": "sculptforge-studio", "version": 1,
"id": "acme", "name": "Acme Animation",
"updates": {"feed": "https://sw.acme.internal/sculptforge/latest.json", "mirror": "/mnt/sw/sculptforge/latest.json"},
"allow": [],
"localNetwork": false,
"ai": false,
"packs": ["packs/acme.sfpack"],
"brushPaths": ["/studio/brushes"],
"preferences": "ui.json",
"branding": {"logo": "logo.png", "title": "Acme"}
}
| Key | What it does |
|---|---|
updates.feed, updates.mirror |
Where the build looks for updates: your private channel, then your mirror (a URL or a file on a share) |
allow |
More URLs the build may reach, such as your own ComfyUI server (empty by default) |
localNetwork |
true lets the Unreal link and phone capture use your studio network |
ai |
true keeps the AI features; they can still reach only the URLs above |
packs |
Your brushes, alphas, Lit Spheres, keymaps and macros as .sfpack files, installed at first start |
brushPaths |
Read-only brush shares, as SCULPTFORGE_BRUSH_PATH |
preferences |
The first-start interface settings: layout, shortcuts and UI scale (Edit > Preferences > Interface exports them) |
branding |
Your logo in Help > About and a word in the title bar |
Paths are relative to the profile's folder, and the profile is data only: nothing in it runs. An unknown key is an error, so a typo never quietly drops a setting.
To request your build, send in one email or a message in your team channel:
- What to bake in: your exported keymap and layout, brush presets and packs (
.sfbrush,.sfpack), and the pipeline defaults you want. - References for custom content: images or scans you own, with a line on what each item should do.
- Where it runs: platforms and, for Linux, the distribution or VFX Reference Platform year.
- Where updates come from: your channel or mirror URL, or a folder on a share.
- Who gets access: the GitHub usernames for your private release channel.
Files are treated as data only: scripts and executables you send are never run. Your build is made by the same pipeline and tests as public builds and published in your private channel, signed, with its checksums and source.
To try a profile on a public build first, start it with sculptforge --studio /path/to/studio.json (or set
SF_STUDIO_PROFILE); sculptforge-cli and the Python module take the same profile.
Offline deployment
A studio build is in studio mode, whatever happens to its files:
- No outside connections. No update check against the public website, no AI services, no community brush
gallery, no Discord presence; SculptForge has no telemetry. Every request goes through one gate that allows only
your update channel, your mirror and your
allowlist, refuses everything else before it is sent, and never follows a redirect. Network sockets open only on this computer (loopback) unlesslocalNetworkistrue. - Fails closed. If the profile is missing or broken, a studio build still starts offline, with nothing allowed.
- Updates on your schedule. The build reads its feed only from your channel or mirror. Copy a new release's
latest.jsonto the mirror when you're ready to move; until then nobody is offered it.
To install on machines without internet access:
- Download the release from your private channel: the installer or archive for each platform,
SHA256SUMS.txtandSHA256SUMS.txt.sig. - Check the files:
sha256sum -c SHA256SUMS.txt --ignore-missing(Windows:Get-FileHash <file> -Algorithm SHA256), and the signature with the public key we send you:openssl pkeyutl -verify -pubin -inkey sculptforge-release.pem -rawin -in SHA256SUMS.txt -sigfile SHA256SUMS.txt.sig. - Deploy as usual: the Windows installer or portable zip, the
.rpm/.deb, the tar.gz or the Rez package. - To test studio mode on any machine,
sculptforge --offlineturns it on with nothing allowed;SF_OFFLINE=1does the same for the CLI and Python.
IT deployment
Everything an IT team needs to roll SculptForge out under its own rules: a policy file that locks settings, an audit log of what AI did, the studio's own AI gateway and single sign-on, and offline use. Nothing here needs a studio build; it works on the public one. For a security review, see the security overview.
The policy file
Put a policy.json where only administrators can write it:
| OS | Path |
|---|---|
| Linux | /etc/sculptforge/policy.json |
| macOS | /Library/Application Support/SculptForge/policy.json |
| Windows | C:\ProgramData\SculptForge\policy.json (deploy it with Group Policy, Intune, SCCM or your usual tool) |
SculptForge reads it at every start (the app, sculptforge-cli, MCP and the Python module). Each setting it locks
is greyed out in Edit > Preferences with Managed by your studio next to it. Without a system file,
SF_POLICY=/path/policy.json names one, for testing a policy or setting it from a launcher or a Rez package; while
the system file exists, SF_POLICY is ignored, so an artist can't loosen it.
{
"format": "sculptforge-policy", "version": 1,
"organization": "Acme Animation",
"ai": {"enabled": true, "providers": ["litellm", "comfyui"],
"endpoints": ["https://llm.acme.internal/", "http://comfy.acme.internal:8188/"], "requireSignIn": true},
"network": {"enabled": false, "allow": ["https://sw.acme.internal/"], "localNetwork": false},
"mcp": {"enabled": true, "live": "never", "categories": ["info", "edit", "files"]},
"maya": {"link": "never"},
"audit": {"path": "//fs01/audit/sculptforge/{user}@{host}.jsonl", "maxMB": 20, "keep": 10, "required": true},
"signIn": {"issuer": "https://acme.okta.com/oauth2/default", "clientId": "0oa1example",
"useFor": ["https://llm.acme.internal/"]},
"telemetry": "none",
"updates": {"check": true, "channel": "stable", "feed": "https://sw.acme.internal/sculptforge/latest.json"}
}
Every key is optional: what the policy leaves out stays the artist's choice. An unknown key or a wrong value is an
error, so a typo never quietly drops a lock, and a broken or unreadable policy fails closed: AI, network
features and AI tools stay off until it is fixed. sculptforge-cli --policy shows what the policy manages (exit
code 2 when it is broken); use it to check a file before you deploy it.
| Key | What it does |
|---|---|
organization |
Shown as "Managed by Acme Animation" |
ai.enabled |
false: every AI feature off and locked (as SF_AI=off). true: on and locked. Left out: the artist's choice |
ai.providers |
The only AI providers artists can pick: free, anthropic, openai, ollama, lmstudio, vllm, llamacpp, litellm, openrouter, openai-compatible (Brush Lab) and huggingface, fal, meshy, comfyui, command (Generate 3D) |
ai.endpoints |
The only addresses AI requests may go to (URL prefixes, matched at a /) |
ai.requireSignIn |
AI works only while the artist is signed in with the studio account (needs signIn) |
network.enabled |
false: studio mode (see Offline deployment): no outside connection except network.allow, ai.endpoints, the identity provider and your update feed |
network.allow |
More URL prefixes that stay reachable while the network is off |
network.localNetwork |
true: the Unreal link and phone capture may use the studio network while the network is off |
mcp.enabled |
false: no AI tool can connect (sculptforge-cli --mcp refuses to start, and Help > Connect an AI tool is gone) |
mcp.live |
"never": AI tools work only on their own scene and can never control an open SculptForge window (the window never listens for them; Let AI tools control this window is locked off) |
maya.link |
"never": the Maya Live link can't be turned on (the window never listens for Maya; the folder bridge still works) |
mcp.categories |
The kinds of command AI tools may use: info (read the scene), edit (change it in memory), files (open, save, export, bridges), scripts (macros), network (brush gallery, Unreal), ai (AI generation). Left out: all |
audit.path, audit.maxMB, audit.keep |
Where the audit log goes, when it rotates (10 MB) and how many old files it keeps (5) |
audit.required |
true: an AI action whose audit line can't be written (the share is down) is refused |
signIn.issuer, signIn.clientId |
Your identity provider and the app registration (see Single sign-on) |
signIn.clientSecret |
Only for providers that issue one to installed apps and require it (Google); it isn't secret there, and artists can read the policy |
signIn.scopes, signIn.audience |
Scopes to ask for (default openid profile email offline_access); an audience, if your provider needs one (Auth0) |
signIn.useFor |
Addresses that get the sign-in as a bearer token (default: ai.endpoints) |
telemetry |
Only "none": SculptForge has no telemetry. The key is there so your checklist can state it |
updates.check |
false: no update check, and the artist can't turn it on |
updates.channel |
"stable" or "preview", locked |
updates.feed, updates.mirror |
Your own update feed (a URL) and mirror (a URL or a file on a share) instead of the public one |
The policy works alongside a studio profile: a profile bakes in content and branding, the policy locks settings. When both turn the network off, both allow lists apply.
Audit log
Every AI action is one line of JSON in a local file: each command an AI tool (MCP) runs, refused ones included ("tool": "mcp", or "mcp-live" when it controls an open window), and every Brush Lab and Generate 3D request ("ai"), from
the app, sculptforge-cli and Python.
{"time":"2026-11-05T14:03:22.120Z","user":"ana","host":"ws042","client":"mcp:claude-code 2.1.0","tool":"mcp",
"command":"export_glb","args":{"path":"/show/troll/assets/rock.glb"},"result":"ok","message":"Exported","ms":930}
- What is never written: artwork (meshes, images, textures), keys and tokens (any argument named like a key,
token, password or secret is
<redacted>), and long text (strings are cut to 120 characters; a long prompt is recorded as its length). File paths are kept: they say what was read or written. - Where:
audit.pathfrom the policy, with{user},{host}and{date}filled in, so each machine can write its own file on a share. Without a policy,audit/ai-audit.jsonlin the settings folder. Edit > Preferences > AI shows the path;sculptforge-cli --audit-logprints it. - Rotation: past
audit.maxMBthe file becomes.1,.1becomes.2, and so on up toaudit.keep. - Nothing is sent anywhere: collect the files with your own tools (any log shipper reads JSON lines).
AI providers
Edit > Preferences > AI > Provider has presets that fill in the address and a model, so artists pick a name instead of typing URLs:
| Preset | Address | Key |
|---|---|---|
| Anthropic (Claude) | https://api.anthropic.com/v1/messages |
The artist's or the studio's API key |
| OpenAI | https://api.openai.com/v1/chat/completions |
API key |
| Ollama | http://localhost:11434/v1/chat/completions |
None |
| LM Studio | http://localhost:1234/v1/chat/completions |
None |
| vLLM server | http://localhost:8000/v1/chat/completions (or your GPU server) |
Optional |
| llama.cpp server | http://localhost:8080/v1/chat/completions (or your server) |
None |
| LiteLLM proxy (studio gateway) | http://localhost:4000/v1/chat/completions (change it to your gateway) |
A virtual key, or the studio sign-in |
| OpenRouter | https://openrouter.ai/api/v1/chat/completions |
API key |
Amazon Bedrock, Google Vertex AI and Azure OpenAI go through a LiteLLM proxy your studio runs: the proxy holds the cloud credentials, applies your budgets and model list, and SculptForge talks only to it. A minimal proxy configuration:
model_list:
- model_name: claude
litellm_params: {model: "bedrock/<Bedrock model id>", aws_region_name: us-west-2}
- model_name: gemini
litellm_params: {model: "vertex_ai/<Vertex model id>", vertex_project: acme-render, vertex_location: us-central1}
- model_name: gpt
litellm_params: {model: "azure/<your deployment>", api_base: "https://acme.openai.azure.com", api_version: "<API version>"}
Point the preset at https://llm.acme.internal/v1/chat/completions, list that prefix in ai.endpoints, allow only
litellm in ai.providers, and artists can reach no other AI service. To validate the studio sign-in at the
gateway, use LiteLLM's JWT authentication with your identity provider's keys.
Keys are kept in the operating system's keychain: macOS Keychain, Windows Credential Manager, or the Secret
Service on Linux (GNOME Keyring, KWallet, KeePassXC). They are never written to a settings file; keys from older
versions move into the keychain at the first start. Where there is no keychain (SF_KEYCHAIN=none, a render node),
a key typed in lasts until SculptForge quits; the environment variables ANTHROPIC_API_KEY, OPENAI_API_KEY,
OPENROUTER_API_KEY, HF_TOKEN, FAL_KEY and MESHY_API_KEY work everywhere.
Single sign-on
With signIn in the policy, Edit > Preferences > AI > Studio sign-in signs the artist in with the studio
account (Okta, Microsoft Entra ID, Google Workspace, Auth0, Keycloak or any OpenID Connect provider). It uses the
device authorization grant only: SculptForge shows a short code and opens your provider's page, and the artist
signs in there, in their browser, with your usual login and MFA. Nothing on the artist's computer listens for the
answer: no local port, no redirect, no embedded browser. sculptforge-cli --sign-in does the same in a terminal.
The tokens are kept in the keychain and refreshed when they expire. The access token is sent as
Authorization: Bearer only to the addresses in signIn.useFor (default: ai.endpoints), such as your AI gateway;
never to anyone else. SculptForge reads the ID token's name and email only to show who is signed in: your
services verify the access token.
To set it up, register a public client (no client secret) with the device flow turned on:
| Provider | Where | Issuer |
|---|---|---|
| Okta | Applications > Create App Integration > OIDC > Native Application; Grant type: Device Authorization | https://<org>.okta.com/oauth2/default |
| Microsoft Entra ID | App registrations > New registration; Authentication > Allow public client flows: Yes | https://login.microsoftonline.com/<tenant id>/v2.0 |
| Google Workspace | Google Cloud console > Credentials > OAuth client ID > TVs and Limited Input devices | https://accounts.google.com (list https://oauth2.googleapis.com/ in network.allow when the network is off) |
| Auth0 | Applications > Native; Advanced settings > Grant types: Device Code | https://<tenant>.auth0.com/ (set signIn.audience to your API) |
| Keycloak | Clients > Create; Client authentication: Off; OAuth 2.0 Device Authorization Grant: On | https://<host>/realms/<realm> |
Put the client id in signIn.clientId. Google's device flow also wants the client's secret, which Google documents
as not confidential for this client type: put it in signIn.clientSecret. Google's access tokens are meant for
Google's own APIs, so with Google Workspace have your gateway validate the ID token instead.
Offline and air-gapped use
"network": {"enabled": false}in the policy, orsculptforge --offline/SF_OFFLINE=1, turns on studio mode: every request goes through one gate that refuses anything not allowed before it is sent, follows no redirect, and sockets open only on loopback (see Offline deployment).- AI can stay on in an air-gapped facility with local models: allow
ollama,lmstudio,vllm,llamacpporcomfyuiand list their addresses inai.endpoints. - Updates come from
updates.feed/updates.mirroronly; copy a release'slatest.jsonthere when you are ready. - Install from the signed checksums as described under Offline deployment.
Not yet
Planned pipeline features, roughly in order: OpenColorIO viewport display, Alembic export, fuller USD
authoring (layers, variants, references, .usdc), UVs and texture baking, multiresolution sculpting. Pipeline
requests are welcome as issues on the project's GitHub page.
See also
- Scripting and automation
- Exporting, Unreal and Bridge
- Brush Lab and sharing brushes
- Image and text to 3D: running models on your own ComfyUI server
- Troubleshooting
- Security overview for IT reviews