Docs

Open /mine, pick an instrument and a run length, and start. The tab holds the GPU at full load for the whole run and reports a sustained score at the end. Nothing installs.

Siliq receives the adapter strings your browser exposes, the score, and how long the tab spent hidden. Your IP address is kept as a salted hash and your country as a two-letter code.

Instruments

Run rules

• Runs last 15, 30 or 60 minutes.
• The server issues a signed run token when the run starts. The run completes once, no sooner than its length minus 20 seconds and no later than 15 minutes after its length.
• One address gets 5 runs an hour. Siliq counts addresses by a salted hash of the IP.
• SLQ-01 runs on WebGL2 when WebGPU is missing. The other instruments need WebGPU.
• The result screen flags a run when the tab spent more than 2% of it hidden. Browsers throttle background tabs, and a throttled GPU scores lower.
• A score above the ceiling for your vendor family is cut to the ceiling before anything is recorded.

Ceilings

A ceiling is the highest sustained score Siliq accepts from one vendor family on one instrument. The values come from runs measured on an RTX 5060 Ti (6.3 TF, 4.1 GB/S, 10,100 MP/S, 2.05 TF, 1.1 TF), with headroom for the fastest card in each family.

Trial runs and passes

Whether a run pays depends on the launch and on your wallet.

A pass is a signed message. It sends no transaction, lasts 24 hours and sits in an HttpOnly cookie on this site. The message reads:

Siliq mining pass

I hold $SILQ in this wallet and want a 24 hour pass.
Signing sends no transaction.

wallet: 0x<your wallet>
nonce: <nonce>

• Your tier comes from the dollar value of your $SILQ when the pass is issued.
• When a run starts, Siliq reads your holding again and uses the lower of the two values. A smaller holding means a lower tier for that run.
• When a run finishes, Siliq reads it a third time. If the wallet holds less than $25, the run is recorded unpaid.
• Your tier sets how many GPUs one wallet can mine on at once: 1, 2, 4 from the lowest tier up.

A paid run earns a dollar amount when it completes. At the next settlement Siliq converts that amount into stock tokens and signs it into your voucher.

reward = ($0.08 + SCU × $0.0011) × tier multiplier × governor

SCU = sustained score × run length in seconds ÷ work per SCU

Siliq compute units

Work per SCU is weighted so a minute on one card earns about the same on every instrument. On the reference RTX 5060 Ti, a 15 minute run comes to about 200 SCU on each of the five.

SCU    = 6.3 × 900 ÷ 28 = 202.5
reward = ($0.08 + 202.5 × $0.0011) × 1 × 1 = $0.30

Lineage split

The server picks the split from the vendor it reads in your adapter strings. The browser cannot send a split. A card the server cannot place gets the unknown split.

Arm Mali GPUs and unknown adapters carry no designer slice; their reward goes to the foundry, lithography, memory and the ETF. Samsung has no stock token on Robinhood Chain, so its slice is paid in EWY, a South Korea ETF. SMH, a semiconductor ETF, stands in for packaging, tools and the rest of the chain.

Cycles and vouchers

1. 01
   Cycles last 6 hours and close at 00:00, 06:00, 12:00, 18:00 UTC. Every paid run adds its reward to your wallet's ledger for the open cycle, split by lineage.
2. 02
   Five minutes after a cycle closes, the settler prices each token at market quotes and turns the dollars owed into token amounts, 18 decimals each.
3. 03
   It signs one EIP-712 voucher per wallet and writes the hash of the cycle report on chain with closeCycle.
4. 04
   You call claim(cycle, tokens, amounts, signature) on the vault from the wallet the voucher names, and pay the gas. A voucher holds up to 16 tokens, and a wallet claims each cycle once.
5. 05
   A claim does not wait for closeCycle, so a failed anchor transaction cannot block payouts.

domain   { name: "SiliqVault", version: "1", chainId: 4663, verifyingContract: <vault> }
Voucher  (address wallet, uint64 cycle, address[] tokens, uint256[] amounts)

Governor and caps

The vault pays out of what it holds. Two rules keep a busy cycle from draining it.

