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

# Architecture

> Core components and system design of Pylon's synchronous composability architecture

## System Overview

**Pylon** enables synchronous composability between appchains and their settlement layer through coordinated sequencing. The system makes cross-chain operations appear atomic to developers while handling coordination behind the scenes.

<Frame>
  <img src="https://mintcdn.com/spire/Fpc2rAFPa-Jycg4_/images/pylon/Architecture-overview.png?fit=max&auto=format&n=Fpc2rAFPa-Jycg4_&q=85&s=48394bcea98309d38d2c1ae5f0e4886e" alt="" width="1200" height="675" data-path="images/pylon/Architecture-overview.png" />
</Frame>

## Core Components

### Sync Zones

A **sync zone** is a group of appchains that can interact atomically. All chains in a sync zone share the same coordinator and settlement layer.

### Coordinator

The **coordinator** is a Pylon node that:

* Monitors all appchains and settlement layer for cross-chain calls
* Forwards calls to target chains
* Injects results back via priming transactions
* Ensures atomic execution across the sync zone

### Port Contracts

**Port contracts** are smart contracts that store cross-chain call results. They serve as the interface for accessing settlement layer data from appchains.

### Priming Transactions

**Priming transactions** are system transactions that pre-populate Port Contracts with cross-chain call results before user transactions execute.

### Forwarding Proxy Contracts

**Forwarding proxy contracts** provide a developer-friendly abstraction that routes calls to Port Contracts, allowing developers to use standard contract interfaces for cross-chain interactions.

## Transaction Flow

```mermaid theme={null}
sequenceDiagram
    actor User
    participant App as Application
    participant Pylon
    participant L2 as Settlement Chain
    box rgba(33,66,130,0.25) Appchain
        participant Appchain as Appchain
        participant Contract as Appchain Contract
        participant Port as Port Contract
    end
    
    User->>App: Initiate cross-chain call
    App->>Pylon: Submit transaction
    Pylon-->>App: Transaction received<br/>(tx hash)
    
    par Async Processing
        Pylon->>L2: Simulate cross-chain call
        L2-->>Pylon: Return result
        Pylon->>Pylon: Build superblock
        Pylon->>L2: Submit superblock
    and Polling
        App->>Pylon: Poll transaction status
        Pylon-->>App: Transaction pending
        App->>Pylon: Poll transaction status
        Pylon-->>App: Transaction successful
    end
    App-->>User: Transaction Confirmation
    
    Note over L2: Execute superblock
    Appchain->>L2: Execute<br/>settled block
    Appchain->>Port: Execute priming transaction: <br/>Populate Port with cross-chain call result
    Appchain->>Contract: Begin executing<br/> user transaction
    Contract<<->>Port: cross-chain call
    Contract-->>Appchain: Finish executing<br/>user transaction
```

## Key Benefits

* **Atomic execution** - Cross-chain operations succeed or fail together
* **No async handling** - Developers write synchronous code
* **Familiar interfaces** - Use standard contract patterns
* **Real-time data** - Always access current settlement layer state

## Next Steps

* **[Quickstart →](/pylon/quickstart)** - Deploy your first cross-chain contract
* **[Build Onchain →](/pylon/build-onchain)** - Learn to deploy and test applications
* **[Chain Setup →](/pylon/chain-setup)** - Configure your development environment