Agentic infrastructure for physical fabrication via 3D printing.

Ask your agent to print something. It just does it — start to finish.
Watch the demo →

Kiln lets AI agents design, queue, and execute physical manufacturing jobs on real 3D printers with zero human intervention. It exposes printer control through both a CLI and the Model Context Protocol (MCP), making any MCP-compatible agent (OpenClaw, Claude, GPT, custom) a first-class operator of your print farm.

All three modes use the same MCP tools and CLI commands. An agent can seamlessly fall back from a busy local printer to a fulfillment center or connected external provider integration — all in one workflow.

• One control plane, any printer — OctoPrint, Moonraker, Bambu Lab, Prusa Link, Elegoo, Serial. Manage a mixed fleet from one place.
• AI-native — 702 MCP tools built for AI agents. Not a web UI with an API bolted on.
• Describe it, print it — Natural-language to physical object pipeline: text or sketch → AI generation → validation → slice → print. Patent pending.
• Decorate anything — QR codes, photos, logos, text, SVGs, and procedural textures (tiger stripe, marble, camo, wood grain, honeycomb) embossed or debossed onto any model with one command. Patent pending.
• Resume, don't restart — Cancelled or failed print? Resume from the exact layer it stopped on any supported FDM printer. No filament wasted. Patent pending (Pro).
• Modify mid-print — Add decorations, append features, or swap materials on a live print with atomic revert if anything goes wrong. Patent pending (Pro).
• Smart material routing — 25 materials, 45 brand-specific filament profiles (Bambu, Prusament, Polymaker, and more) across 11 material families. Intent-based recommendations with printer capability awareness.
• Prints don't fail silently — Cross-printer learning, automatic failure recovery, closed-loop AI generation feedback (failed prints auto-improve future generations), preflight safety checks on every job.
• Search → Slice → Print — Search and download 3D models from MyMiniFactory and Cults3D (search only), auto-slice with PrusaSlicer or OrcaSlicer, print — all from one agent conversation.
• Safety at scale — 29 per-printer safety profiles, G-code validation, heater watchdog, tamper-proof audit logs. Enterprise adds encrypted G-code at rest with key rotation, lockable profiles, RBAC, SSO, fleet site grouping, per-project cost tracking, and PostgreSQL HA.

graph TD
    A["🤖 AI Agent<br/><sub>Claude · GPT · Custom</sub>"]
    A -->|"CLI or MCP"| B["⚙️ Kiln<br/><sub>CLI + MCP Server</sub>"]

    B --> C["🖨️ Your Printers"]
    B --> F["🏭 Fulfillment"]
    B --> N["🌐 External Integrations<br/><sub>(third-party providers/networks, as available)</sub>"]
    B --> D["🛒 Marketplaces"]

    C --> E1["OctoPrint"]
    C --> E2["Moonraker"]
    C --> E3["Bambu"]
    C --> E4["Prusa Link"]
    C --> E5["Elegoo"]

    F --> F1["Craftcloud"]

    N --> N1["Third-Party Network Providers"]

    D --> I["MyMiniFactory"]
    D --> J["Cults3D"]
    D --> H["Thingiverse (deprecated)"]

    style A fill:#1a1a2e,stroke:#e94560,color:#fff
    style B fill:#16213e,stroke:#0f3460,color:#fff
    style C fill:#0f3460,stroke:#e94560,color:#fff
    style F fill:#0f3460,stroke:#27ae60,color:#fff
    style N fill:#0f3460,stroke:#f39c12,color:#fff
    style D fill:#0f3460,stroke:#533483,color:#fff
    style E1 fill:#2d2d44,stroke:#e94560,color:#fff
    style E2 fill:#2d2d44,stroke:#e94560,color:#fff
    style E3 fill:#2d2d44,stroke:#e94560,color:#fff
    style E4 fill:#2d2d44,stroke:#e94560,color:#fff
    style F1 fill:#2d2d44,stroke:#27ae60,color:#fff
    style F2 fill:#2d2d44,stroke:#27ae60,color:#fff
    style N1 fill:#2d2d44,stroke:#f39c12,color:#fff
    style H fill:#2d2d44,stroke:#533483,color:#fff
    style I fill:#2d2d44,stroke:#533483,color:#fff
    style J fill:#2d2d44,stroke:#533483,color:#fff

