> For the complete documentation index, see [llms.txt](https://docs.nexus.xyz/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.nexus.xyz/architecture/architecture.md).

# Overview

Nexus is a blockchain built for programmable finance. Its architecture pairs a general-purpose smart-contract environment with a specialized, high-performance financial execution engine, under a single consensus layer and a distributed proof system — so applications get the composability of a public chain and the speed and depth of a centralized exchange.

<figure><img src="/files/yNV3n1XZiLPSVNrSyz4M" alt="The Nexus architecture stack: NexusEVM and NexusCore (with native co-processors) in the Execution layer, the Nexus zkVM verification layer, and NexusBFT consensus, with applications on top."><figcaption><p>The Nexus stack — dual-core execution, verification, and consensus.</p></figcaption></figure>

## The layers

Nexus separates **execution**, **verification**, and **consensus** while keeping a single, unified global state.

| Layer            | Components           | Role                                                                                           |
| ---------------- | -------------------- | ---------------------------------------------------------------------------------------------- |
| **Execution**    | NexusEVM · NexusCore | Runs general-purpose contracts (NexusEVM) and specialized financial co-processors (NexusCore). |
| **Verification** | Compute Network      | Progressively produces validity proofs of execution that anyone can verify independently.      |
| **Consensus**    | NexusBFT             | Orders transactions and finalizes blocks with single-slot finality.                            |

## Dual-core execution

The execution layer runs two synchronized engines:

* **NexusEVM** — an Ethereum-compatible virtual machine for general-purpose, composable smart contracts. It produces 1-second blocks and supports the standard Ethereum toolchain.
* **NexusCore** — a high-performance engine that hosts **enshrined co-processors**: native financial modules (order matching, risk, oracles, liquidations) that run deterministically at 200 ms block intervals. NexusCore powers the Nexus Exchange.

The two engines interoperate through atomic cross-core messaging, so an EVM contract and a NexusCore co-processor can act within a single, consistent transaction. This lets developers combine smart-contract flexibility with exchange-grade financial execution.

## Verification

The **Compute Network** generates validity proofs of execution using the Nexus zkVM and is live on Nexus Testnet. Proof coverage expands incrementally toward both NexusEVM and NexusCore, so any party can verify correctness without re-executing or trusting the operator.

## Consensus

**NexusBFT** is the consensus mechanism, built on CometBFT. Blocks are final when committed — there is no probabilistic finality window or reorgs.

## How execution flows

Today, a developer submits an EVM transaction; NexusEVM executes it and NexusBFT commits the block with single-slot finality. As the Nexus Exchange comes online, a trader will submit a signed order over the API; the sequencer will route it to NexusCore, which will match, update positions, and run risk checks at 200 ms intervals; NexusBFT will commit the block and the Compute Network will prove the batch.

## Design principles

* **Performance** — financial operations execute deterministically at 200 ms; the architecture targets centralized-exchange-grade throughput and latency.
* **Composability** — NexusEVM, NexusCore, and every co-processor interoperate within single transactions.
* **Extensibility** — new co-processors can be added without changing consensus.
* **Verifiability** — execution is provable and independently checkable.

Explore each component: [NexusCore](/architecture/nexuscore.md) · [NexusEVM](/architecture/nexusevm.md) · [NexusBFT](/architecture/nexusbft.md) · [Compute Network](/architecture/compute-network.md).


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.nexus.xyz/architecture/architecture.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.