How Arcium works

Everything you deploy on Arcium is an MXE, a Multi-Party eXecution Environment, which the docs describe as your complete encrypted application and the network's equivalent of a virtual machine. An MXE is three things stapled together: a normal Solana program that acts as the on-chain coordinator, a set of encrypted instructions (confidential logic written in Arcium's Rust-based Arcis framework, where each #[instruction] function compiles to MPC bytecode stored in an on-chain comp def account) and an MXE account holding metadata: which cluster runs the workload, and the x25519 public key that clients encrypt against.

The split of labor is the architectural core. Solana is the coordination layer: per the docs, all state management and orchestration of computations happen on-chain: deterministic ordering through a single decentralized mempool with priority-based execution, node registration and scheduling, verification of results, and the economics of payments, staking, and slashing. The heavy cryptographic lifting happens elsewhere: Arx nodes are off-chain decentralized computational workers that pull jobs from the chain, execute them in MPC, and post signed results back. Here's the full round trip a single confidential computation makes.

Collectively, those Arx nodes form arxOS, the distributed encrypted operating system ("arx" is Latin for fortress). What's striking is how ordinary the hardware is: no GPUs, no secure enclaves, just commodity servers running a Docker image, staking collateral that can be slashed for violations.

Nodes are organized into clusters, the units that actually execute MXE workloads. Clusters are owner-proposed: a node cannot join unless the cluster owner has proposed it first, and the node must accept. Owners configure capacity and a Node Priority List that governs activation order, and clusters can include randomly selected nodes for sybil resistance. The docs don't fix a cluster size; the localnet minimum is two nodes.

Work itself is metered in CUs, or Computation Units, the smallest unit of computation on the network; every arithmetic operation in a circuit has a CU cost. The price of a CU is a base fee set each epoch by a stake-weighted vote of node operators, plus an optional market-driven priority fee. The docs don't publish absolute CU prices, only this mechanism. And epochs are the network's clock: fixed-duration periods that frame the base-fee vote, stake activation, reward distribution, and unbonding cooldowns. Every computation must complete within a single epoch. The docs don't publish the epoch duration either; the live explorer currently reports 12-hour epochs on mainnet (an observed value, not a documented one).

Sources: docs.arcium.com/…/core-concepts · docs.arcium.com/…/computation-lifecycle · docs.arcium.com/…/architecture-overview · docs.arcium.com/…/pricing-and-incentives

Sources: docs.arcium.com/…/mpc-protocols · docs.arcium.com/…/arcis/mental-model · docs.arcium.com/developers/encryption · Arcium Purplepaper

You don't write secret-sharing protocols to build on Arcium. You write Rust. Arcis is the framework that makes that possible: code inside an #[encrypted] module compiles into fixed MPC circuits that a cluster of Arx nodes executes over encrypted data. The rest of the project looks deliberately familiar to a Solana developer: an MXE project is a normal Anchor workspace plus an Arcium.toml config and an encrypted-ixs/ directory holding the Arcis code, and the arcium CLI is, per the docs, a wrapper over the Anchor CLI.

The core abstraction is the encrypted type Enc<Owner, Data>, which encodes who can decrypt directly in the type system. Enc<Shared, T> is encrypted under a secret shared between the client and the MXE, so both can decrypt; Enc<Mxe, T> is decryptable only by the MXE cluster itself: the docs' tool for private shared state, like an order book no individual user should be able to read. Inside a circuit, .to_arcis() turns ciphertext into secret shares, .from_arcis() seals a result back to an owner, and .reveal() deliberately makes it public. Step through the canonical example below and the whole Hello World of encrypted computing fits in under twenty lines.

1use arcis::*;
2 
31#[encrypted]
4mod circuits {
5    use arcis::*;
6 
7    pub struct InputValues {
8        v1: u8,
9        v2: u8,
10    }
11 
12    #[instruction]
132    pub fn add_together(input_ctxt: Enc<Shared, InputValues>) -> Enc<Shared, u16> {
143        let input = input_ctxt.to_arcis();
154        let sum = input.v1 as u16 + input.v2 as u16;
165        input_ctxt.owner.from_arcis(sum)
17    }
186}