Kiln connects AI agents to OctoPrint, Moonraker (Klipper), Bambu Lab, Prusa Link, and Elegoo printers. Agents can also outsource jobs through Craftcloud fulfillment, and search models on MyMiniFactory, Cults3D (search only), and Thingiverse.

This monorepo contains two packages:

Before installing Kiln, you need your printer's LAN details (Ethernet or Wi-Fi):

Kiln only needs IP reachability on your local LAN. Ethernet-only printers are fully supported. Direct USB printers just need a USB cable — no network at all.

Optional: Install PrusaSlicer or OrcaSlicer to slice STL files directly from Kiln (brew install --cask prusaslicer on macOS).

Optional: Install OpenSCAD for AI model generation via Gemini Deep Think (brew install openscad on macOS). Gemini Deep Think can generate 3D-printable models from text descriptions — OpenSCAD compiles the generated geometry to STL. Set KILN_GEMINI_API_KEY to enable.

pip install kiln3d

# Discover printers on your network (mDNS + HTTP probe)
kiln discover

# Add your printer (pick your type from the Prerequisites table)
kiln auth --name my-printer --host http://octopi.local --type octoprint --api-key YOUR_KEY
# Other printer types:
# kiln auth --name prusa --host http://192.168.1.100 --type prusaconnect --api-key YOUR_KEY
# kiln auth --name klipper --host http://192.168.1.100:7125 --type moonraker
# kiln auth --name bambu --host 192.168.1.100 --type bambu --access-code LAN_CODE --serial SERIAL
# If discovery misses your printer (common on WSL/VLANs), connect directly by IP with kiln auth.

# Check printer status
kiln status

# Upload and print a file
kiln upload model.gcode
kiln print model.gcode

# Slice an STL and print in one step
kiln slice model.stl --print-after

# Batch print multiple files
kiln print *.gcode --queue

# Monitor a running print
kiln wait

# Take a webcam snapshot
kiln snapshot --save photo.jpg

# View print history
kiln history --status completed

# All commands support --json for agent consumption
kiln status --json

Kiln works the same over Ethernet and Wi-Fi because it talks to printer APIs over LAN IP.

# 1. Connect printer and host to the same router/switch
# 2. Find printer IP from the printer UI or your router DHCP client list
# 3. Verify the printer endpoint responds:
curl http://<printer-ip>/api/version                    # OctoPrint
curl http://<printer-ip>:7125/server/info               # Moonraker
curl -H "X-Api-Key: YOUR_KEY" http://<printer-ip>/api/v1/status   # Prusa Link

# 4. Register directly by IP (no discovery required)
kiln auth --name my-printer --host http://<printer-ip> --type prusaconnect --api-key YOUR_KEY

Kiln runs natively on Linux and Ubuntu under WSL 2.

pipx installs Kiln into its own isolated environment and puts the kiln command on your PATH — works from any directory, no virtualenv to manage.

Note: The pip package name is kiln3d (not kiln). This matters for pipx uninstall, pip show, etc. The CLI command is still kiln.

# One-time: install pipx
sudo apt install pipx
pipx ensurepath   # adds ~/.local/bin to PATH (restart your shell after)

# Clone and install
git clone https://github.com/codeofaxel/Kiln.git
cd Kiln
pipx install ./kiln

# System dependencies (optional but recommended)
sudo apt install prusa-slicer   # Required for slicing STL → G-code
sudo apt install openscad        # Required only for text-to-3D generation

# Verify
kiln verify

# Uninstall (package name is kiln3d, not kiln)
pipx uninstall kiln3d

# Update to latest version (if installed from a git clone)
cd Kiln
git pull
pipx install --force ./kiln

# Check what pipx has installed (useful for troubleshooting)
pipx list

If you prefer a manual virtualenv:

python3 -m venv ~/.kiln-venv
source ~/.kiln-venv/bin/activate

git clone https://github.com/codeofaxel/Kiln.git
cd Kiln
pip install -e ./kiln            # includes all printer backends (OctoPrint, Moonraker, Bambu, Elegoo, Prusa Link)

kiln verify

Tip: Add source ~/.kiln-venv/bin/activate to your ~/.bashrc so the kiln command is always available when you open a terminal.

WSL 2 networking note: WSL 2 uses a virtual network (NAT), so mDNS printer discovery (kiln discover) will not find printers on your home network. Instead, connect directly by IP (same flow for Ethernet-only printers):

