Introduction

What is Syndicate?

With Syndicate, developers can easily build custom application-specific blockchains (appchains) with programmable, atomically composable, onchain sequencers. Unlike general-purpose chains where applications pay for shared blockspace, appchains using Syndicate give developers and their tokenized communities complete control and ownership over the network, sequencer, and economy. Using Syndicate, developers can also build custom transaction ordering rules, enshrined protocols, and economic systems where value flows directly back to their tokenized communities onchain.

Appchains use programmable sequencer contracts on Syndicate Chain that can be customized to their applications and ecosystems — by changing their transaction ordering rules, sequencer permissions, models for value creation/capture/distribution, and more through simple smart contract module updates.

With Syndicate, appchains can leverage any rollup framework (e.g., Arbitrum Orbit, OP Stack) and EVM settlement layer (e.g., Ethereum L1, Base) — giving developers maximum flexibility along with the superpowers of programmable onchain sequencers when building a chain.

* Syndicate currently supports Arbitrum Orbit Stack. Support is planned for OP Stack and other frameworks, including non-EVM frameworks.

How Does Syndicate Work?

Syndicate Appchains are a special type of blockchain that leverage programmable sequencer contracts on Syndicate Chain and consist of three main layers:

┌ ── ── ── ── ── ┐       ┌──────────────┐       ┌────────────────┐       ┌────────────────┐
|                |       │              │       │                │       │                │
|  Users &       |─────▶ │   Execution  │─────▶ │   Onchain      │─────▶ │   Settlement   │
|  Applications  |       │   Layer      │       │   Sequencing   │       │   Layer        │
|                |       │              │       │                │       │                │
└ ── ── ── ── ── ┘       └──────────────┘       └────────────────┘       └────────────────┘

1. Execution Layer: Execution environment where transactions are processed and state of the appchain is updated. Syndicate Appchains can leverage any rollup framework* (e.g., Arbitrum Orbit, OP Stack).
2. Onchain Sequencing Layer: Programmable sequencer smart contracts on Syndicate Chain that define transaction inclusion and ordering for a Syndicate Appchain. It gives developers and their communities full control over inclusion/ordering, economic mechanisms, and permissioning/governance models.
3. Settlement Layer: Blockchain that provides cryptographic security, finality, and settlement. It also hosts the appchain's gas token. Developers can choose any settlement layer that best suits their needs — whether Ethereum L1, Base L2, or another L1/L2 network.

* Syndicate currently supports Arbitrum Orbit Stack. Support is planned for OP Stack and other frameworks.

Key Benefits

Syndicate Appchains and their programmable onchain sequencers give developers and their communities unprecedented control and flexibility — while dramatically reducing their cost and complexity.

• Easy Customization of Transaction Ordering Rules: Easily customize and update transaction inclusion and ordering rules through simple smart contract module upgrades. Reduce time to market and costs by 100x.
• Custom Economic Models: Design custom economic mechanisms through transaction inclusion, ordering, permissioning, and fee structures that align value/MEV with your community.
• Lower Operating Cost (10-100x): Run appchains at a fraction of the cost of a centralized provider by moving transaction sequencing and data onchain, reducing overhead by 10x-100x through fewer nodes.
• Enshired Protocols: Enshrine protocols like oracles, verifiable random function (VRF), marketplaces, and more directly into the sequencer — unlocking new/more capabilities, value, and alignment.
• Atomic Cross-Chain Composability: Atomically compose Syndicate Appchains — different chains or shards — by including transactions in the same block with simple atomic composability modules.
• Progressively Decentralize: Progressively open control and ownership of the network to your tokenized community by easily updating to your programmable onchain sequencer's permissioning module.

Example Use Cases

Syndicate Appchains are ideal for a wide range of applications and application-centric networks, including:

Get Started

Ready to build your appchain with Syndicate?

1. Read about why Appchains are the path forward
2. Read about the Syndicate Stack to understand Syndicate's technical architecture
3. View Onchain Sequencing Modules to start customizing ordering, permissions, and economic mechanisms