Skip to content
Kiln1.9Get Kiln

Latest published package: Kiln 1.9.0. Earlier versions below identify feature requirements or historical results.

This guide covers the stable @instruktlabs/kiln package. Feature-specific minimum versions are noted where they matter. Use a version available in the npm registry, or build a local package to test an unpublished checkout. CHANGELOG.md lists changes; read the migration notes before upgrading an existing workspace.

Kiln supports standalone authoring with optional projects, a material library and Live Review in the local dashboard. The SDK, CLI and MCP server use the same engine and saved-source contracts.

Install the package

Install the current stable package with Node.js and npm:

mkdir kiln-install
cd kiln-install
npm init -y
npm install @instruktlabs/kiln
npx --offline --no -- kiln-init ../my-assets --harness codex  # or claude, opencode, hermes, agy, copilot, cursor-agent
cd ../my-assets
# Follow START.md for your harness

This selects npm’s stable latest tag. Existing-project adoption and the new SDK host interfaces require 1.1 or later. Check the installed version with npm ls @instruktlabs/kiln. When qualifying an unpublished candidate, use a local package. The next tag is only for prereleases.

The package includes the built CLI/MCP runtimes, renderer code, plugins and skills. You do not need Bun, a source checkout, a build step or a separate model API key to use its tools. Choose the appropriate harness and follow START.md in the generated workspace.

Run the CLI

The executable is named kiln, even though its npm package is @instruktlabs/kiln. For a terminal-wide command:

npm install -g @instruktlabs/kiln
kiln discover --capabilities --json
kiln render my-asset.kiln.js --out my-asset.glb --views sheet.png

npm puts global commands directly in its prefix on Windows and in PREFIX/bin on macOS/Linux. If the shell cannot find kiln, run npm prefix -g, ensure that executable directory is on PATH, and open a new terminal. See npm’s executable locations. kiln-init and kiln-mcp are available the same way. kiln mcp starts the same stdio server from the default executable, which is what npx @instruktlabs/kiln mcp and the official MCP registry entry use.

For a project-local installation, run from the project that contains the dependency:

npm install @instruktlabs/kiln
npx --no -- kiln discover --capabilities --json
# Equivalent:
npm exec --offline -- kiln discover --capabilities --json

npx --no -- refuses an automatic package download when the command is missing. Install the scoped package first; the unscoped package name kiln is a different package. npm scripts can call kiln directly because npm adds local executables to their PATH. See npm exec. In PowerShell, use npm.cmd exec --offline -- kiln … for the equivalent command: PowerShell’s npm script wrapper can consume the separator before forwarding flags.

Generated asset workspaces also contain kiln.mjs. Run node kiln.mjs … there to use the exact installation, Node interpreter and source store selected for that workspace’s MCP server. It also checks whether the managed setup needs an upgrade or repair. This is useful when multiple Kiln versions are installed: a global kiln command uses whichever installation your PATH selects. Without an explicit KILN_WORKSPACE or KILN_PROGRAM_STORE, the direct CLI stores work beneath the current directory’s .kiln/; run it from the intended workspace root.

Add Kiln to an existing project

With Kiln 1.1+, run these commands from the installation directory:

npx --offline --no -- kiln-init /absolute/path/to/my-project --adopt --harness codex --check
npx --offline --no -- kiln-init /absolute/path/to/my-project --adopt --harness codex

The first command previews changes without writing and exits 1 when setup is needed. The second adds Kiln while preserving existing instructions, unrelated MCP settings and user files. Conflicting owned paths stop setup before it replaces them. Read .kiln/START.md and .kiln/AGENTS.md alongside your project’s existing instructions. Repeat with another supported --harness to add its connection around the same source store and assets.

Adoption also works for a new directory. To update an already managed workspace, use check and upgrade. Do not copy a new set of skills over local customizations by hand.

Install a release archive

