Whitepaper

Siliq measures sustained work on consumer GPUs from a browser tab and pays for it in tokenized equities of the companies that made each GPU. 5 WebGPU instruments convert throughput into a common unit, the Siliq compute unit (SCU). A server issues signed run tokens, caps scores at per-vendor ceilings and accrues dollar rewards. Every 6 hours a settler converts those rewards into token amounts and signs them as EIP-712 vouchers, which a contract on Robinhood Chain pays from 11 stock tokens it holds. The same GPUs serve an OpenAI-compatible inference queue, and payments for API keys and render jobs refill the vault. A utility token, $SILQ, gates paid runs. This paper states the formulas and constants in the code, and it lists what the system does not verify yet.

A GPU is the product of a short supply chain. One company designs the chip, a foundry manufactures it, and a memory maker supplies the DRAM beside it. Packaging houses and toolmakers finish the part. Most of these companies are listed, and Robinhood Chain carries tokenized versions of their shares as ERC-20 tokens.

Siliq connects the two. A GPU owner lends the card to a browser workload, the server verifies the run within stated limits, and the reward is split across the tokens of that card's makers. The design goals:

• Nothing to install. A desktop browser with WebGPU is enough, and WebGL2 covers one instrument.
• Rewards held, never printed. Every payout comes from tokens a public vault already holds.
• Stated limits. Each check the system performs, and each one it does not, is written down.
• Useful work. The GPUs that run instruments also answer prompts and render frames for paying users.

Siliq has five parts: the browser client, the API server, the settler, the vault contract, and the workers that serve inference. The server runs on Vercel and keeps shared state in Upstash Redis. One run moves through seven stages.

Inference runs beside this loop. Open-model prompts wait in a queue per model. A miner tab running SLQ-05, or a registered headless node, pulls a prompt for a model it holds in memory, decodes it and posts the text back. Frontier models skip the queue and go to their provider on the caller's key.

Each instrument is a WGSL compute workload with its own unit. The client reports the sustained score, the throughput held across the run, and the server converts it into work.

W   = s′ × 60 × L
SCU = W ÷ wᵢ

3.1 Calibration

The weights w_i are set so a minute on one card earns about the same on every instrument. Table 3 applies formula (1) to scores measured on one RTX 5060 Ti over a 15 minute run. The five results land within 4% of each other.

3.2 SLQ-01 in detail

SLQ-01 runs a dependent chain of fused multiply-add passes over 1,048,576 vec4 lanes at fp32, 16 MB resident. Each pass reads the output of the one before, so the GPU cannot skip ahead or reuse a cached result. The client waits on queue.onSubmittedWorkDone() between passes, and where the adapter supports timestamp queries, the GPU's own clock times the work.

The client reports vendor, architecture, device and description from WebGPU, or the unmasked renderer string from WebGL2. The server matches these strings against vendor patterns in a fixed order (NVIDIA, Apple, AMD, Intel, Qualcomm, Arm) and falls back to unknown. It then names the family, process node and memory type where it can. The split depends on the vendor alone.

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

5.1 Run tokens

A run token is the base64url JSON of the run's claims (run id, instrument, length, start time, hashed address, country, wallet, tier, mode, vendor, device label, family, graphics API) followed by an HMAC-SHA256 of that body under a server secret. The server accepts one completion per run id; a second returns 409.

5.2 Timing and ceilings

60 × L − 20  ≤  t  ≤  60 × L + 900
s′ = min(s, C_v,i)

5.3 Gates

• 5 runs an hour per address, where an address is an HMAC-SHA256 of the IP, truncated to 24 hex characters.
• After launch, one free trial per address, scored and not paid.
• A paid run needs a pass: a signed message from a wallet holding at least $25 of $SILQ, valid 24 hours. The holding is read at issue, at run start (the lower value sets the tier) and at completion (below the minimum, the run is recorded unpaid).
• The tier caps concurrent runs per wallet: etch 1, stack 2, tape-out 4.
• The client records time spent hidden; the result flags runs hidden more than 2% of their length.

5.4 Inference checks

