> ## Documentation Index
> Fetch the complete documentation index at: https://docs.arcium.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Core concepts

> Key terminology for Arcium development: MXE, Clusters, Encrypted Instructions, Computation Definitions, offsets, and how they connect

Key terms you'll encounter throughout Arcium development.

<CardGroup cols={1}>
  <Card title="MXE (MPC eXecution Environment)" href="/multi-party-execution-environments-mxes/overview">
    Your complete encrypted application composed of three parts:

    * A **Solana program** that receives inputs and queues computations
    * **Encrypted instructions** with encrypted logic written in Arcis
    * An **MXE account** storing onchain metadata like cluster selection and the MXE's public key

    When no longer needed, MXE accounts can be closed through the [account lifecycle](/developers/program/account-lifecycle).
  </Card>

  <Card title="Cluster" href="/clusters/overview">
    A group of Multi-Party Computation (MPC) nodes that execute your encrypted instructions. You choose
    which cluster when deploying your MXE. The selection is made at deployment time
    but can be changed later via [`arcium migrate-cluster`](/developers/deployment#cluster-migration).
    Each cluster has a numeric `cluster_offset` identifier (e.g., `456` on devnet)
    that you specify during [deployment](/developers/deployment).
  </Card>

  <Card title="Encrypted instruction" href="/developers/arcis">
    Your encrypted business logic written in **Arcis** (Rust framework) that
    executes on encrypted data via MPC. Mark functions with the `#[instruction]`
    macro to designate them as encrypted instructions. Examples: vote counting,
    order matching, sealed-bid auctions.
  </Card>

  <Card title="Arcium program" href="/developers/program">
    The onchain coordinator on Solana that orchestrates MPC computations, routes
    work to clusters, and manages callbacks and finalization. You interact with it
    via **CPI** (Cross-Program Invocation) from your Solana program.
  </Card>

  <Card title="Computation definition" href="/developers/program/computation-def-accs">
    An onchain account storing compiled MPC bytecode. Created once per
    encrypted instruction, it contains the compiled circuit from your Arcis
    code and must be initialized via `init_computation_def()` before first use.
    When no longer needed, a computation definition has its own [close lifecycle](/developers/program/account-lifecycle).
  </Card>

  <Card title="Computation" href="/developers/computation-lifecycle">
    A single execution instance of an encrypted instruction. You generate a random
    `computation_offset` (u64) per invocation to uniquely identify it. The computation
    tracks execution status and stores encrypted results until callback.
  </Card>

  <Card title="Arx node" href="/arx-nodes/overview">
    An MPC execution node that participates in cluster computations. Each node
    holds secret shares and collaborates via the MPC protocol. Clusters contain
    multiple Arx nodes. The dishonest majority model means privacy holds even
    if all but one node are compromised.
  </Card>
</CardGroup>

<Frame caption="How core concepts relate: MXE programs queue computations via Arcium, which routes to clusters for execution">
  ```mermaid theme={null}
  graph TD
      A[MXE Program] -->|queues computation| B[Arcium Program]
      A -->|references| C[MXE Account]
      B -->|routes to| D[Cluster]
      D -->|executes| E[Encrypted Instructions]
      D -->|returns result via callback| A
  ```
</Frame>

## Offset identifiers

Arcium uses numeric offsets to identify onchain resources. You'll encounter these throughout the SDK:

| Offset               | Type  | Purpose                                                       | How it's set                                                                                 |
| -------------------- | ----- | ------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| `cluster_offset`     | `u32` | Identifies which cluster your MXE connects to                 | Chosen at [deployment](/developers/deployment) (e.g., `456` on devnet)                       |
| `computation_offset` | `u64` | Uniquely identifies a single computation invocation           | Generated randomly per invocation (`randomBytes(8)`)                                         |
| `comp_def_offset`    | `u32` | Identifies a computation definition (circuit) within your MXE | Via `comp_def_offset("instruction_name")`, which computes `sha256(name)` truncated to LE u32 |

## What's next?

<CardGroup cols={2}>
  <Card title="Computation Lifecycle" icon="rotate" href="/developers/computation-lifecycle">
    Understand how computations flow from queue to callback
  </Card>

  <Card title="Write Encrypted Instructions" icon="code" href="/developers/arcis">
    Learn Arcis and write encrypted business logic
  </Card>
</CardGroup>