# 1. Find your printer's IP (check your router or the printer's LCD/web UI)
# 2. Verify connectivity from WSL
curl http://192.168.1.100:7125/server/info                              # Moonraker (Klipper)
curl http://192.168.1.100/api/version                                   # OctoPrint
curl -H "X-Api-Key: YOUR_KEY" http://192.168.1.100/api/v1/status       # Prusa Link
# Bambu printers use MQTT — just ensure port 8883 is reachable:
# nc -zv 192.168.1.100 8883

# 3. Register the printer with Kiln (pick your type)
kiln auth --name my-printer --host http://192.168.1.100:7125 --type moonraker
# kiln auth --name prusa --host http://192.168.1.100 --type prusaconnect --api-key YOUR_KEY
# kiln auth --name bambu --host 192.168.1.100 --type bambu --access-code LAN_CODE --serial SERIAL

# 4. Check printer status
kiln status

If PrusaSlicer is not in your PATH, set it explicitly:

export KILN_SLICER_PATH=/path/to/prusa-slicer

Bambu TLS security defaults: Kiln now uses certificate pinning (pin mode) for Bambu by default. On first successful connection, the printer certificate fingerprint is pinned (TOFU) in ~/.kiln/bambu_tls_pins.json. Advanced overrides:

# Strict CA/hostname validation (usually fails on stock self-signed printers)
export KILN_BAMBU_TLS_MODE=ca

# Legacy behavior (no certificate validation) - use only on trusted LANs
export KILN_BAMBU_TLS_MODE=insecure

# Optional explicit pin (SHA-256 fingerprint, hex with or without colons)
export KILN_BAMBU_TLS_FINGERPRINT=0123abcd...

Bambu webcam snapshots require ffmpeg for RTSP frame capture. Install it if you want vision monitoring on Bambu printers:

# macOS
brew install ffmpeg

# Ubuntu/Debian
sudo apt install ffmpeg

Without ffmpeg, Bambu printers will work normally but can_snapshot will be False and vision monitoring tools won't capture frames.

kiln discover                              # Scan LAN for printers (mDNS + HTTP probe)
kiln auth --name N --host H --type T       # Save printer credentials
kiln doctor-prusa [--json]                 # Prusa Link diagnostics (endpoints + storage roots)
kiln status [--json]                       # Printer state + job progress
kiln files [--json]                        # List files on printer
kiln upload <file> [--json]                # Upload G-code file
kiln print <files>... [--queue] [--json]   # Start printing (supports batch + queue)
kiln cancel [--json]                       # Cancel current print
kiln pause [--json]                        # Pause current print
kiln resume [--json]                       # Resume paused print
kiln emergency-stop [--printer N|--all]    # Trip emergency stop latch (single printer or fleet)
kiln emergency-status [--printer N|--all]  # Inspect emergency latch/interlock state
kiln emergency-clear --ack-note "..."      # Acknowledge and clear emergency latch
kiln temp [--tool N] [--bed N] [--json]    # Get/set temperatures
kiln gcode <cmds>... [--json]              # Send raw G-code
kiln printers [--json]                     # List saved printers
kiln use <name>                            # Switch active printer
kiln remove <name>                         # Remove a saved printer
kiln preflight [--material MAT] [--json]   # Pre-print safety checks
kiln slice <file> [--print-after] [--json] # Slice STL/3MF to G-code (material-aware temps + smart supports)
kiln snapshot [--save PATH] [--json]       # Capture webcam snapshot
kiln wait [--timeout N] [--json]           # Wait for print to finish
kiln history [--status S] [--json]         # View past prints
kiln order materials [--json]              # List fulfillment materials
kiln order quote <file> -m MAT [--json]   # Get manufacturing quote
kiln order place <quote_id> [--json]      # Place a fulfillment order
kiln order status <order_id> [--json]     # Track order status
kiln order cancel <order_id> [--json]     # Cancel an order
kiln cost <file> [--material PLA] [--json]    # Estimate print cost
kiln material set|show|spools|add-spool       # Material tracking
kiln level [--status] [--trigger] [--json]    # Bed leveling triggers
kiln stream [--port 8081] [--stop] [--json]   # Webcam MJPEG proxy
kiln sync status|now|configure                # Cloud sync
kiln local-first [--apply] [--write-env]     # Local-first profile for edge/AGX deployments (backs up cloud sync config before disabling)
kiln ingest watch --dir ~/incoming [--auto-queue] [--once] [--state-file ~/.kiln/ingest_service/watch_state.json] [--min-stable-seconds N]
kiln ingest service install --dir ~/incoming [--auto-queue]  # Install opt-in background watcher config (detect-only by default)
kiln ingest service start|stop|status                           # Run and manage watcher as a background service
kiln plugins list|info                        # Plugin management
kiln generate "a phone stand" --provider meshy --json   # Generate 3D model from text (meshy/tripo3d/stability/gemini/openscad)
kiln generate-and-print "a phone stand" --provider gemini --material PLA   # One-command generate -> preview -> slice -> upload
kiln generate-status <job_id> --json                    # Check generation status
kiln generate-download <job_id> -o ./models --json      # Download generated model
kiln firmware status --json                # Check for firmware updates
kiln firmware update [--component klipper] # Apply firmware updates
kiln firmware rollback <component>         # Roll back firmware
kiln fleet route --material PLA [--file model.gcode] --json   # Mixed-fleet printer recommendation
kiln partner connect --name N --location L # Connect provider account/listing (integration preview)
kiln partner find --material PLA           # Find provider capacity by material/location
kiln partner submit URL --material PLA     # Submit job through a connected provider integration
kiln partner status <job_id>               # Check provider-managed job status
kiln partner list                          # List connected provider capacity listings
kiln partner sync <id> --available         # Sync provider capacity availability
# Legacy alias (deprecated in v0.2.0, removal target v0.4.0):
# kiln network register|find|submit|status|list|update
kiln setup                                 # Interactive printer setup wizard
kiln serve                                 # Start MCP server
kiln rest [--port 8420] [--tier full] [--auth-token TOKEN]  # Start REST API server
kiln agent [--model openai/gpt-4o]         # Interactive agent REPL (any LLM)