Open models use greedy decoding, so identical weights and prompts give identical tokens. After a miner answers, the server enqueues a replay with probability 1/4. The replay goes to a different worker of the same kind, and the original is marked verified when the two texts match character for character. Anyone can request a replay of a miner answer, 10 an hour per address. Node and frontier answers have no replay path.

5.5 Threats

R = (b + u × SCU) × m × g

6.1 Upper bound per run

With s′ at the ceiling, a 60 minute run at tape-out (×1.5) and g = 1 earns at most the amounts in Table 7.

6.2 Governor

Let V be the dollar value of the vault at settlement and O_c the total owed in cycle c. The budget targets 1.2% of V per day.

B_c      = V × 0.012 × 6 ÷ 24
r_c      = min(1, B_c ÷ O_c)
paid     = owed × r_c
g_next   = max(0.1, r_c)

Settlement pays each amount in the cycle scaled by r_c. The value g_next is stored and applied to rewards recorded during the following cycle.

6.3 Per-token cap

cap_t   = balance_t × price_t × 0.004
scale_t = min(1, cap_t ÷ P_t)

6.4 Vouchers

For each wallet and token, the settler divides the scaled dollar amount by the token's settlement price and writes the result with 18 decimals. It signs the typed struct below, stores the voucher, and anchors keccak256 of the cycle report with closeCycle.

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

SiliqVault holds the payout tokens and pays vouchers. It has no imports, no proxy and no upgrade path. It is built with solc 0.8.28, optimizer on at 200 runs, EVM version shanghai, and deploys for about 1.3M gas.

deposit

Anyone deposits an ERC-20 with a memo. Deposited records the amount received. Tokens sent with a plain transfer are held without the event.

closeCycle

Callable by the settler. Anchors a report hash, once per cycle. The contract does not check vouchers against it.

claim

Checks a 65-byte settler signature with low s, that the voucher names msg.sender, at most 16 tokens, and one claim per wallet per cycle.

setSettler

Callable by the owner. Voids every unclaimed voucher signed by the old key.

transferOwnership, acceptOwnership

Owner handover in two steps.

sweep

Callable by the owner. Moves any token out of the vault.

Vault address: SiliqVault:launch soon

The vault refills from deposits by anyone and from payments for API keys (from 0.001 ETH) and render jobs (from 0.002 ETH), which Siliq converts into stock tokens. Each deposit is a public event.

$SILQ gates paid runs and node registration. Rewards never pay in $SILQ. A wallet's holding is its balance times the price of the deepest $SILQ trading pair.

Supply, allocation and trading venue are not set in the code this paper describes. The contract address is not published yet: $SILQ:launch soon

9.1 Shipped by September 17, 2026

Five instruments with a WebGL2 fallback, lineage detection, signed run tokens with ceilings and limits, the live feed, leaderboard, GPU table and open dataset, the vault contract source, the settlement signer, the inference API with streaming and rechecks, frontier models on the caller's key, paid keys and render jobs (active at launch), the headless node client and wallet login. The roadmap keeps the live list.

9.2 Next

• $SILQ launch and vault deployment.
• Spot-checked kernels with server-issued seeds.
• Vault ownership to a multisig.
• Paying headless nodes, once node work has a verification path.
• Transcription and image endpoints, sponsor deposits by ticker, mobile GPU instruments.

9.3 Risks

Contract

SiliqVault is tested by our own tests alone and has no external audit.

Keys

The settler is a hot key, and one owner key controls the vault until a multisig takes over.

Verification

The open items in Table 6 let a modified client earn more than its work, up to the ceiling.

Market

Stock tokens follow listed equities and ETFs and can lose value after you claim them. Rewards convert at settlement quotes.

Issuer and chain

A third party issues the stock tokens on Robinhood Chain. Siliq controls neither the tokens nor the chain.

Regulation

Tokenized equities and $SILQ can be restricted where you live, and rules can change.

Hardware

Long runs heat the GPU and draw power. Electricity can cost more than a run earns.

Availability

Price feeds, RPC endpoints and hosting can fail and delay settlement.