How it works

This page follows a single rental from start to finish and shows what happens on-chain and on the provider's machine at each step.

The parts

 ┌──────────────┐      wallet txs       ┌──────────────────────┐
 │   Renter     │ ────────────────────▶ │  Kiln program        │
 │  (browser)   │                       │  on Solana           │
 └──────┬───────┘                       │  • listings          │
        │ signed session                │  • leases + escrow   │
        │ deploy / status / logs        │  • heartbeats        │
        ▼                               │  • settlement        │
 ┌──────────────┐     relay (https)     └──────────▲───────────┘
 │ kiln site    │ ──────────────┐                  │ heartbeat + settle txs
 └──────────────┘               ▼                  │
                       ┌──────────────────────┐    │
                       │  kiln-provider node  │────┘
                       │  gateway :8443       │
                       │  Docker + GPU        │──▶ renter's container
                       └──────────────────────┘    (ports 30000–30099)
  • The Kiln program is the source of truth. It holds listings, leases and escrowed funds, records heartbeats, and pays out.
  • The provider node (kiln-provider) runs on the GPU machine. It has a small HTTP gateway for renters, runs workloads with Docker, and signs heartbeats with a dedicated heartbeat key.
  • The website lets you sign transactions with your wallet and relays your deploy requests to the provider's gateway.

1. A provider lists a GPU

The provider runs kiln-provider heartbeat-key new on their machine, then registers a listing from the website. The listing is an on-chain account holding:

  • the owner wallet, which receives payouts
  • the heartbeat key the machine signs with
  • the price per hour in USDC
  • GPU model, count, region, and the machine's public address (gateway URL)

They start the node with kiln-provider run. From then on, the listing appears on the market.

2. A renter opens a lease

You choose a listing and a number of hours on Rent, and whether to pay in USDC or $KILN. Your wallet signs one transaction that:

  1. creates a lease account recording the price, start time and end time
  2. creates an escrow token account owned by the lease
  3. moves price × hours in USDC from your wallet into that escrow

If you pay in $KILN, the same transaction first swaps exactly enough $KILN to USDC through Jupiter, Solana's main swap router. If the swap or the lease fails, the whole transaction is cancelled and nothing leaves your wallet.

The price is fixed for the life of the lease, even if the provider changes their listing later.

3. You connect to the machine

You click Connect to machine and your wallet signs a plain-text message (no transaction, no fee):

Kiln session
lease: <your lease address>
provider: <the listing address>
issued: <unix time>

The provider's gateway reads your lease from Solana, checks that you are its renter and that it is still running, and verifies the signature. It then gives you a session token valid until the lease ends. Signatures older than five minutes are refused, so they can't be replayed.

4. You launch a workload

You pick a template (Jupyter, SSH machine, LLM API) or any Docker image with the ports you need. The provider node:

  • validates the request (image name, ports, environment)
  • assigns public ports from its range, for example 30100 → 8888
  • runs the container with --gpus all, without privileged mode
  • reports status, links and logs back to you through the website

Only one renter's workload can run on a listing at a time. If a GPU is busy, you'll be told before anything starts, and you can close your lease for a full refund.

5. The machine proves it's working

Every 60 seconds, for each lease whose container is running, the node measures GPU utilisation with nvidia-smi and sends a heartbeat transaction signed by its heartbeat key.

The program adds the time since the previous heartbeat to the lease's verified seconds, but only if the gap was 180 seconds or less. If a machine goes quiet for longer, that gap is never counted. If you stop your workload, heartbeats stop too. See Proof of rental.

6. The provider gets paid

settle pays the provider for verified time that hasn't been paid yet:

owed = verified_seconds × price_per_hour ÷ 3600   (never more than the deposit)

2.5% of each payment goes to the protocol treasury and the rest to the provider's wallet. The node settles every hour, and anyone can call settle.

7. The lease ends

Either you or the provider can close a lease at any time, and leases also run out at their end time. Closing:

  1. settles any verified time still owed
  2. refunds everything left in escrow to you
  3. closes the escrow and lease accounts and returns their rent deposit to you

The provider node notices the lease is gone and deletes the container within a minute.

What you trust, and what you don't

You don't have to trust Kiln or the provider with your money: escrow and payouts are enforced by the program. You do have to trust the provider's machine with your workload, as with any cloud. See Security and trust for the full picture, including the limits of heartbeat proofs today.

Previous← The technologyNextFAQ →