Archives are also supported. The package packs as instruktlabs-kiln-VERSION.tgz; earlier releases used kiln-engine-VERSION.tgz. Install the actual tarball with Node.js and npm. Download the archive and SHA256SUMS.txt from the selected release, then verify its checksum with sha256sum -c SHA256SUMS.txt or Windows Get-FileHash. Use that release’s documentation and the actual downloaded filename:

mkdir kiln-install
cd kiln-install
npm init -y
npm install /absolute/path/to/PACKAGE.tgz --omit=dev --include=optional
npx --offline --no -- kiln-init ../my-assets --harness opencode  # or claude, codex, hermes, agy, copilot, cursor-agent
cd ../my-assets
# Follow START.md for your harness

The installed package exposes kiln, kiln-init and kiln-mcp. The last command is a stdio server for MCP clients, not an interactive shell. A client can launch it from an existing installation with npm exec --offline -- kiln-mcp; package-based plugin definitions pin the matching engine version and require that exact version to be published, or its reviewed local archive during qualification. npm 11 may warn that the optional webgpu package’s install script is not covered by allowScripts (npm warn install-scripts). That script only clears the macOS download quarantine from the prebuilt Dawn binary the package ships; Windows and Linux need nothing, and the warning is not an install failure. To modify Kiln itself, install from the repository and build with Bun 1.4.2 instead.

Choose your harness from the setup guide. Existing users should read migration notes, then run the newer installation’s kiln-init --check and --upgrade as described below to refresh managed workspace skills and launchers. Do not point an old package at new documentation and assume its tools have changed.

Released-package checks cover Windows, Linux, and hosted Apple Silicon/Intel Mac; see the dated platform receipts. A receipt qualifies the tarball it names, not a later build. Community reports on local Mac installations are welcome. CPU package setup and optional GPU support are separate checks.

Choose the simplest connection

Where you want to work Setup path
Codex, Claude Code or OpenCode Install Kiln, generate a project workspace, open your agent there. Local MCP needs no tunnel.
Google Antigravity CLI or desktop Generate an agy workspace. See the Google setup guide for verified CLI steps and desktop checks.
ChatGPT in a browser Follow the private MCP tunnel guide. This is a separate developer setup.
Gemini Spark in a browser Remote MCP is required; Kiln’s end-to-end Spark integration remains unverified. See current status.

For agent-assisted installation, give your agent the repository URL and ask:

Set up Kiln in a new asset workspace for my current coding agent. Follow docs/install.md and the generated START.md. Keep configuration and skills project-local. Verify tool discovery and a small render before creating my asset. Report missing login or setup failures without substituting another installation.

Release compatibility

The packaged local MCP server lists the fifteen base tools in the generated tool reference, plus kiln_project, kiln_material and kiln_review from the packaged local host: eighteen in all, and nineteen with kiln_export_to when KILN_EXPORT_ROOT is set. When installing an older release, use the documentation and receipt attached to that release; newer tools and migration changes are not retroactively available there.

Package publication requires per-platform receipts (Linux, Windows, macOS arm64, macOS x64) and SHA256SUMS.txt for the exact tarball. Check the artifacts actually attached to the selected release; do not treat an older receipt or a source archive as qualification of a different package version.

A successful local build or an unreleased fix does not update the GitHub release: a checkout can be ahead of it. Registry and GitHub release receipts each identify the exact archive they qualify; neither an unpublished checkout nor an older receipt proves that a newer version has been published and verified.

Start on a Mac with a local package

The compiled CLI and MCP runtime contract is Node 20.15.0+ on the 20.x line, or 22.2.0 and later. Bun and a particular npm version are not end-user requirements. For a new installation, use a maintained Node 22 or 24 LTS release from the official download page. Node 20 compatibility allows distribution-managed installations; Node 20 itself is upstream EOL. Use native ARM64 Node on Apple Silicon, or x64 Node on an Intel Mac. Check what this terminal is running:

node --version
npm --version
node -p "process.platform + ' ' + process.arch"

