Introduction

What Curta is

A language model that runs inside Solana. Every token is computed by the chain itself, and any program can call it.

Curta is a Solana program that executes a transformer language model’s whole forward pass on chain: tokenizing the prompt, every layer, sampling the next token and decoding it to text. A model’s weights live in sealed Solana accounts. The output of a run is account data that every validator computed, in the same place as a token balance.

A forward pass is a long integer computation, and one transaction holds a fixed amount of compute. Curta makes the computation resumable. A caller opens a run, an account that holds the prompt, the working state of the forward pass and the output. Anyone turns it: a turn is one transaction that advances the forward pass as far as one transaction’s compute allows, and is paid for it from the run’s budget. Tokens appear in the run account as they complete.

A person uses it at the console, a developer in one line, and a program by CPI:

const { text, address } = await curta.run({ model, prompt })

A run from open to close

1. open_run: the caller names a sealed model, gives the prompt and the parameters (max tokens, temperature, seed) and deposits a budget in SOL. The run is running.
2. turn: anyone signs. The program tokenizes the prompt, then advances the forward pass through as many steps as fit, and samples each new token on chain from the run’s seed. The turn pays its signer the turn reward from the budget. Each completed token accrues the publisher’s royalty.
3. The run is complete when it produces the end token or reaches max tokens. Its text is readable from the run account at every turn on the way.
4. settle: anyone signs. The accrued royalty moves to the model’s vault and the accrued protocol share to the fee account.
5. close_run: the caller takes back the unspent budget and the account’s rent.

How it works follows the computation through those turns. Runs and turns covers every state and transition.

The three roles

Runs are paid in SOL: a run costs validator compute, and crankers spend SOL to land turns. Fees gives every amount and who receives it.

The parts

The program

curta is a native Solana program. It holds 6 kinds of account and 13 instructions.

A turn writes only the run and its signer. Weight accounts are read by every run and written by none once the model is sealed, so runs on separate accounts execute in parallel. Accounts, Instructions, Errors and Events are the program’s reference.

The inference core

curta-core is one no_std Rust crate with no dependencies. It holds the weight format, the resumable forward pass, the tokenizer, the sampler and the turn planner. The same source builds for three targets:

• the program (SBF)
• the CLI (native)
• the browser (WebAssembly)

Its arithmetic: int8 weights, fixed-point activations, lookup tables. Bit-exact across targets. Inference core describes it, and Weight format the file it reads.

The SDK

@curta/sdk is the TypeScript client for Node 20 and later and for the browser. It carries the WebAssembly build of curta-core, so the quote and the replay it computes come from the code the program runs. Its run and read calls are run, openRun, turn, quote, getRun, getModel, replay. SDK reference lists every call.

The CPI crate

curta-cpi is the Rust crate a Solana program calls Curta with. It builds and invokes open_run, cancel and close_run with a PDA as the opener, and its RunView reads a completed run’s state and text. The example program oracle-of-stories asks the model for a line by CPI and stores it in its own account. Call from a program walks through it.

The CLI

curta is the bin of the @curta/cli package, built on the SDK. It has 7 commands:

CLI reference has every flag.

The cranker

A cranker is a process that turns every running run in order and settles the ones that have ended. It is the crank export of @curta/sdk, and curta crank runs it from the command line with any funded wallet. The turn reward of each turn it lands arrives in its wallet inside that turn’s transaction. Run a cranker sets one up.

The genesis models

The genesis models are Karpathy’s TinyStories checkpoints in the llama2.c architecture, converted to Curta’s integer weight format.

The program runs any model of that architecture family from the configuration in its Model account, and any publisher adds one to the registry. Models describes the registry and Publish a model the steps.

The site

Where to go next