The REST API can be deployed to Fly.io for production use — see deploy.sh for one-command deployment.

Global option: --printer <name> to target a specific printer per-command.

# Start the MCP server (uses printer from ~/.kiln/config.yaml)
kiln serve

# Or override with environment variables
export KILN_PRINTER_HOST=http://192.168.1.100    # Your printer's IP or hostname
export KILN_PRINTER_API_KEY=your_api_key          # API key (OctoPrint/Moonraker/Prusa Link)
export KILN_PRINTER_TYPE=prusaconnect             # octoprint | moonraker | bambu | prusaconnect
kiln serve

Add to your project's .claude/settings.json (or global ~/.claude/settings.json):

{
  "mcpServers": {
    "kiln": {
      "command": "kiln",
      "args": ["serve"]
    }
  }
}

Note: Claude Code uses your ~/.kiln/config.yaml for printer credentials (set up via kiln setup or kiln auth). No env vars needed if you've already configured a printer.

Add to ~/.config/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "kiln": {
      "command": "python",
      "args": ["-m", "kiln", "serve"],
      "env": {
        "KILN_PRINTER_HOST": "http://192.168.1.100",
        "KILN_PRINTER_API_KEY": "your_key",
        "KILN_PRINTER_TYPE": "prusaconnect"
      }
    }
  }
}

Tip: Replace KILN_PRINTER_TYPE with your backend: octoprint, moonraker, bambu, or prusaconnect. Or skip env vars entirely if you've already run kiln setup.

Kiln works with any LLM that supports OpenAI-compatible function calling — not just Claude.

# Interactive agent REPL with any model via OpenRouter
export KILN_OPENROUTER_KEY=sk-or-...
kiln agent --model openai/gpt-4o
kiln agent --model anthropic/claude-sonnet-4
kiln agent --model meta-llama/llama-3.1-70b-instruct --tier essential

# REST API mode — any HTTP client can call Kiln tools
export KILN_API_AUTH_TOKEN=CHANGE_ME_long_random_token
kiln rest --port 8420 --tier full
# POST http://localhost:8420/api/tools/printer_status
# GET  http://localhost:8420/api/tools

# Install with REST API support
pip install kiln3d[rest]

When binding REST to non-localhost addresses (for hosted deployments), set KILN_API_AUTH_TOKEN or pass --auth-token.

Tool tiers automatically match model capability: essential (15 tools) for smaller models, standard (46 tools) for mid-range, full (105 tools) for Claude/GPT-4/Gemini. All 702 tools are available via MCP (kiln serve).

# Install
pip install -e ./octoprint-cli

# Initialize config
octoprint-cli init --host http://octopi.local --api-key YOUR_KEY

# Use
octoprint-cli status
octoprint-cli files
octoprint-cli print myfile.gcode --confirm