The last line should say darwin arm64 or darwin x64. The npm supplied with Node can install the package; contributor CI pins npm 12.2.0 for reproducible receipts. You do not need to change global npm or install Homebrew for this workflow.

The optional built-in Strands agent and SDK subpaths agent and composer/agent require Node 22.2.0+ and their optional SDK and provider dependencies. Using Kiln from Cline or another MCP/CLI agent does not require Strands or its model-provider packages. The v1 library and commands are compiled; package imports need no TypeScript loader. Maintainer release checks still use the exact versions in the source repository’s toolchain.json. Package CI checks Linux Node 20.15.0, 22.2.0 and 24.20.0, plus Node 22.23.4 on Linux, Windows and both macOS architectures. Each receipt qualifies only its named tarball; a later candidate needs its own passing checks. Physical GPU coverage and distribution-specific Debian/Cline setup remain separate checks.

Cline CLI 3.0.64 and VS Code 4.1.20 Next/SDK have a known MCP-to-model limitation: image responses become text, with larger results also truncated. The tested Legacy extension preserves images. Until the affected path is fixed and verified, use Kiln CLI exports and Cline’s native image-file reader for visual review; see the setup instructions and upstream issue #14421. Kiln’s standard MCP output is unchanged.

This separation follows feedback from a Cline user recommending Kiln for programming and game-development classes, who reported needing to install Node 22 on Debian. The reporter’s name and exact Debian/Node versions were not supplied.

Choose a permanent installation directory and use the real tarball filename:

mkdir -p "$HOME/Developer/kiln-install"
cd "$HOME/Developer/kiln-install"
npm init -y
npm install "/absolute/path/to/PACKAGE.tgz" --omit=dev --include=optional
npm exec --offline -- kiln-init ../my-assets --harness codex
cd ../my-assets
node kiln.mjs --help

Choose your harness from the table below, then follow START.md in the new workspace. The setup creates project-local configuration and copies the skills. These authoring skills support external CLI/MCP harnesses. Strands-specific workflow guidance stays inside the optional built-in agent and is not installed into CLI/MCP workspaces. Do not copy its native finish protocol into your harness; see the workflow boundary. Your source and revisions live in my-assets; the installed engine stays in kiln-install. No global skills or agent configuration are changed. Keep the installation in place while using its workspaces.

CPU images work without a GPU service. Start there to verify the connection. They show geometry and flat color; use GPU rendering for material review. Apple GPU/Metal operation is also unverified; a CPU package result would not establish GPU support.

Kiln uses sharp for image work. Its upstream distribution includes native macOS ARM64 and x64 binaries, installed through optional dependencies; keep those enabled. Install dependencies on the Mac rather than copying node_modules from another OS or architecture. The standard prebuilt path should not require a compiler or a separate libvips installation. If installation instead tries to compile native code, check the Node architecture and npm optional-dependency settings before adding a build toolchain. See sharp’s installation guidance. Manifold CSG and xatlas UV unwrapping are shipped WASM dependencies and are exercised by the package smoke alongside the native image dependency.

Install from the repository

git clone --filter=blob:none https://github.com/instruktlabs/kiln
cd kiln
bun install --frozen-lockfile
bun run build:runtime
node scripts/create-workspace.mjs ../my-assets --harness opencode

dist/ is built, not tracked, so a clone has no runtime until that build runs, and a pull leaves the previous build in place. After pulling, run bun run build:runtime again, then rerun setup with --check and --upgrade for any workspace that runs from this checkout.

--filter=blob:none checks out the current tree in full and leaves historical file contents on the server, so the clone transfers less and finishes sooner. Git fetches an old file version on demand the first time something asks for one, which needs network access. Use a plain git clone if you want the entire history available offline.

Setup checks that the Node runtime, bundles, dependencies and selected skills are available before writing the workspace. It does not install an agent or sign in on your behalf. Open the generated START.md for the selected harness’s launch steps.

The destination must be empty and outside the installation. Authoring, refinement and QA skills are included. Add scene composition and batch dispatch when needed:

node scripts/create-workspace.mjs ../my-scene --harness codex --skills compose,batch

--progress-file PATH names the workspace-relative compaction handoff the guide tells the agent to keep (default KILN_PROGRESS.md at the root). Choose a folder the host lets the agent edit; see long-running sessions.

Skills are ordinary Markdown files with supporting resources. Ask the agent to read AGENTS.md and the relevant skill; a special skill loader is not required. Setup does not change global skills, configuration, or authentication.

Install a local package

Contributors can build an installable tarball without publishing anything:

bun run build:runtime
npm pack --ignore-scripts

Install the resulting .tgz in a separate installation directory using npm. The package includes the Node entry points and workspace setup; npm installs their runtime dependencies. The build includes a separate worker and deterministic bundle metadata. It does not need the original checkout or its devDependencies. Use the actual tarball path and filename returned by npm pack:

mkdir kiln-install
cd kiln-install
npm init -y
npm install /absolute/path/to/PACKAGE.tgz --omit=dev --include=optional
npm exec --offline -- kiln-init ../my-assets --harness opencode  # or claude, codex, hermes, agy, copilot, cursor-agent

kiln renders programs and imports/exports source revisions. kiln-init creates a workspace, and kiln-mcp starts the stdio server. These are installed commands from that exact build of @instruktlabs/kiln. Library consumers use its compiled ESM and TypeScript declarations through the SDK entrypoints, without a source loader. The optional kiln generate adapter is separate and needs its agent/provider dependencies; connecting an existing harness does not load that stack.

Optional built-in agent dependencies

Install these only when using Kiln’s own generation loop or OpenRouter model adapter. Run npm in the engine installation directory created above, where its package.json lists @instruktlabs/kiln, rather than in an asset workspace or the disposable plugin cache:

npm install @strands-agents/sdk@1.19.0 @openrouter/ai-sdk-provider@2.10.0 @ai-sdk/provider@3.0.18

These exact versions passed a fresh installed-package check for all SDK imports and declarations, native render/completion tools and offline OpenRouter adapter construction. The declared minimum peers (Strands 1.18.0, OpenRouter 2.10.0, provider 3.0.0) passed the same bounded check. Native Anthropic, OpenAI, Google and Bedrock routes additionally require their selected adapter’s dependencies. Live model availability and provider credentials are separate from installation; the package does not supply a model subscription. External Claude Code, Codex and other CLI/MCP workflows do not need any of these peers.

Choose a harness

Harness Project configuration Launch from the workspace
Claude Code .mcp.json claude
Codex .codex/config.toml, read once $CODEX_HOME/config.toml marks the project trusted node codex.mjs (applies the same values per run)
OpenCode opencode.json opencode
Antigravity .agents/mcp_config.json node agy.mjs
Hermes One user-level MCP registration; workspace launcher supplies paths node hermes.mjs

Sign in to your harness and accept its normal project/MCP trust prompts. Hermes has no project-local MCP registration; follow its generated START.md for the one user-level registration. Its launcher preserves your existing provider and authentication and supplies this workspace’s paths per run. Do not add --ignore-rules unless you intend to suppress project instructions. The Antigravity launcher sets the absolute project directory and disables automatic skill expansion in print mode. Name kiln_workspace in the brief, use the project skill copies, and pass absolute task-file paths. See clean-room setup for evaluation controls and limitations.

Verify the connection

OpenCode workspaces register their local skills/ directory using the supported skills.paths configuration. With OpenCode 2, opencode debug config from the workspace is the configuration check: it shows the resolved kiln_workspace entry. opencode mcp list reports what OpenCode’s shared background service loaded, not this workspace’s configuration, so it can print “No MCP servers configured” here. These are optional OpenCode diagnostics, not Kiln requirements; node kiln.mjs discover --capabilities --json from the workspace is the harness-independent proof. Start a fresh session in that directory and verify that it reads the workspace’s author, refine and QA skills and calls kiln_workspace; configuration alone does not prove that the running session loaded them. The older opencode debug skill command is not available in OpenCode 2. See the OpenCode configuration schema.

Fetching the skills by URL instead

The same skills are published at a well-known URI, so a client that reads Cloudflare’s Agent Skills Discovery RFC can load them with no clone and no workspace. OpenCode’s skills.urls consumes it:

https://kilnstudio.tools/.well-known/agent-skills/index.json

Each entry names an artifact and the sha256 of its raw bytes, so a client can verify what it fetched. The index is generated from skills/ in the same run that serves it – a committed copy would publish digests that go stale the moment a skill changes.

This path carries the skills and nothing else. It does not configure an MCP server, so kiln_workspace is still absent and no tool call will resolve; the skills will describe a tool surface that is not there. Use it to read the workflows, or alongside a server you configured yourself, not as a substitute for kiln-setup-workspace.

Ask the agent to read AGENTS.md, discover geometry helpers, render a small draft, read its source, edit it by programRef, and export the accepted revision. Check the actual tools and files, not only the agent’s final message. CPU rendering needs no model key or GPU; material-faithful rendering requires the optional GPU service and a successful fidelity result.

The CLI and MCP configuration point to the same .kiln/programs directory. Follow-up calls use immutable source references, so the model need not retransmit its program. Source and revision semantics.

Move or repair an installation

Generated configuration records absolute runtime paths. Setup resolves the Node executable to its real path, so temporary version-manager shell links are not saved in MCP configuration. If you remove that Node version, run repair using the replacement Node installation. Repair also updates workspaces created by older setup versions that saved a temporary shell path.

After moving the runtime or workspace, close its agent session and run setup from the current installation:

node /current/kiln/scripts/create-workspace.mjs /absolute/my-assets --repair

For an installed package, npm exec --offline -- kiln-init /absolute/my-assets --repair works from its installation directory. Repair checks .kiln/workspace.json and updates generated launchers/configuration. It preserves source revisions, asset files, instructions and skill copies. It refuses to replace configuration you edited; update those paths manually while preserving your changes. Restart the harness.

Repair does not upgrade copied skills. To update an existing workspace, stop its harness/MCP session and run from the desired installation:

node /current/kiln/scripts/create-workspace.mjs /absolute/my-assets --check
node /current/kiln/scripts/create-workspace.mjs /absolute/my-assets --upgrade

--check is read-only JSON; it exits 1 when an update is required. It compares runtime identity and bundle bytes, generated configuration, instructions and all three skill locations. --upgrade refreshes unchanged managed files and removes unchanged retired skill resources. Assets, source stores and other user files are left in place. Existing customizations remain when the corresponding upstream file has not changed. If both changed, or an older manifest cannot establish who owns an instruction file, the whole upgrade stops and lists the conflicts before writing anything. Preserve those files separately, compare with a fresh temporary workspace from the desired installation, and resolve them before retrying. Reapply compatible customizations afterward; no automatic content merge is attempted.

Generated CLI launchers refuse a stale managed workspace before running. The MCP server still answers the handshake and the tool list; its first call that needs the engine returns the stale-workspace diagnostic with the kiln-init steps, and the next call succeeds once the workspace is upgraded, without restarting the session. Older launchers need an explicit --check/--upgrade first. Hand-wired MCP setups are outside this managed-workspace check. Customizations are reported by --check; their compatibility remains the owner’s responsibility. Keep exported .kiln.js files as portable checkpoints even when retaining the source store. Use fresh workspaces for independent model evaluations.

Manual MCP configuration

Launch the installed dist/mcp-server.mjs over stdio using an absolute path. It loads dist/mcp-engine.mjs from the same directory on the first call that needs the engine, so launch the installed copy in place rather than copying one file elsewhere. Choose an explicit store shared with your CLI:

{
  "mcpServers": {
    "kiln": {
      "command": "node",
      "args": ["/absolute/path/to/kiln/dist/mcp-server.mjs"],
      "env": {
        "KILN_PROGRAM_STORE": "/absolute/path/to/assets/.kiln/programs",
        "KILN_RENDER": "auto"
      }
    }
  }
}

The table above names each client’s native configuration location; their JSON/TOML shapes differ. Prefer generated configuration. Without an explicit store, the server uses .kiln/programs beneath its process working directory.

The folder above that .kiln is the server’s workspace root: the file input reads programs below it (a relative path, or an absolute path inside it) and the project collection saves to its assets/kiln. A client may start the server in a folder other than the one the agent writes in, so point KILN_PROGRAM_STORE at the agent’s folder (KILN_WORKSPACE is for a kiln-init workspace, which the server checks is current). kiln_discover with capabilities: true reports the root as source.file.workspaceRoot and the setting that chose it as selectedBy (KILN_WORKSPACE, KILN_PROGRAM_STORE or cwd); a refused file names both.

To let the agent write exported files without a shell call, add "KILN_EXPORT_ROOT" to env: an existing absolute directory (on Windows a drive or UNC path, not Git Bash /c/...) outside every collection and the workspace .kiln/. The server then also advertises kiln_export_to, which writes a saved revision’s GLB, and for the runtime profile its metadata sidecar, at a path relative to that directory and never replaces a file. Without the variable the tool list is unchanged. The server checks the directory when the engine starts; a wrong value fails each call with the fix. See export profiles.

For an explicitly bound asset brief, append "--requirements" and the absolute path to a host-binding JSON file to args. This optional policy is fixed for the server session; changing the file requires a new session. The default remains neutral authoring. See host requirements for the binding format and task/asset lineage boundary. A binding can also carry a host validation profile that the final GLB must satisfy; kiln_discover with capabilities: true shows it to the author.

The legacy root plugin manifests launch the Node bundle from an engine installation. The v1 local plugin below uses a smaller bundle and creates an explicit workspace.

Local Claude Code and Codex plugins

The commands below select the released 1.9.0 plugin, which supports new workspaces and existing-project adoption. The matching GitHub tag and npm version are available. To qualify an unpublished candidate, select its exact source ref and supply the matching local engine archive as described in its bundled setup reference. Normal use should select a published release tag.

The product is Kiln; its local plugin installation ID is kiln-engine in the Instrukt Labs marketplace instruktlabs. Its cache contains setup guidance and an installer, while the pinned engine and asset workspaces stay in persistent directories outside that cache. Installing the plugin does not start a second global Kiln MCP server.

For Claude Code:

claude plugin marketplace add instruktlabs/kiln#v1.9.0 --sparse .claude-plugin plugins/kiln-engine
claude plugin install kiln-engine@instruktlabs

For Codex:

codex plugin marketplace add instruktlabs/kiln --ref v1.9.0 --sparse .agents/plugins --sparse plugins/kiln-engine
codex plugin add kiln-engine@instruktlabs

Ask your agent to set up a Kiln asset workspace. The setup skill installs the exact package version in runtime.json through npm, with optional dependencies included and lifecycle scripts disabled. Node.js and npm are required; an engine checkout, Bun and a separate model API key are not. An existing working workspace can be used as-is. Otherwise choose a new workspace or preview adoption of an existing project, then follow the generated startup instructions to open an authoring session. Accept the host’s project/MCP trust prompts, then verify kiln_discover({capabilities:true}) on kiln_workspace and an actual render.

The workspace owns its author/refine/QA skills and MCP configuration. The plugin registers only setup, avoiding duplicate authoring skills and servers. It does not redirect saved assets or rewrite an existing workspace when its cached version changes. For an intended engine update, use the new plugin’s helper with --check and --upgrade, following its bundled references/plugin-install.md; customized managed files require explicit conflict resolution. Select the desired release tag when changing the marketplace source. Removing the plugin leaves the persistent runtime and authored assets in place.

An older kiln@kiln installation can expose a separate global kiln server. Disable or uninstall that old plugin in the relevant host before using the new workspace workflow, after recording any custom store paths. Do not delete its source store. See the v1 migration notes.

Verify a distribution as a contributor

bun run build:runtime
npm run test:package

This explicit smoke test may download dependencies from npm. It makes no model calls and publishes nothing. It packs the current files, installs without devDependencies in a temporary directory, tests CSG and UV WASM, CPU images, MCP discovery, reference editing, persistence across restart, and exact source export. It retains a JSON receipt and artifacts at the printed path. Normal unit tests do not run npm installs.

The maintained local plugin is generated with node scripts/package-local-plugin.mjs FRESH_OUTPUT_DIRECTORY. Review the generated files before copying them into plugins/kiln-engine, then run node scripts/package-local-plugin.mjs plugins/kiln-engine --check. The unit suite checks those bytes, including the version pin and complete setup reference. The package smoke checks that the installed npm archive contains both catalogs and every file named by the plugin’s hash inventory. Validate the plugin itself with claude plugin validate plugins/kiln-engine --strict, in addition to the marketplace manifest. A local-path Claude installation loads in place; use a Git-backed marketplace to qualify a copied cache installation.

To test an existing package instead of packing the checkout, run node scripts/smoke-package.mjs --tarball /absolute/candidate.tgz. For Linux, run node scripts/smoke-package-linux.mjs /absolute/candidate.tgz /absolute/receipt.json with Docker running. See the recorded Linux package check for the pinned image, exact candidate hash, coverage, and limitations.

CI builds one tarball on Linux, then runs the same npm package smoke natively on macos-15 (ARM64) and macos-15-intel (x64), with Node 22.23.4 and npm 12.2.0. The Mac jobs install no contributor dependencies and do not set up Bun. Their retained receipts include the tarball hash, native architecture and completed checks. These versioned runner labels follow GitHub’s runner catalog; GitHub maintains the underlying images, so the labels are not immutable OS images. Both architectures passed all 16 package checks in CI run 33996715717. The retained receipts are linked in the platform matrix.

CI also runs Linux package jobs at Node 20.15.0, 22.2.0 and 24.20.0 using each distribution’s npm. The release build retains its pinned maintainer toolchain. A separate Ubuntu 24.04 job selects Mesa software Vulkan and exercises textured renderer readback from the installed tarball, recording the adapter class and PNGs. This probe explicitly permits a software adapter; normal Kiln GPU rendering continues to require hardware. A job qualifies only the tarball it ran against, and none of these jobs qualifies physical AMD, Intel or Apple GPU behavior.

Embed the tools

import { createKilnProgramToolRegistry } from '@instruktlabs/kiln/tools';
const tools = createKilnProgramToolRegistry();

Definitions include the schema, implementation and image extraction. Forward image content as well as text. An embedded registry uses an in-memory store unless the host injects a persistent ProgramStore. See the library reference.

Evaluation limits

Local CLI/MCP builds run in a separate process by default, with a 60-second deadline, 16 MiB GLB cap and 32 MiB response cap. The Node worker has a 512 MiB V8 old-space heap cap; native/WASM buffers and total process memory are not bounded by that flag. KILN_EVALUATOR_TIMEOUT_MS accepts 1 to 120000 and KILN_EVALUATOR_HEAP_MB accepts 64 to 4096 in the packaged Node runtime. KILN_EVALUATOR_MAX_GLB_BYTES accepts 1 to 67108864; see large assets. Host callers can cancel through an AbortSignal.

KILN_EVALUATOR_MODE=in-process retains the trusted legacy path, with no hard synchronous interruption. A separate process is not an operating-system security sandbox. The isolated mode remains host-specific and requires its verified Linux isolation setup; its fixed 65-second CPU-time limit stays in force whatever KILN_EVALUATOR_TIMEOUT_MS says.

Optimize and instancing options are sent explicitly to the worker. The legacy KILN_QA_MODE=observe|off override is rejected in subprocess mode rather than silently ignored; remove it or choose the trusted in-process mode deliberately.

Read this page in the repository