Documentation

About Kiln

Overview

Kiln is the intelligence layer between idea and physical object. It provides a unified interface for AI agents to design, validate, and manufacture 3D-printed parts — controlling local printers, searching third-party model marketplaces (Thingiverse, MyMiniFactory, Cults3D), and routing jobs to fulfillment providers (Craftcloud) — all through the Model Context Protocol (MCP) or a 136-command CLI.

Clarification: Kiln does not operate its own marketplace or manufacturing network. It integrates with third-party marketplaces for model discovery and third-party fulfillment providers for outsourced manufacturing. Kiln is orchestration and agent infrastructure, not a supply-side platform.

Three ways to print:

• 🖨️ Your printers. Control OctoPrint, Moonraker, Bambu Lab, or Prusa Link machines on your LAN — or remotely via Bambu Cloud.
• 🏭 Fulfillment providers. Route to third-party fulfillment services like Craftcloud (150+ services — no API key required). No printer required — or use alongside local printers for overflow and specialty materials.
• 🌐 External provider integrations. Route jobs through connected third-party provider APIs.

All three modes use the same MCP tools and CLI commands.

Non-goals:

• Operating a first-party marketplace or manufacturing network
• Replacing third-party supply-side platforms
• Owning marketplaces instead of integrating with them
• Acting as merchant of record for provider-routed manufacturing orders

Key properties:

• Local-first. Local printer communication stays on your network. No cloud relay, no accounts, no telemetry.
• Adapter-based. One interface covers OctoPrint, Moonraker, Bambu Lab, and Prusa Link. New backends plug in without changing upstream consumers.
• Safety-enforced. Pre-flight checks, G-code validation, and temperature limits are protocol-level — not optional.
• Agent-native. Every operation returns structured JSON. Every error includes machine-readable status codes. --json on every CLI command.

Supported Printers

Key Concepts

PrinterAdapter — Abstract base class defining the contract for all printer backends. Implements: status, files, upload, print, cancel, pause, resume, temperature, G-code, snapshot.

PrinterStatus — Normalized enum: IDLE, PRINTING, PAUSED, ERROR, OFFLINE. Every backend maps its native state model to this enum.

MCP Tools — Typed functions exposed to agents via the Model Context Protocol. Each tool has a defined input schema and returns structured JSON.

MarketplaceAdapter — Abstract base class for searching third-party 3D model repositories. Implements: search, details, files, download. Concrete adapters for Thingiverse (deprecated — acquired by MyMiniFactory, Feb 2026), MyMiniFactory, and Cults3D (search only). Kiln does not host models — it searches external marketplaces.

MarketplaceRegistry — Manages connected marketplace adapters. Provides search_all() for parallel fan-out search across all third-party sources with round-robin result interleaving.

GenerationProvider — Abstract base class for text-to-3D model generation backends. Implements: generate, get_job_status, download_result. Concrete providers for Meshy (cloud AI), Tripo3D (cloud AI), Stability AI (synchronous cloud), Gemini Deep Think (AI-reasoned text/sketch-to-3D via Gemini + OpenSCAD), and OpenSCAD (local parametric). A GenerationRegistry auto-discovers providers from KILN_*_API_KEY environment variables.

Mesh Validation — Pipeline that checks generated STL/OBJ files for 3D-printing readiness: geometry parsing, manifold checks, dimension limits, polygon count validation. Uses pure Python (no external mesh libraries).