The Kiln MCP server (kiln serve) exposes 702 tools to agents. Key tools are listed below — run kiln tools for the complete catalog.

The legacy network_* CLI commands and MCP tool aliases were deprecated in v0.2.0 and have been removed. Use the canonical provider integration tools instead: connect_provider_account, sync_provider_capacity, list_provider_capacity, find_provider_capacity, submit_provider_job, provider_job_status.

The server also exposes read-only resources that agents can use for context:

Kiln supports optional API key authentication for MCP tools. Disabled by default.

# Enable auth
export KILN_AUTH_ENABLED=1
export KILN_AUTH_KEY=your_secret_key

# Clients provide their key via
export KILN_MCP_AUTH_TOKEN=your_secret_key

Scopes: read, write, admin. Read-only tools (status, list) never require auth.

Register HTTP endpoints to receive real-time event notifications:

register_webhook(url="https://example.com/hook", events=["job.completed", "print.failed"])

Payloads are signed with HMAC-SHA256 when a secret is provided.

Security defaults:

• Webhook redirects are blocked by default (KILN_WEBHOOK_ALLOW_REDIRECTS=0).
• If redirects are enabled, each hop is SSRF-validated and HTTPS→HTTP downgrade is blocked.

Kiln can automatically find printers on your local network:

kiln discover

Discovery uses mDNS/Bonjour and HTTP subnet probing to find OctoPrint, Moonraker, Bambu, and Prusa Link printers. If discovery returns no results, register printers directly by IP with kiln auth (works for both Ethernet and Wi-Fi LAN setups).

Third-party entry-point plugins are default-deny in production (KILN_PLUGIN_POLICY=strict). Allow only specific plugins with:

export KILN_ALLOWED_PLUGINS=my_plugin,other_plugin

For temporary migration compatibility, permissive mode can be enabled:

export KILN_PLUGIN_POLICY=permissive

Kiln includes adapters for discovering and downloading 3D models from popular marketplaces:

Marketplace features require free API keys. Get yours and set the environment variables:

export KILN_MMF_API_KEY=your_key               # MyMiniFactory (recommended)
export KILN_CULTS3D_USERNAME=your_username      # Cults3D
export KILN_CULTS3D_API_KEY=your_key            # Cults3D
export KILN_THINGIVERSE_TOKEN=your_token       # Thingiverse (deprecated)

All configured marketplaces are searched simultaneously via search_all_models. Agents can inspect details, download files, and upload directly to a printer — enabling a full design-to-print workflow without human intervention.

Kiln's universal generation adapter auto-discovers text-to-3D providers from environment variables. Set any of the following and the provider is available instantly:

export KILN_MESHY_API_KEY=your_key         # Meshy — cloud text-to-3D
export KILN_TRIPO3D_API_KEY=your_key       # Tripo3D — high-quality cloud text-to-3D
export KILN_STABILITY_API_KEY=your_key     # Stability AI — synchronous 3D generation
export KILN_GEMINI_API_KEY=your_key        # Gemini Deep Think — AI-reasoned text/sketch-to-3D

OpenSCAD is also available for local parametric generation (no API key needed — just install the openscad binary).

Generated models are automatically validated for printability (manifold check, triangle count, bounding box dimensions) before printing. The registry pattern means new providers can be added in under 100 lines. kiln generate and kiln generate-and-print now render a 3-view preview (isometric/dimetric/trimetric) by default; use --no-preview to disable. The MCP provider list reports every supported backend and whether its API key is configured, so agents can reason about the real generation surface instead of a partial subset.

Kiln wraps PrusaSlicer and OrcaSlicer for headless slicing. Auto-detects installed slicers on PATH, macOS app bundles, or via KILN_SLICER_PATH.

# Slice an STL to G-code
kiln slice model.stl

# Slice and immediately print
kiln slice model.stl --print-after

# Smart supports (auto = minimal buildplate-only only when needed)
kiln slice model.stl --support-mode auto

# Override material defaults when needed
kiln slice model.stl --material PETG

# Supported formats: STL, 3MF, STEP, OBJ, AMF

Capture point-in-time images from printer webcams for monitoring and quality checks:

# Save snapshot to file
kiln snapshot --save photo.jpg

# Get base64-encoded snapshot (for agents)
kiln snapshot --json

Supported on OctoPrint, Moonraker, Prusa Link, and Bambu (requires ffmpeg for RTSP capture — see install note above). Agents use the printer_snapshot MCP tool.

