Introduction

Overview

Adrift is a survival game built on its own appchain. A custom, application-specific blockchain powered by Syndicate. You’re a lone vessel at sea. Each day, you check in to repair your ship and survive whatever the ocean throws your way. Some days bring fortune. Others, disaster. Miss a check-in, and your boat starts to fall apart. Miss too many, and you’re lost to the waves. The last vessel afloat wins.

Adrift is a gaming appchain from Syndicate. A live demonstration of what onchain sequencing unlocks for onchain games and other highly scalable onchain use cases. The objective of this demo is to provide a hands-on, end-to-end example of:

• Architecture for projects built using a Syndicate appchain
• Implementing custom sequencing logic (e.g., randomness, game mechanics)
• Leveraging modular sequencing and permissioning
• Showcasing best practices for appchain UX, embedded wallet setup, and contract integration

User Experience

Adrift is designed as a simple, interactive game that highlights:

• Onboarding: Players sign in (an embedded wallet is created for them if they're a new player) and join the game before the voyage begins.
• Survival Gameplay: Each day, players check in to repair their ship. Random events, good or bad, are triggered on every check-in, and all outcomes are enforced onchain. Miss a check-in, and you are immediately disqualified, the last vessel afloat wins.
• Transparency: All game logic, randomness, and outcomes are enforced and verifiable onchain, making gameplay fair, tamper-proof, and impossible to cheat.

Architecture

+-------------------------------------------------+
|                 Adrift Frontend                 |
+-------------------------------------------------+
+--------------------------+ +--------------------+ 
|    Wallet Integration    | |       Indexer      |
+--------------------------+ +--------------------+ 
+-------------------------------------------------+ 
|             Game Contract Factory               | 
|    +--------------------------------------+     |
|    |        Adrift Smart Contracts        |     |
|    +--------------------------------------+     |
+-------------------------------------------------+ 
+-------------------------------------------------+ 
|               Sequencer Modules                 |
+-------------------------------------------------+ 
+-------------------------------------------------+ 
|               Syndicate Appchain                |
+-------------------------------------------------+ 

Adrift demonstrates several technical patterns and features:

• Onchain Game Logic: All core game mechanics, including check-ins, outcomes, and eliminations, are executed and enforced on the appchain.
• Custom Sequencing Modules: The app interacts with programmable sequencing modules for permissioning, transaction ordering, and randomness—enabling logic that is impossible on traditional chains.
• Randomness Integration: Randomness is injected by the sequencer and enforced onchain, making outcomes tamper-proof and removing the possibility for players to game the system.
• Smart Contract Factory: Game contracts are deployed and managed via a factory pattern for extensibility and modularity.
• Real-time Indexer: An indexer reads onchain data and exposes it to the frontend for live updates and transparency (e.g., Ponder (used in this demo), Index Supply, The Graph, Goldsky).
• Wallet Integration: Frictionless embedded wallet setup and seamless chain interaction for all players (e.g., Para (used in this demo), Privy, Dynamic, Turnkey).
• Transaction Cloud (TC): On first-time sign-in, the app submits a registration transaction via TC and funds the new user from a contract so they can transact immediately, which complements embedded wallet onboarding.
• Open Source: View the code

What Syndicate Appchain enabled

Adrift looks simple, but under the surface, it runs on infrastructure built to allow developers to have more control of onchain interactions. Randomness is enforced at the sequencer level, so outcomes are locked in as soon as a player checks in. This minimizes the risk of reorgs or rollbacks under normal operation and makes manipulation highly impractical, unlike most chains, where randomness is either slow or vulnerable to exploits.

With Syndicate appchains, developers can program exactly how transactions are sequenced, how randomness works, how fees are structured, and how the game economy runs. The infrastructure adapts to the gameplay, not the other way around.

• Programmable Sequencing: All transaction ordering and permissioning logic is onchain and upgradable via modules, making gameplay rules tamper-proof and transparent. Adrift's sequencing module can be found here.
• Lower Cost & Complexity: Minimal offchain infrastructure, easy upgrades, and reduced operational overhead.
• Atomic Composability: Enables future cross-chain and multi-app coordination.
• Community Ownership: Path to progressive decentralization and community governance.

Continue to the next guides for a deep dive into Adrift's game logic, contract setup, sequencing modules, indexer, and wallet integration.

Learn More

Watch this short video walkthrough to see how fresh randomness is injected every block, how the sequencer and smart contracts enforce fair outcomes, and why this approach is unique to appchains. Caleb from Syndicate explains the full flow: