kiln latest
Latest server release

Serve it. Teach it.
Watch it get better.

Kiln serves, trains, and evaluates Qwen3.5-4B on one GPU. Turn agent traces and scoring signals into LoRA adapters, prove the change locally, and serve the winner through the same OpenAI-compatible endpoint.

Start the quickstart See the learning pass
  • Rust server
  • One binary
  • One GPU
  • MIT licensed
repair-policy · illustrative trace local example
task

A test fails after a small refactor. What do you do first?

before 0 / 1

Rewrite the module so the implementation is easier to reason about.

reward accepted · adapter updated POST /v1/train/grpo
1 update
after 1 / 1

Run the failing test, isolate the regression, then patch the smallest surface.

repair-policy-v3 is now serving

OpenAI-compatible API for existing clients OpenEnv · SFT · GRPO · OPD training CUDA · ROCm · Metal · Vulkan Exact receipts and strict replay
One local improvement loop

From real work to a verified adapter.
Keep the loop on your machine.

Most inference servers stop after the response. Kiln keeps the entire improvement cycle beside the model—from captured work to an adapter you can measure, inspect, and serve.

01

Serve

Point pi, opencode, or any OpenAI client at localhost:8420/v1.

02

Capture

Collect OpenEnv episodes, agent traces, scores, and A/B judgments locally.

03

Teach

Run bounded SFT, GRPO, or OPD and publish a versioned LoRA adapter.

04

Prove

Compare adapters, inspect every example, and strictly replay seeded evals.

Train with OpenEnv Walk through GRPO See the eval loop Read the checkpoint contract
The product is already in the binary

Operate the loop, not a collection of scripts.

Every Kiln server ships a dashboard for live requests, adapters, training, evals, traces, and exact receipts. No separate control plane to install.

localhost:8420/ui embedded dashboard
Kiln embedded server dashboard showing server status, live request activity, adapters, training, and operational controls.
01

See every request

Streaming traces, token timing, tool calls, and serving-adapter identity.

02

Train without a sidecar

Queue SFT, GRPO, and OPD jobs against the resident model.

03

Judge the result

Run suites, compare adapters, and turn A/B picks into training data.

04

Keep the evidence

Receipts bind model, data, runtime, adapter, and replay identity.

Serving-profile boundary: the default stable profile serves traffic but rejects training and live adapter changes. Use experimental for the interactive learning loop. Read the profile contract.

Explore the current product tour
A different kind of model server

Built for the tight loop.

Kiln is deliberately narrow: one model family, one GPU, and one complete path from inference to evidence-backed improvement.

One model, end to end

Purpose-built for Qwen3.5-4B.

The scheduler, paged KV cache, kernels, quantization, LoRA routes, and training memory plans are tuned for Qwen3.5-4B’s hybrid architecture.

One runtime

Rust server. No Python runtime.

A single executable owns inference, training, evals, adapter lifecycle, metrics, and the dashboard.

One source of truth

Proof is a product feature.

Exact receipts, immutable identities, typed configuration, and strict replay make “better” inspectable.

Your signal

Reward is code, not a platform.

Use a test, regex, scorer, local judge, A/B pick, or teacher. Kiln accepts the result over HTTP.

Your hardware

Four backends. One source tree.

Native CUDA, ROCm, Metal, and Vulkan builds cover Linux GPUs and Apple Silicon; CUDA also ships for Windows.

Run it locally

One binary.
One model path.
One endpoint.

The latest server release publishes five provenance-attested archives: Linux CUDA, ROCm, and Vulkan; Apple Silicon Metal; and Windows CUDA. The macOS binary is signed and notarized. The full quickstart covers drivers, Docker, Desktop, and every backend.

Choose your platform Download latest
bash linux · cuda 12.4 
# Resolve the current provenance-attested server release
KILN_VERSION=$(curl -fsSL https://api.github.com/repos/ericflo/kiln/releases/latest \
  | sed -n 's/.*"tag_name": "kiln-v\([^"]*\)".*/\1/p')

curl -fsSLO "https://github.com/ericflo/kiln/releases/download/kiln-v${KILN_VERSION}/kiln-${KILN_VERSION}-x86_64-unknown-linux-gnu-cuda124.tar.gz"
tar xf "kiln-${KILN_VERSION}-x86_64-unknown-linux-gnu-cuda124.tar.gz"

# Serve Qwen3.5-4B
KILN_MODEL_PATH=./Qwen3.5-4B ./kiln serve

# Connect pi to the local OpenAI endpoint
./kiln pi-setup
listening on localhost:8420/v1 loopback only · no API key
Current, inspectable evidence

Performance you can trace back to the source.

Every number has a workload, command, source revision, and limitation. Every release artifact has a checksum and build-provenance attestation.

Latest server release

Five native artifacts.
One source tree.

  • CUDA 12.4Linux · Windows
  • ROCm 7.2.4Linux
  • MetalApple Silicon
  • VulkanLinux
Checksums · attestations · third-party licenses Inspect the release
Your model already did the work

Now let it learn from it.

Start with one GPU, Qwen3.5-4B, and the scoring signal you already trust.

Run the quickstart Watch Kiln work