Print through external manufacturing services — no 3D printer required, or use alongside your own printers for overflow, specialty materials, or production runs. Kiln handles the entire workflow from idea to delivered product:

# Get material recommendations for your use case
kiln order recommend functional --budget budget

# Instant price estimate (no API call needed)
kiln order estimate FDM --x 80 --y 60 --z 40

# Estimate delivery timeline
kiln order timeline SLA --country US

# List available materials (FDM, SLA, SLS, MJF, etc.)
kiln order materials

# Get a quote for a model
kiln order quote model.stl --material pla-white --quantity 2

# Validate your shipping address
kiln order validate-address --street "123 Main St" --city Austin --state TX --postal-code 78701 --country US

# View shipping insurance options
kiln order insurance 45.00

# Place the order
kiln order place q-abc123 --shipping std

# Track order status
kiln order status o-def456

# View order history
kiln order history

# List supported shipping countries
kiln order countries

Configure your fulfillment provider:

# Craftcloud — works out of the box (no API key required for public endpoints)
export KILN_FULFILLMENT_PROVIDER=craftcloud

# Optional: API key to associate orders with a Craftcloud account
export KILN_CRAFTCLOUD_API_KEY=your_key

# Optional: WebSocket price polling (recommended by Craftcloud, requires pip install websockets msgpack)
export KILN_CRAFTCLOUD_USE_WEBSOCKET=1

# Craftcloud staging (for testing)
export KILN_CRAFTCLOUD_BASE_URL=https://api-stg.craftcloud3d.com

# Optional: explicitly select a provider
export KILN_FULFILLMENT_PROVIDER=craftcloud

Agents use the consumer workflow MCP tools: consumer_onboarding for guided setup, suggest_material_for_order for material selection, estimate_price / estimate_timeline for quick estimates, fulfillment_compare_providers for cross-provider quotes, fulfillment_batch_quote for multi-part assemblies, and fulfillment_order_history / fulfillment_reorder for repeat orders.

# Create a virtualenv first (required on modern Ubuntu/Debian/WSL)
python3 -m venv .venv && source .venv/bin/activate

# Install both packages in dev mode
pip install -e "./kiln[dev]"
pip install -e "./octoprint-cli[dev]"

# Run tests (11,376 total across Kiln + kiln-pro)
cd kiln && python3 -m pytest tests/ -v        # 8,750 tests
cd ../octoprint-cli && python3 -m pytest tests/ -v  # 223 tests (auxiliary CLI tool)

All local printing is free forever — status checks, file management, slicing, fleet control, and printing to your own printers costs nothing.

Kiln charges a 5% orchestration fee on orders placed through external manufacturing services (kiln order / fulfillment MCP tools), with:

• First 3 outsourced orders per month free
• $0.25 minimum / $200 maximum per-order cap

The fee is shown transparently in every quote before you commit.

For provider-routed orders, the provider remains merchant of record and support owner. Kiln acts as orchestration infrastructure.

Run kiln upgrade to activate a license key.

Kiln is safety-first infrastructure for controlling physical machines:

• Pre-flight checks validate printer state, temperatures, and files before every print
• G-code validation blocks dangerous commands (firmware reset, unsafe temperatures)
• Temperature limits enforce safe maximums (300C hotend, 130C bed)
• Confirmation required for destructive operations (cancel, raw G-code)
• Optional authentication with scope-based API keys for multi-user setups
• Structured errors ensure agents always know when something fails

Logo files live in docs/assets/:

All files are vector SVG — scale to any size.

Kiln is free, open-source software. If you find it useful, consider sending a tip:

• Solana: kiln3d.sol
• Ethereum: kiln3d.eth

Messaging clarification (February 24, 2026): We clarified wording to remove ambiguity and align with existing intent; no strategy change. Kiln is orchestration and agent infrastructure for fabrication workflows. Kiln does not operate a first-party decentralized manufacturing marketplace/network. Kiln integrates with third-party providers and external provider/network adapters as integrations are available.

• Operating a first-party decentralized manufacturing marketplace/network
• Replacing partner supply-side networks
• Owning provider marketplaces instead of integrating with them
• Acting as merchant of record for provider-routed manufacturing orders

Kiln is a project of Hadron Labs Inc.

AGPL-3.0 License — open source with copyleft. Commercial licensing available for companies that need proprietary use.

By contributing, you agree to the Contributor License Agreement.