Job Queue — Priority queue backed by SQLite. Jobs are dispatched to idle printers by a background scheduler with history-based smart routing (best-performing printer for the job's file/material is preferred).

DeviceType — Enum classifying physical devices. Currently covers FDM printers with room for future device types.

DeviceAdapter — Alias for PrinterAdapter. Alternative import name.

Cross-Printer Learning — Agent-curated outcome database (print_outcomes table) that records success/failure/quality per printer and file. Safety-validated: rejects physically dangerous parameter values.

PaymentProvider — Abstract base class for payment processing backends. Implements: create_payment, get_payment_status, refund_payment, authorize_payment, capture_payment, cancel_payment. Concrete providers for Stripe and Circle (USDC).

PaymentManager — Orchestrates payment collection across providers. Routes to the correct rail (Stripe/Circle/crypto), enforces spend limits, persists transactions, and emits payment events.

HeaterWatchdog — Background daemon that monitors heater state and auto-cools idle heaters after a configurable timeout (default 30 min). Prevents heaters from being left on when no print is active.

LicenseManager — Offline-first license tier management. Resolves tier from key prefix (kiln_pro_, kiln_biz_, kiln_ent_) with cached remote validation fallback. Supports Free, Pro, Business, and Enterprise tiers. Enterprise unlocks RBAC, SSO (OIDC/SAML), audit trail export, lockable safety profiles, encrypted G-code at rest, per-printer overage billing, uptime SLA monitoring, and on-prem deployment. Never blocks printer operations.

Getting Started

Installation

# From PyPI
pip install kiln3d

# From source (development)
pip install -e ./kiln

Requirements: Python 3.10+, pip.

Discover Printers

kiln discover

Scans your local LAN (Ethernet or Wi-Fi) using mDNS and HTTP probing. If discovery does not find your printer, add it directly by IP with kiln auth.

Add a Printer

# OctoPrint
kiln auth --name ender3 --host http://octopi.local --type octoprint --api-key YOUR_KEY

# Moonraker
kiln auth --name voron --host http://voron.local:7125 --type moonraker

# Prusa Link
kiln auth --name prusa-mini --host http://192.168.1.44 --type prusaconnect --api-key YOUR_KEY

# Bambu Lab
kiln auth --name x1c --host 192.168.1.100 --type bambu --access-code 12345678 --serial 01P00A000000001

Ethernet-Only Setup (No Wi-Fi)

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

# Verify endpoint from your host:
curl http://192.168.1.44/api/v1/status                  # Prusa Link
curl http://192.168.1.50:7125/server/info               # Moonraker
curl http://192.168.1.60/api/version                    # OctoPrint

# Register directly by IP (no discovery required):
kiln auth --name printer --host http://192.168.1.44 --type prusaconnect --api-key YOUR_KEY

First Print

kiln status                    # Verify printer is online
kiln preflight --material PLA  # Run safety checks
kiln upload benchy.gcode       # Upload file to printer
kiln print benchy.gcode        # Start printing
kiln wait                      # Block until complete

Slice and Print (STL to Object)

kiln slice benchy.stl --print-after

Auto-detects PrusaSlicer or OrcaSlicer, slices to G-code, uploads, and starts printing.

CLI Reference

Global Options

Commands

`kiln discover`

Scan the local LAN for printers via mDNS and HTTP probing. If no printers are found, use kiln auth --host <ip> to register directly.

`kiln auth`

Save printer credentials to ~/.kiln/config.yaml.

`kiln status`

Get printer state, temperatures, and active job progress.

`kiln files`

List G-code files available on the printer.

`kiln upload `

Upload a local G-code file to the printer.

`kiln print ... [--queue]`

Start printing. Accepts multiple files via glob expansion. With --queue, files are submitted to the job queue for sequential printing.

`kiln cancel`

Cancel the active print job.

`kiln pause` / `kiln resume`

Pause or resume the active print.

`kiln temp [--tool N] [--bed N]`

Get current temperatures, or set targets. Without flags, returns current temps.

`kiln gcode ...`

Send raw G-code commands to the printer. Commands are validated for safety before sending.

`kiln preflight [--material MAT]`

Run pre-print safety checks. Optional --material validates temperatures against expected ranges for: PLA, PETG, ABS, TPU, ASA, Nylon, PC.

`kiln slice [--print-after] [--profile PATH] [--output-dir DIR]`

Slice an STL/3MF/STEP/OBJ/AMF file to G-code. --print-after chains upload and print.

`kiln snapshot [--save PATH]`

Capture a webcam snapshot. --save writes to file; otherwise returns base64 in JSON mode.

`kiln wait [--timeout N] [--interval N]`

Block until the current print finishes. Returns exit code 0 on success, 1 on error/timeout.

`kiln history [--status S] [--limit N]`

Query past print records from the local database. Filter by completed, failed, cancelled.

`kiln printers`

List all saved printers with type and active status.

`kiln use `

Switch the active printer.

`kiln remove `

Remove a saved printer from config.

`kiln serve`

Start the MCP server (for agent integration).

`kiln cost [--material MAT] [--electricity-rate N] [--printer-wattage N]`

Estimate the cost of printing a G-code file. Analyzes extrusion, calculates filament weight and cost, and optionally includes electricity cost.

`kiln material set|show|spools|add-spool`

Material tracking commands. set records loaded material on a printer. show displays current material. spools lists spool inventory. add-spool registers a new spool.

`kiln level [--status] [--trigger] [--set-prints N] [--set-hours N] [--enable/--disable]`

Bed leveling management. Check status, manually trigger leveling, or configure auto-leveling policy.

`kiln stream [--port 8081] [--stop]`

Start or stop the MJPEG webcam streaming proxy. Proxies the upstream printer webcam stream to a local HTTP endpoint.

`kiln sync status|now|configure`

Cloud sync management. status shows sync state. now triggers immediate sync. configure sets cloud URL and API key.

`kiln plugins list|info`

Plugin management. list shows all discovered plugins. info shows details for a specific plugin.

MCP Server Reference

Installation

The MCP server starts via kiln serve or python -m kiln serve.

Claude Desktop Integration

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

{
  "mcpServers": {
    "kiln": {
      "command": "python",
      "args": ["-m", "kiln", "serve"],
      "env": {
        "KILN_PRINTER_HOST": "http://octopi.local",
        "KILN_PRINTER_API_KEY": "your_key",
        "KILN_PRINTER_TYPE": "octoprint"
      }
    }
  }
}

Tool Catalog (Selected)

Kiln exposes 456 MCP tools in total. The most commonly used tools are documented below by category. Run kiln tools for the complete list.

Printer Control

File Management

Slicing

Monitoring

Fleet Management

Job Queue

Model Discovery

System

Cost Estimation (Quick Reference)

See Cost Estimation below for the full tool set including slice_and_estimate, compare_print_options, and material cost from mesh geometry.

Material Tracking

Material Intelligence

Bed Leveling

Webcam Streaming

Cloud Sync

Plugins

Billing & Payments

External Provider Integrations *(As Integrations Launch)*

Kiln does not operate its own marketplace or manufacturing network. These tools integrate with third-party provider APIs for capacity discovery and job routing.

Safety Audit

Fulfillment Services (Third-Party Providers)

Routes manufacturing to third-party fulfillment providers (Craftcloud). Kiln acts as an API client to these providers — it does not operate manufacturing capacity or act as merchant of record.

Consumer Workflow (No Printer Required)

Model Generation

Supported providers: meshy, gemini, tripo3d, stability, openscad. Set KILN_GEMINI_API_KEY, KILN_MESHY_API_KEY, KILN_TRIPO3D_API_KEY, or KILN_STABILITY_API_KEY to enable cloud providers. For original idea-to-part creation, prefer generate_original_design, which chooses idea-to-CAD backends and explicitly does not treat raw openscad compilation as natural-language generation.

Mesh Analysis & Repair

Pure-Python mesh operations — no external mesh libraries required. Operates directly on STL binary geometry for analysis, repair, transformation, and composition.

Parametric Design Templates

Design Advisor & Iteration

Original Design Audit & Design DNA

The generate_original_design / audit_original_design pipeline produces idea-to-part designs and validates them through a multi-gate readiness audit. Each audit gate (mesh validity, printability, design constraints, orientation, build volume) independently passes or blocks with severity levels.

When designs are generated via OpenSCAD (parametric), the pipeline preserves the parametric source code alongside the compiled mesh. This "Design DNA" allows agents to iterate on the design by modifying parameters rather than regenerating from scratch. The audit_original_design function chains: mesh validation, printability analysis (7-dimension), design intelligence constraint checking, auto-orientation scoring, and prompt improvement feedback — returning a single OriginalDesignAudit with a readiness score, blockers list, and next-action recommendations.

Print Analysis

Firmware Updates

Vision Monitoring (Agent-Delegated)

Kiln provides structured monitoring data (webcam snapshots, temperatures, print progress, phase context, failure hints) to agents. The agent's own vision model (Claude, GPT-4V, Gemini, etc.) analyzes the snapshots for defects — Kiln does not embed its own vision model. Kiln adds lightweight heuristic validation (brightness/variance checks) to detect blocked cameras or corrupted frames.

Cross-Printer Learning

Printability Engine

7-dimension analysis of STL/OBJ meshes for FDM printing readiness. Pure Python (no external mesh libraries). Each dimension produces a typed dataclass result; the composite report includes a 0-100 score, letter grade (A-F), and actionable recommendations.

The last two dimensions (thermal stress and adhesion force) are material-aware heuristics. Thermal stress accounts for layer bonding weakness at sharp geometric transitions. Adhesion force estimation combines contact area, material shrinkage coefficients, and printer type (bed-slinger vs. CoreXY) to predict detachment risk.

Adhesion intelligence includes a decision matrix combining contact percentage, material warp tendency (_HIGH_WARP_MATERIALS: ABS, ASA, PA, PC, etc.), bed-slinger detection, enclosure status, and model height to produce concrete slicer overrides (brim_width, brim_type, raft_layers).

Multi-Part Assembly & Job Splitting

Splits large models or multi-part assemblies across multiple printers for parallel printing. Three split modes: build volume overflow (model exceeds one printer), multi-copy distribution (N copies across fleet), and assembly splitting (multi-STL archive across printers with reassembly instructions).

Cost Estimation

G-code and 3MF cost analysis. Parses extrusion totals, calculates filament weight and cost from a 9-material database (PLA, PETG, ABS, TPU, ASA, Nylon, PC, PVA, HIPS), and optionally includes electricity cost from slicer-embedded time estimates. For 3MF files (including Bambu .gcode.3mf), extracts slicer metadata directly from the archive.

Pipelines (Runtime)

Model Cache

Database Management

Printer Trust

Design Intelligence

Constraint-aware design reasoning — agents query material properties, design patterns, and functional constraints before generating geometry.

Construction-Scale Design Intelligence

Enterprise Features (Enterprise Tier)

MCP Resources

Read-only resources for agent context:

Printer Adapters

OctoPrint

Communicates via HTTP REST. Requires an API key (generated in OctoPrint settings).

Configuration:

type: octoprint
host: http://octopi.local
api_key: YOUR_KEY

State Mapping: OctoPrint returns state as a set of boolean flags (printing, paused, error, ready, operational). The adapter maps flag combinations to PrinterStatus.

Webcam: Snapshots via GET /webcam/?action=snapshot.

Moonraker

Communicates via HTTP REST. No authentication required by default (Moonraker trusts local network).

Configuration:

type: moonraker
host: http://voron.local:7125

State Mapping: Moonraker returns Klipper state as a string (ready, printing, paused, error, shutdown). Direct mapping to PrinterStatus.

Webcam: Discovers cameras via GET /server/webcams/list, then fetches the snapshot URL.

Bambu Lab

Communicates via MQTT over LAN. Requires access code and serial number (found in printer settings).

Configuration:

type: bambu
host: 192.168.1.100
access_code: "12345678"
serial: "01P00A000000001"

Note: Requires paho-mqtt package. Kiln gracefully handles its absence.

Prusa Link

Communicates via Prusa Link REST API (/api/v1/). Requires a Prusa Link API key.

Configuration:

type: prusaconnect
host: http://prusa-mk4.local
api_key: YOUR_KEY

State Mapping: Prusa Link returns state as a string (IDLE, PRINTING, PAUSED, FINISHED, ERROR, etc.). Direct mapping to PrinterStatus.

Limitations: No raw G-code or direct temperature control — these are managed through print files.

Elegoo (SDCP)

Communicates via the SDCP (Smart Device Control Protocol) over WebSocket on port 3030. No authentication required on local network. Covers Elegoo printers with cbd-tech/ChituBox mainboards: Centauri Carbon, Centauri Carbon 2, Saturn, Mars series.

Note: Elegoo Neptune 4 and OrangeStorm Giga run Klipper/Moonraker. Use the moonraker adapter type for those printers (port 4408 for Fluidd, 7125 for Moonraker API).

Configuration:

type: elegoo
host: 192.168.1.50
mainboard_id: ABCD1234ABCD1234  # optional, auto-discovered

Environment variables:

export KILN_PRINTER_HOST=192.168.1.50
export KILN_PRINTER_TYPE=elegoo
export KILN_PRINTER_MAINBOARD_ID=ABCD1234  # optional

State Mapping: SDCP returns numeric status codes. Mapping: 0=IDLE, 5/8/9/20=BUSY, 10=PAUSED, 13=PRINTING. Unknown codes default to UNKNOWN.

File Upload: SDCP uses a pull-based upload model — Kiln starts a temporary HTTP server, sends the printer a download URL, and the printer fetches the file. The printer must be able to reach the host machine on the ephemeral port.

Discovery: UDP broadcast of M99999 on port 3000. All SDCP printers on the network respond with their details.

Dependencies: Requires websocket-client package. Install with pip install 'kiln[elegoo]'.

Model Marketplaces (Third-Party Search)

Kiln provides a MarketplaceAdapter interface (mirroring the printer adapter pattern) for searching and downloading 3D models from third-party repositories. Kiln does not host or serve models itself — it searches external marketplaces on the user's behalf. A MarketplaceRegistry manages connected adapters and exposes search_all() for parallel fan-out across all sources.

Supported Marketplaces

Configuration

Set environment variables for each marketplace you want to enable:

export KILN_MMF_API_KEY=your_key               # MyMiniFactory developer key (recommended)
export KILN_CULTS3D_USERNAME=your_username      # Cults3D account username
export KILN_CULTS3D_API_KEY=your_key            # https://cults3d.com/en/api/keys
export KILN_THINGIVERSE_TOKEN=your_token        # Deprecated — Thingiverse acquired by MyMiniFactory (Feb 2026)

Adapters are auto-registered at server startup based on available credentials. Only configured marketplaces participate in searches.

Unified Search

search_all_models fans out the query to all connected marketplaces in parallel using a thread pool. Results are interleaved round-robin across sources for variety. If one marketplace fails (rate limit, timeout), results from the others still return.

Each result includes a source field identifying the marketplace, plus print-readiness hints:

• is_free — whether the model is free to download
• has_sliceable_files — has STL/3MF/OBJ files that need slicing
• has_printable_files — has ready-to-print G-code

Download and Upload

download_and_upload combines marketplace file download with printer upload in a single tool call. Accepts a source parameter to target any marketplace that supports downloads. Cults3D is excluded (metadata-only).

Safety Systems

Pre-flight Checks

Every print job should pass through preflight_check():

1. Printer online — Adapter can reach the printer
2. Printer idle — No active job running
3. File exists — Target file is on the printer
4. Temperature safe — Targets within safe bounds
5. Material validation — When --material specified, temperatures match expected ranges

G-code Validation

The validate_gcode() function screens commands before they reach hardware:

• Blocked: Firmware reset, EEPROM wipe, unsafe axis movements
• Warned: High temperatures, rapid moves without homing
• Passed: Standard print commands, temperature sets within limits

Temperature Limits

Authentication

Disabled by default. Enable for multi-user or network-exposed setups.

export KILN_AUTH_ENABLED=1
export KILN_AUTH_KEY=your_secret_key

Scopes: read, write, admin.

Read-only tools (printer_status, printer_files, fleet_status) never require authentication.

Webhooks

Register HTTP endpoints for real-time event notifications:

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

Event types: job.submitted, job.dispatched, job.completed, job.failed, job.cancelled, print.started, print.paused, print.resumed, print.failed, printer.online, printer.offline, printer.error, stream.started, stream.stopped, sync.completed, sync.failed, leveling.triggered, leveling.completed, leveling.failed, leveling.needed, material.loaded, material.mismatch, material.spool_low, material.spool_empty, plugin.loaded, plugin.error, vision.check, vision.alert.

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

Configuration

Config File

Location: ~/.kiln/config.yaml

active_printer: my-voron

printers:
  my-voron:
    type: moonraker
    host: http://voron.local:7125

  ender3:
    type: octoprint
    host: http://octopi.local
    api_key: ABC123

  x1c:
    type: bambu
    host: 192.168.1.100
    access_code: "12345678"
    serial: "01P00A000000001"

settings:
  timeout: 30
  retries: 3

Environment Variables

Precedence

CLI flags > Environment variables > Config file.

Development

Setup

git clone https://github.com/codeofaxel/Kiln.git
cd kiln
pip install -e "./kiln[dev]"
pip install -e "./octoprint-cli[dev]"

Running Tests

cd kiln && python3 -m pytest tests/ -v    # 8,000+ tests
cd ../octoprint-cli && python3 -m pytest tests/ -v  # 239 tests

Adding a New Printer Adapter

1. Create kiln/src/kiln/printers/yourbackend.py
2. Implement all abstract methods from PrinterAdapter in base.py
3. Return typed dataclasses — never raw dicts
4. Map all backend states to PrinterStatus enum
5. Handle connection failures gracefully (return OFFLINE)
6. Add to the adapter factory in cli/config.py
7. Write tests following the pattern in tests/test_server.py

Project Structure

kiln/src/kiln/
    __init__.py
    __main__.py          # Entry point
    server.py            # MCP server + all tools
    slicer.py            # PrusaSlicer/OrcaSlicer integration
    registry.py          # Fleet printer registry
    queue.py             # Priority job queue
    scheduler.py         # Background job dispatcher with smart routing
    events.py            # Pub/sub event bus
    persistence.py       # SQLite storage
    webhooks.py          # Webhook delivery
    auth.py              # API key authentication
    billing.py           # Fee tracking
    gcode.py             # G-code safety validator (per-printer limits)
    safety_profiles.py   # Bundled safety database (29 printer models)
    slicer_profiles.py   # Bundled slicer profiles (auto .ini generation)
    printer_intelligence.py  # Printer knowledge base (quirks, materials, fixes)
    design_intelligence.py   # Design knowledge queries (materials, patterns, constraints)
    design_validator.py      # Design validation + feedback bridge
    pipelines.py         # Pre-validated print pipelines (quick_print, calibrate, benchmark)
    cost_estimator.py    # Print cost estimation (G-code + 3MF, 9 materials)
    printability.py      # 7-dimension printability engine (overhangs, thin walls, bridging, adhesion, supports, thermal stress, adhesion force)
    job_splitter.py      # Multi-printer job splitting (multi-copy, assembly, build volume overflow)
    original_design.py   # Original design audit pipeline (multi-gate readiness)
    materials.py         # Multi-material tracking
    bed_leveling.py      # Bed leveling trigger system
    streaming.py         # MJPEG webcam proxy
    cloud_sync.py        # Cloud sync manager
    heater_watchdog.py   # Auto-cooldown watchdog for idle heaters
    licensing.py         # License tier management (Free/Pro/Business/Enterprise)
    sso.py               # SSO authentication (OIDC/SAML, IdP role mapping, email domain allowlists)
    gcode_encryption.py  # G-code encryption at rest (Fernet/PBKDF2)
    printer_billing.py   # Per-printer overage billing (metered via Stripe)
    teams.py             # Team seat management with RBAC (admin/engineer/operator)
    uptime.py            # Rolling uptime health monitoring (1h/24h/7d/30d, 99.9% SLA)
    project_costs.py     # Per-project cost tracking for manufacturing bureaus
    model_metadata.py    # Model metadata management
    wallets.py           # Crypto wallet configuration (Solana/Ethereum donations)
    plugins.py           # Plugin system
    backup.py            # Database backup and restore
    log_config.py        # Structured logging configuration
    model_cache.py       # Local model cache with metadata tracking
    plugins/             # Auto-discovered MCP tool plugins (22 modules)
        printability_tools.py    # Printability analysis, auto-orient, adhesion
        recovery_tools.py        # Job splitting, print recovery, checkpoint
        estimate_tools.py        # Slice-and-estimate (no-print cost preview)
        smart_print_tools.py     # Smart reprint, AMS-aware printing
        design_tools.py          # Design intelligence MCP tools
        generation_tools.py      # Model generation + original design
        fulfillment_tools.py     # Third-party fulfillment provider tools
        mesh_diagnostic_tools.py # Advanced mesh diagnostics
        ...                      # + 14 more plugin modules
    payments/
        base.py          # PaymentProvider interface, PaymentRail enum
        manager.py       # Payment orchestration across providers
        stripe_provider.py   # Stripe payment provider
        circle_provider.py   # Circle USDC payment provider
    gateway/
        network.py       # Provider-integration gateway client (canonical partner_* tools + legacy network_* aliases)
    data/
        safety_profiles.json     # Per-printer safety limits (temps, feedrates, flow)
        slicer_profiles.json     # Per-printer slicer settings (INI key-values)
        printer_intelligence.json  # Firmware quirks, materials, failure modes
        design_knowledge/          # Design intelligence data files
            material_troubleshooting.json   # 20 materials × 5-7 failure modes each
            printer_material_compatibility.json  # 29 printers × 20 materials
            multi_material_pairing.json     # Soluble support pairs, co-print matrix
            post_processing.json            # Finishing techniques per material
    printers/
        base.py          # Abstract PrinterAdapter + dataclasses
        octoprint.py     # OctoPrint REST adapter
        moonraker.py     # Moonraker REST adapter
        bambu.py         # Bambu Lab MQTT adapter
        prusaconnect.py  # Prusa Link adapter
        elegoo.py        # Elegoo SDCP adapter (WebSocket)
    fulfillment/
        base.py          # Fulfillment adapter interface
        registry.py      # Provider registry and factory
        craftcloud.py    # Craftcloud v5 API client (third-party; upload → price → cart → order)
        sculpteo.py      # Sculpteo partner API client (third-party; inactive — pending partner credentials)
    marketplaces/
        base.py          # Marketplace adapter interface
        myminifactory.py # MyMiniFactory API client (primary)
        cults3d.py       # Cults3D API client
        thingiverse.py   # Thingiverse API client (deprecated — acquired by MMF)
    cli/
        main.py          # Click CLI entry point
        config.py        # Config management
        discovery.py     # mDNS printer scanning
        output.py        # JSON/text formatting

deploy/                  # On-prem Enterprise deployment
    k8s/                 # Kubernetes manifests (9 files: namespace, deployment, service, ingress, configmap, secrets, PVC, network policies, HPA)
    helm/kiln/           # Helm chart (12 files: Chart.yaml, values.yaml, templates/)

Kiln is a project of Hadron Labs Inc.