On the client side, the @arcium-hq/client TypeScript library handles the cryptography. The app generates an x25519 keypair, fetches the MXE's cluster public key, and derives a shared secret via Diffie-Hellman. Values are then encrypted with RescueCipher, the cipher whose decryption runs inside the MPC itself, as explained in section 02 using a 16-byte nonce and one 32-byte ciphertext per value. Queueing is just an Anchor method call with PDA helpers for the mempool, cluster, and computation accounts; then awaitComputationFinalization waits for the cluster to execute and the callback to land, and the client decrypts the result from the program event. Each encrypted instruction turns into three program instructions: one to initialize its comp def, one to queue, one callback.

Those comp defs (computation definitions) are on-chain accounts storing the compiled MPC circuit for each instruction, addressed by the first four bytes of the SHA-256 of its name. Compiled circuits can reach several megabytes, so the docs recommend off-chain circuit storage for large ones; the comp def then holds a URL plus a circuit_hash! that Arx nodes verify when they fetch the code.

The honest trade-off: because circuits are fixed before any data flows through them, Arcis is not quite general-purpose Rust. Anything whose shape depends on secret data has to be paid for in full, up front:

These constraints are the price of the guarantee from the previous section: a circuit whose execution pattern never depends on the data can't leak the data through its execution pattern. For most confidential-DeFi and gaming logic (comparisons, arithmetic, fixed loops over fixed arrays), they turn out to be workable rules rather than blockers.

Sources: docs.arcium.com/…/arcis · docs.arcium.com/…/hello-world · docs.arcium.com/…/js-client-library · docs.arcium.com/…/arcis/operations

ARX is not a gas token. Its live job is collateral: per the official tokenomics page, ARX is what operators put up to provide compute, and the more a node stakes, the more computational capacity it may offer: the docs describe a near-linear stake-to-capacity relationship, gated by a minimum self-delegation. Anyone else can delegate ARX to a node via stake.arcium.com: stake activates at the next epoch, rewards are shared pro-rata minus the operator's commission (auto-compounding supported), and unstaking triggers a one-epoch cooldown. Two governance tracks (a technical one for node operators and a lock-weighted community one) are announced for later in 2026 but not live yet.

The part that surprises people: computation fees are not paid in ARX. Arcium's tokenomics page is explicit that customers pay in the chain's native token (SOL on Solana), and you can see this live on the computations page, where every job carries its fee in lamports plus a callback reserve. Fees have two parts: a base fee set at a minimally economically viable level to cover operator costs, and optional priority fees for jumping the queue, distributed equally to each participating node. The value link back to ARX is indirect: usage generates SOL income for staked operators, which drives demand for ARX as capacity collateral; there is no buyback or auto-conversion mechanism described in official materials.

Supply is simple by design: 1,000,000,000 ARX, fixed: no inflation, no dynamic minting. The token generated on June 22, 2026, debuting on Binance Alpha with same-day listings on MEXC, Bitget, KuCoin and BingX, and about 208.8M ARX (20.88%) circulating from day one. Before that, a CoinList community round (March 24 to April 1, 2025) sold 20M tokens at $0.20 (a $200M FDV), raising $4M, fully unlocked at TGE. Launch trading opened around $0.40-0.43, roughly a $400M fully diluted valuation. Here's where the billion tokens go, per the announced tokenomics:

The vesting design front-loads community and ecosystem float and locks insiders hard: every backer, team, angel and validator token sits behind a 12-month cliff, so between July 2026 and June 2027 the circulating supply barely moves. Then the cliffs end all at once (June 22, 2027 is the single biggest date on the schedule) and monthly linear vesting runs for 18 to 42 months per pool, stretching full unlock into 2030. Meanwhile the staking loop below is what the token actually does day to day: collateral in, compute out, SOL fees back, and slashing as the backstop that makes a stranger's node worth trusting.

Sources: arcium.com/tokenomics · docs.arcium.com/…/staking/overview · docs.arcium.com/…/pricing-and-incentives · coinlist.co/arcium