The technology

Most of the world's GPUs spend most of their time doing nothing. Gaming rigs sit dark during the working day, workstations idle overnight, and small racks wait between jobs. Meanwhile, anyone who needs a GPU for an afternoon is told to sign a contract, join a waitlist, or pay data-centre prices by the hour whether the machine works or not.

Kiln connects the two with a simple idea: you should only pay for GPU time that can be proven. This page explains how the technology makes that possible, layer by layer.

The idea in one paragraph

A renter funds a lease with dollars (USDC, or $KILN converted at checkout) into an escrow account that no person controls. The provider's machine starts the renter's workload and, every minute it keeps running, signs a small transaction on Solana: a heartbeat. A program on Solana counts those heartbeats, pays the provider for exactly the proven minutes, and returns everything else to the renter. No invoices, no support tickets, no "trust us."

Five layers

Layer	What it does	Where it runs
Settlement	Holds money, enforces the rules, pays out	The Kiln program on Solana
Proof	Turns "the GPU is working" into on-chain evidence	Heartbeats from the provider node
Execution	Runs the renter's workload with the GPU attached	Docker on the provider's machine
Access	Lets only the lease's renter control the workload	The provider's gateway, wallet signatures
Payments	Dollar prices, payable in USDC or $KILN	USDC escrow, Jupiter for $KILN

1. Settlement: a program instead of a company

Kiln's core is a program on Solana. It holds three kinds of record:

Listings: a provider's GPU, its hourly USD price, its region, and the key its machine uses to sign heartbeats.
Leases: one renter renting one listing, at a fixed price, until a fixed end time.
Escrow accounts: one per lease, owned by the program itself. No key, Kiln's included, can move money out of them except by the program's rules.

Those rules are short and strict:

A provider can be paid only for proven seconds, at the price agreed when the lease opened, and never more than the renter deposited.
Anyone can trigger payment for proven time, so providers never wait on renters.
The renter or the provider can end a lease at any time, and ending it always refunds the unproven balance to the renter.
The protocol fee is 2.5%, with a hard ceiling of 20% written into the program.

Because these rules are code on a public blockchain, they're the same for everyone and visible to anyone.

2. Proof: a heartbeat every minute

Proof is the hard part of any compute marketplace. How does a renter know they got what they paid for?

Kiln's answer is the heartbeat. While a renter's container is running, the provider's node sends a transaction once a minute, signed by a key that belongs to that listing. Each heartbeat carries the GPU's measured utilisation and lands on Solana with a timestamp the provider can't choose.

The program counts the time between heartbeats, with one firm rule: if two heartbeats are more than three minutes apart, the gap counts for nothing. So:

A healthy machine earns 60 seconds of proven time per heartbeat.
A machine that drops off the network stops earning that minute, and doesn't get paid for the outage when it comes back.
Stopping the workload stops the heartbeats, so the meter stops too.

This is only practical because of Solana. A heartbeat costs about 0.000005 SOL, a tiny fraction of a cent, and confirms in under a second. Proving a machine every minute of a full day costs around 0.007 SOL in fees, small next to what an hour of GPU time earns. On most other chains, per-minute proof would cost more than the compute.

Heartbeats are public, so every lease's history is visible on the live network: how long it ran, when it last checked in, how hard the GPU was working.

3. Execution: any workload, one GPU, no setup

On the provider's side, kiln-provider turns an ordinary Linux machine with an NVIDIA card into a cloud node. When a renter launches a workload, it:

checks the request (image name, ports, settings) so nothing can smuggle in dangerous options
downloads the container image the renter asked for
starts it with the GPU attached, maps the renter's ports to public ones, and limits what it can do on the host
reports status, links and logs back to the renter
removes it automatically when the lease ends

Renters get one-click templates (JupyterLab with PyTorch, an SSH machine, an OpenAI-compatible LLM API) or can run any Docker image. Anything that runs in a container runs on Kiln.

Because the same node that runs the workload sends the heartbeats, and it only sends them while the container is in the running state, payment is tied to the renter's actual job, not just to the machine being switched on.

There are no accounts on Kiln. When a renter connects to the machine they rented, their wallet signs a short, human-readable message naming the lease. The provider's gateway:

reads the lease from Solana
checks the signature belongs to that lease's renter
issues a session that works only for that lease and expires when it ends

Old signatures are refused, so they can't be replayed, and a session for one lease is useless on any other. The provider never sees a password, and the renter never creates one.

5. Payments: dollar prices, paid your way

Every GPU on Kiln is priced in US dollars and settled in USDC. That gives renters a price they understand and providers earnings they can plan around.

Renters who hold $KILN can still pay with it. At checkout, the site gets a live quote from Jupiter, Solana's swap router, for exactly enough $KILN to cover the deposit. Then a single transaction swaps the $KILN to USDC and opens the lease. If the price moves more than 1%, or anything else fails, the whole transaction is cancelled and nothing is spent.

What a rental looks like

Pick a GPU: an RTX 4090 in Frankfurt at $0.60/hour, say. Fund 8 hours: $4.80 into escrow.
Launch: choose Jupyter, sign one message, and click Open. The provider's node starts JupyterLab with the GPU attached.
Work: heartbeats land every minute. The lease shows as verified on the live network.
Stop early: you finish after 5 hours and 20 minutes. Close the lease.
Settle: the provider receives $3.12 for the proven time (minus the 2.5% fee), and $1.60 comes straight back to your wallet, in the same transaction.

No invoice and no dispute process, because the record of what happened is already on-chain.

Why it's cheaper

Idle hardware has almost no marginal cost. A GPU that's already bought and plugged in can rent for a fraction of data-centre prices and still earn its owner money.
No middleman margin. The protocol takes 2.5%. Everything else goes to the provider.
No paying for downtime. You're charged per proven second, so outages cost you nothing.
No minimums. Rent for one hour. Leave whenever you like.

Built for trust you can check

Claim	How you can check it
Your deposit is safe	It sits in a program-owned escrow account, visible on the explorer
You only pay for proven time	Every heartbeat and payment is a public transaction
The fee is 2.5%	Read live from the program on the Transparency page
Who can change the program	Also on the Transparency page, read from the chain

Where the technology goes next

Today a heartbeat proves the provider's node is up and running your container. The next steps make that proof stronger still:

Renter attestations: your container co-signs heartbeats, so a provider can't claim time without your workload actually running.
GPU challenges: occasional computations with checkable answers catch fake or underpowered hardware.
Provider staking: providers put $KILN at stake, and proven cheating costs them the stake.

See the roadmap for timing, and Proof of rental for exactly what's proven today.