Introduction
Blockchains today work like postcards, where everything is visible to everyone. Arcium is changing this through its confidential computing network built on Solana that allows programs to process sensitive data without ever exposing it. Not even the nodes doing the computation can see the data involved or decrypt it. Arcium is a privacy layer that doesn't sacrifice verifiability or decentralization. Whether you're a curious newcomer or a developer ready to build on Arcium, this guide breaks down what Arcium is, how it works, and how to build with it.
The Rookie's Guide to Arcium
What Exactly Is Arcium?
Arcium is a decentralized confidential computing network that enables encrypted computation on-chain. This means data stays encrypted even while it's being processed. With normal computing, you lock your valuables in a safe, take them out to count them, then put them back. But with Arcium, you count the valuables while they're still locked in the safe. This is made possible by a cryptographic technique called Multi-Party Computation (MPC).
Multi-Party Computation (MPC)
MPC is one of the core technologies behind Arcium. To understand this quickly, imagine three people (Alice, Bob, and Carol) who know one piece of a secret recipe. Since the three of them want to bake the cake together without any of them learning the others' ingredients. MPC allows them to combine their secret pieces and produce the final cake (the result) without any single person ever seeing the full recipe. Arcium runs this computation through special virtual machines that give the developer the freedom to customize their preferences.
In Arcium's case, your data is the secret recipe, while Alice, Bob, and Carol are the Arcium nodes processing the transactions. These nodes run on arxOS, the operating system that powers the set of arx nodes and clusters.
None of them can see the value of the data in the process. They only handle encrypted fragments called shares. The computation result is the cake that comes out of the cooperation of the nodes on Arcium.
How Solana Dapps Work through Arcium
Arcium is not a blockchain in itself. It uses Solana to handle:
- Task scheduling and coordination
- Settlement and verification of computation results
- Staking, incentives, and penalties (such as slashing).
This means your Solana dApp can call Arcium computations the same way it calls any other program. This makes privacy composable with everything else in the Solana ecosystem.
What Problem Does Arcium Solve?
Blockchain's biggest selling point, in its transparency, is also its biggest limitation for real-world adoption. Think about what you'd need to put on-chain for these use cases:
- Healthcare: Patient medical records
- Finance: Portfolio positions, trading strategies
- Gaming: Hidden game states, player strategies
- Voting: Private ballots that are verifiable
- AI/ML: Proprietary model weights and training data
None of these can be fully deployed on a public blockchain today without exposing sensitive information to the entire world. The current traditional solutions force you to choose between:
- Privacy or decentralization
- Privacy or verifiability
- Privacy or composability
With Arcium, we don’t have to choose. We can have all. The following are applications with the need for native privacy that Arcium can be used to build:
- DeFi: Arcium can be used to create hidden order b ooks that settle DeFi dark pools and sealed-bid auctions.
- Healthcare: Research on patient data without exposure to the details involved with the medical analysis.
- Governance: People vote privately using verifiable secret ballots that Arcium can help power.
- Enterprise: In B2B data sharing, organizations can collaborate on data without exposing it
- AI: Arcium can be used to process private ML inferences without leaking information.
The Arcium (MPC) Voting Program
This is the confidential part of the app that runs inside Arcium’s MPC environment and never sees raw, individual votes.
// arx_programs/private_voting/src/lib.rs
use arx::prelude::*;
/// Private tally: takes encrypted yes/no votes and returns a public tally.
#[arx_program]
pub mod private_voting {
use super::*;
// Encrypted votes are 0 (no) or 1 (yes)
pub fn tally_votes(
_ctx: Context<TallyVotes>,
votes: Vec<EncryptedInput<u8>>,
) -> Result<PublicOutput<VoteResult>> {
// yes and no stay "hidden" during the entire computation
let mut yes: EncryptedValue<u64> = EncryptedValue::zero();
let mut no: EncryptedValue<u64> = EncryptedValue::zero();
for v in votes {
// v is still encrypted here
yes = yes + v.cast::<u64>();
// "1 - v" (still in encrypted form) counts "no" votes
no = no + (1u8 - v).cast::<u64>();
}
// Only reveal the **final totals**, not each individual vote
Ok(PublicOutput::new(VoteResult {
yes: yes.reveal(),
no: no.reveal(),
}))
}
#[derive(AnchorSerialize, AnchorDeserialize)]
pub struct VoteResult {
pub yes: u64,
pub no: u64,
}
#[derive(Accounts)]
pub struct TallyVotes {}
}
What this shows is that:
- The inputs are EncryptedInput<u8>.
- Computation happens on encrypted values.
- Only the final yes / no counts are revealed.
Let’s look at another component that complements :
A Simple Solana Program That Uses Arcium
This runs on Solana, and just stores encrypted votes and asks Arcium to tally them.
// programs/private_voting/src/lib.rs
use anchor_lang::prelude::*;
use arcium_sdk::prelude::*;
declare_id!("Vote111111111111111111111111111111111111111");
#[program]
pub mod private_voting {
use super::*;
/// Create a new proposal with a title.
pub fn create_proposal(ctx: Context<CreateProposal>, title: String) -> Result<()> {
let proposal = &mut ctx.accounts.proposal;
proposal.creator = ctx.accounts.creator.key();
proposal.title = title;
proposal.encrypted_votes = Vec::new();
Ok(())
}
/// Store an encrypted vote (0 or 1) on-chain.
pub fn cast_vote(ctx: Context<CastVote>, encrypted_vote: Vec<u8>) -> Result<()> {
let proposal = &mut ctx.accounts.proposal;
proposal.encrypted_votes.push(EncryptedVote {
voter: ctx.accounts.voter.key(),
ciphertext: encrypted_vote,
});
Ok(())
}
/// Ask Arcium to privately tally all the encrypted votes.
pub fn tally_with_arcium(ctx: Context<TallyWithArcium>) -> Result<()> {
let proposal = &mut ctx.accounts.proposal;
// Convert stored ciphertexts into Arcium inputs
let inputs: Vec<ComputeInput> = proposal
.encrypted_votes
.iter()
.map(|v| ComputeInput::encrypted(v.ciphertext.clone()))
.collect();
// Build Arcium instruction to run our MPC "tally_votes" program
let ix = arcium_sdk::instructions::queue_computation(
ctx.accounts.arcium_program.key(), // Arcium system program
ctx.accounts.cluster.key(), // cluster that will run MPC
ctx.accounts.mxe_program.key(), // our Arx program id
inputs, // encrypted votes
ctx.accounts.computation.key(), // where Arcium writes status
)?;
// CPI into Arcium
anchor_lang::solana_program::program::invoke(
&ix,
&[
ctx.accounts.arcium_program.to_account_info(),
ctx.accounts.cluster.to_account_info(),
ctx.accounts.mxe_program.to_account_info(),
ctx.accounts.computation.to_account_info(),
ctx.accounts.payer.to_account_info(),
],
)?;
Ok(())
}
/// Called by Arcium after tally is complete with the public result.
pub fn receive_result(ctx: Context<ReceiveResult>, result: VoteResult) -> Result<()> {
let proposal = &mut ctx.accounts.proposal;
proposal.yes = result.yes;
proposal.no = result.no;
Ok(())
}
}
/// On-chain proposal state
#[account]
pub struct Proposal {
pub creator: Pubkey,
pub title: String,
pub encrypted_votes: Vec<EncryptedVote>,
pub yes: u64,
pub no: u64,
}
#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
pub struct EncryptedVote {
pub voter: Pubkey,
pub ciphertext: Vec<u8>, // Encrypted 0/1
}
// ---- Accounts----
#[derive(Accounts)]
pub struct CreateProposal<'info> {
#[account(init, payer = creator, space = 8 + 32 + 64 + 4 + 100 * 64 + 8 + 8)]
pub proposal: Account<'info, Proposal>,
#[account(mut)]
pub creator: Signer<'info>,
pub system_program: Program<'info, System>,
}
#[derive(Accounts)]
pub struct CastVote<'info> {
#[account(mut)]
pub proposal: Account<'info, Proposal>,
pub voter: Signer<'info>,
}
#[derive(Accounts)]
pub struct TallyWithArcium<'info> {
#[account(mut)]
pub proposal: Account<'info, Proposal>,
/// CHECK: Arcium system program
pub arcium_program: AccountInfo<'info>,
/// CHECK: Arcium cluster account
pub cluster: AccountInfo<'info>,
/// CHECK: Our MPC program on Arcium
pub mxe_program: AccountInfo<'info>,
/// CHECK: Computation account managed by Arcium
#[account(mut)]
pub computation: AccountInfo<'info>,
#[account(mut)]
pub payer: Signer<'info>,
pub system_program: Program<'info, System>,
}
#[derive(Accounts)]
pub struct ReceiveResult<'info> {
#[account(mut)]
pub proposal: Account<'info, Proposal>,
}
/// Same struct as in the Arx program, duplicated here for convenience
#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
pub struct VoteResult {
pub yes: u64,
pub no: u64,
}
What this shows:
- Votes are stored encrypted (ciphertext: Vec<u8>).
- The Solana program never decrypts anything.
- It calls Arcium via CPI (queue_computation) to run the MPC logic.
- Arcium later calls back with a plain VoteResult { yes, no }.
Frontend: Encrypt and Submit Vote
import { ArciumClient } from "@arcium-hq/arcium-js-sdk";
import { Program } from "@coral-xyz/anchor";
async function castEncryptedVote(
program: Program, // Anchor program for `private_voting`
proposalPubkey: PublicKey,
isYes: boolean,
arcium: ArciumClient,
) {
// 1 = yes, 0 = no
const voteValue = BigInt(isYes ? 1 : 0);
// Get cluster encryption key from Arcium
const clusterKey = await arcium.getClusterEncryptionKey();
// Encrypt locally – chain never sees the raw 0/1
const encrypted = await arcium.encrypt(voteValue, clusterKey);
// Call Solana program, which simply stores ciphertext
await program.methods
.castVote(Buffer.from(encrypted))
.accounts({
proposal: proposalPubkey,
voter: program.provider.publicKey,
})
.rpc();
}
Conclusion
By bringing confidential computation to one of the fastest blockchains in the world, it opens doors to applications that were previously impossible, such as DeFi that protects trading strategies, healthcare applications that respect patient privacy and enterprise tools that enable collaboration without exposing sensitive data. The Arcium tech is no longer experimental, but it's production-ready, composable, and Solana-native.