• Governor. Siliq aims to pay 1.2% of the vault's dollar value per day, which is 0.3% per cycle. When a cycle owes more than that budget, every amount in the cycle shrinks by the same factor. The rate recorded on new runs has a floor of ×0.1. Settlement has no floor: it never pays past the budget, so a cycle far over budget pays below ×0.1.
• Per-token cap. No cycle pays more than 0.4% of the vault's balance of any one token. When a token runs over, payouts in that token shrink and the other tokens stay whole.

budget per cycle = vault value × 0.012 × 6 ÷ 24
rate             = min(1, budget ÷ total owed in the cycle)
cap per token    = token balance × price × 0.004

SiliqVault is a contract on Robinhood Chain that holds stock tokens and pays vouchers out of them. It has no imports, no proxy and no upgrade path.

deposit(token, amount, memo)

Anyone deposits an ERC-20 with a memo. The Deposited event records the amount the vault received.

closeCycle(cycle, reportHash)

The settler anchors the hash of a cycle report, once per cycle. The contract keeps it as a public record.

claim(cycle, tokens, amounts, signature)

A wallet redeems its voucher. The contract checks the settler signature, that the voucher names the caller, and that the cycle is unclaimed.

setSettler, transferOwnership, acceptOwnership, sweep

Owner functions. Ownership moves in two steps. Rotating the settler voids every unclaimed voucher signed by the old key.

Vault address:launch soon

Payout tokens

The vault pays in 11 Robinhood stock tokens on Robinhood Chain, each an ERC-20 with 18 decimals. Links open the token on the explorer.

• Samsung has no stock token on Robinhood Chain, so its slice is paid in EWY, a South Korea ETF.
• The SKHY token tracks SK hynix depositary shares. Siliq's reference quote is the Korea Exchange common share in dollars, and the operator can pin a settlement price when the two do not match one to one.
• Before launch there is no vault to read. After launch, /vault shows its balances read from the chain.

$SILQ decides whether a run gets paid. Hold at least $25 of it in the wallet you mine with, sign a pass, and your runs earn. Hold more to mine on more GPUs with a higher multiplier. Rewards arrive as stock tokens from the vault; Siliq never pays in $SILQ.

• Siliq values your holding at the price of the deepest $SILQ trading pair.
• After launch, a headless node needs the same $25 minimum to register.
• No $SILQ contract exists yet. An address posted before launch belongs to someone else. Siliq posts the real one on this site and on X at @siliq.

$SILQ contract:launch soon

The server and the vault contract enforce the first list. The second list is open, and you should weigh it before you mine, hold $SILQ or build on the API.

The roadmap lists the fixes in order, and the open dataset marks every run with its mode.

One base URL in OpenAI request and response shapes. Miners' tabs and headless nodes answer the open models. Frontier models are answered by their maker, on your own key. Every answer says who wrote it.

$SILIQ/api/v1

In every sample on this page, $SILIQ stands for the origin of this site: the scheme and host in your address bar, without a path. Set it once with export SILIQ=https://<this host>. CORS is open on every /api/v1 route, so a web page can call them.

Authentication

Endpoints

First call

curl -X POST $SILIQ/api/v1/chat/completions \
  -H 'content-type: application/json' \
  -d '{"model": "smol-360m",
       "messages": [{"role": "user", "content": "What does a foundry do?"}]}'

{
  "id": "chatcmpl-...",
  "object": "chat.completion",
  "model": "smol-360m",
  "choices": [{ "index": 0,
                "message": { "role": "assistant", "content": "..." },
                "finish_reason": "stop" }],
  "usage": { "prompt_tokens": <int>, "completion_tokens": <int>, "total_tokens": <int> },
  "siliq": { "served": "miner", "gpu": "...", "tokens": <int>, "ms": <int>,
             "prefillMs": <int>, "job": "...", "poll": "/api/v1/inference/...",
             "verified": null }
}

The siliq block is the part OpenAI does not send. The model field names the model that wrote the answer, so an alias resolves to its real id.

served

miner or node for open models; anthropic or deepseek for frontier models, which add servedBy with the provider's model name.

gpu

Device label of the GPU that wrote the answer.

tokens, ms

Tokens written and total time on the GPU in milliseconds.

prefillMs

Time the GPU spent reading the prompt.

job, poll

The queue job and the URL that returns it for 24 hours.

verified

null until a recheck runs, then true when a second GPU wrote the same text, false when it did not.

curl -X POST $SILIQ/api/v1/chat/completions \
  -H 'content-type: application/json' \
  -H 'x-provider-key: sk-...' \
  -d '{"model": "claude-opus-5", "stream": true,
       "messages": [{"role": "user", "content": "Explain EIP-712 in two lines."}]}'

Streaming

Send "stream": true and the answer arrives as server-sent events in OpenAI chunk shape, ending with data: [DONE].

• Open models stream what the worker has decoded so far. Workers post partial text about once a second.
• While a prompt waits, a comment line arrives every 5 seconds: : waiting for a gpu, then : decoding once a GPU holds it.
• The last chunk carries usage and the siliq block. If the finished answer differs from the streamed partial, that chunk carries the full answer with "replace": true.
• Frontier models stream token by token from the provider.

data: {"id":"chatcmpl-...","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}

: waiting for a gpu

data: {"id":"chatcmpl-...","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"A foundry"},"finish_reason":null}]}

data: {"id":"chatcmpl-...","object":"chat.completion.chunk","choices":[{"index":0,"delta":{},"finish_reason":"stop"}],"usage":{...},"siliq":{...}}

data: [DONE]

Timeouts and the queue

• chat/completions waits 45 seconds for a GPU. After that it answers 504 with timeout_queued or timeout_running, the job id and a poll URL. The prompt stays in the queue.
• inference waits 25 seconds, then answers 202 with the job. Poll GET /api/v1/inference/{id}.
• A model with no GPU online still takes prompts; they wait in its queue, up to 200. A full queue answers 503 queue_full.

Models

Leaving model out picks smol-360m. Siliq also accepts the names smollm2-135m, smollm2-360m, smollm2-1.7b, deepseek-r1-distill-qwen-1.5b, qwen3, opus and sonnet. GET /api/v1/models reports how many workers serve each open model right now.

Limits

Parameters Siliq ignores

chat/completions reads model, messages, stream, max_tokens and max_completion_tokens. It drops every other field without an error, including temperature, top_p, stop, n, seed, tools, tool_choice and response_format. Tool calls and JSON mode do not exist. messages must end with a user turn, and content can be a string or an array of text parts.

Errors

Errors come back as {"error": {"code": "...", "message": "..."}} with a string code you can branch on.

Buying a key

A Siliq key lifts the hourly limit and the answer length on open models. Frontier models run on your provider key and need no Siliq key.

1. 01
   GET /api/v1/keys. It returns the pay-to address, the minimum, the ETH price and how many credits a dollar buys.Pay-to address:launch soon
2. 02
   Send at least 0.001 ETH on Robinhood Chain to the pay-to address.
3. 03
   Sign the payment message below with the wallet that sent the ETH. The signature proves the payment is yours, so a stranger who sees the transaction cannot claim it first.
4. 04
   POST /api/v1/keys with {"txHash": "0x...", "signature": "0x..."}. Siliq checks both on chain and returns the key once. It stores a hash of the key and cannot show it again.
5. 05
   Send the key as authorization: Bearer silq_... on every call. GET /api/v1/keys/me shows the credits left.

Siliq payment

I sent this transaction and want to use it on Siliq.

0x<your transaction hash>

Credits equal the ETH sent × the ETH price in dollars × 1,000. A prompt costs 1 to 8 credits depending on the model. One transaction pays for one key or one render job. Before launch the pay-to address does not exist and POST /api/v1/keys answers 503 prelaunch.

Greedy decoding and rechecks

Open models use greedy decoding, with no temperature and no sampling. The same prompt on the same weights gives the same tokens, so a second GPU can check the first.

• Siliq replays one in four miner answers on a second miner GPU, never the one that wrote the original, and marks the original verified when the two texts match character for character.
• You can ask for a recheck of any finished miner answer. Poll the job afterwards for verified and verifiedBy.
• Tabs and nodes load different weight files, so a recheck comes from the same kind of worker. Node and frontier answers are not cross-checked.
• A match shows two GPUs agree. It says nothing about whether the answer is correct.

curl -X POST $SILIQ/api/v1/inference/<job>/verify
curl $SILIQ/api/v1/inference/<job>     # "verified": true | false, "verifiedBy": "<gpu>"

SLQ-03 is a path tracer. A render job buys frames of a seeded scene from the miners running it. Render jobs open at launch, with the pay-to address.

1. 01
   Send at least 0.002 ETH on Robinhood Chain to the pay-to address.
2. 02
   Sign the same payment message as for a key, with the wallet that sent the ETH.
3. 03
   Post the transaction hash, the signature and a scene seed on /jobs, or to POST /api/jobs with an optional title of up to 48 characters.
4. 04
   Miners on SLQ-03 take the oldest open job. Each GPU delivers one frame every 15 seconds, as WebP or JPEG under 180 KB.
5. 05
   The job closes when the paid frames have arrived. The board keeps the latest 24. GET /api/jobs/{id} returns the job and its frames.

A browser tab holds a small model. A machine with more memory can serve bigger ones from its own Ollama through silq-node.mjs. The client reads your key from a file so it stays out of shell history, signs one login message, and talks to Siliq and Ollama and nothing else.

curl -O $SILIQ/silq-node.mjs
curl -O $SILIQ/silq-node.sha256
sha256sum -c silq-node.sha256          # macOS: shasum -a 256 -c silq-node.sha256
npm i viem
ollama pull qwen3:8b
PRIVATE_KEY_FILE=~/.siliq/key node silq-node.mjs --models=qwen3-8b --base=$SILIQ

The key file holds one 0x-prefixed private key. Use a wallet made for the node, and on macOS or Linux run chmod 600 on the file. To register, the node asks the server for a nonce and signs this message. The client refuses to sign any other text.

Siliq node

Register a headless node for this wallet.
Signing sends no transaction.

wallet: 0x<node wallet>
nonce: <nonce>

• The node token lasts 7 days, and the client renews it before it expires.
• After launch the node wallet must hold $25 of $SILQ.
• The client refuses Ollama cloud models. Every answer comes from weights on your machine.
• A node pulls prompts from POST /api/v1/inference/pull and posts partial text about once a second to POST /api/v1/inference/{id}/result. A job lease lasts 90 seconds; a node that goes quiet hands the prompt back to the queue.

Every verified run in one file, as CSV or JSON lines. The file carries no wallets, no IP addresses, no run tokens and no dollar amounts. Responses are cached for 10 minutes, and CORS is open.

curl "$SILIQ/api/dataset?format=csv"     # CSV with a header row
curl "$SILIQ/api/dataset?format=json"    # JSON lines, one run per line

Before launch every row has mode genesis. Filter on mode to keep them apart from paid runs later. Download it from /api/dataset.

run

One session of 15, 30 or 60 minutes in which your tab keeps the GPU busy with one instrument and reports a sustained score.

instrument

One of the 5 workloads, SLQ-01 to SLQ-05. Each measures one thing about the card in its own unit.

sustained score

The throughput a GPU holds across the whole run, after the ceiling.

ceiling

The highest score Siliq accepts from one vendor family on one instrument.

SCU

Siliq compute unit. 28 teraflops on SLQ-01, 18 GB moved on SLQ-02, 45,000 megapaths on SLQ-03, 9 teraflops on SLQ-04, 5 teraflops on SLQ-05.

lineage

Who designed the chip, who manufactured it, who made its memory. It decides which stock tokens a run pays in.

genesis run

A run before $SILQ launches. Scored and listed, not paid.

trial

One free run per address after launch. Scored and listed, not paid.

pass

A signed message, no transaction, from a wallet holding at least $25 of $SILQ. It lasts 24 hours.

tier

etch, stack, tape-out. Set by your holding; decides the multiplier and how many GPUs mine at once.

cycle

A 6 hour window. Runs add up inside it and settle together when it closes.

voucher

A settler signature listing the tokens and amounts a wallet earned in one cycle. You redeem it on chain.

settler

Siliq's signing key for vouchers. It lives on the server; treat it as a hot key.

governor

The rule that scales payouts toward 1.2% of the vault per day.

vault

SiliqVault, the contract on Robinhood Chain that holds the stock tokens and pays vouchers.

node

A machine running silq-node.mjs that serves open models from a local Ollama. Unpaid for now.

$SILIQ

In code samples, the origin of this site.

Siliq has one public account: @siliq on X. Announcements, answers and the contract addresses at launch all go there first.

What Siliq keeps about you is on /privacy. What it can and cannot promise is on /terms.