Today, we’re launching Adrift—the first game and gaming appchain from Syndicate—to show what programmable onchain sequencing makes possible and create a new opportunity for users to engage with appchains.

The game begins on July 9th, and once it starts, no new players will be allowed in. Join the game while registration is still open. Register here.

Why Games Need Their Own Chains

Games have always pushed technology forward.

From LAN parties to Minecraft mods to player-run economies in Runescape, games are where communities experiment, break rules, and build new digital worlds. But over the past decade, most online games have become increasingly centralized—run on proprietary servers, governed by opaque logic, and locked into closed ecosystems.

Even “onchain games” face limitations. Built on general-purpose blockchains, they struggle with latency, randomness, transaction ordering, and exploit prevention. Developers are forced to hack around the infrastructure just to deliver basic interactivity—while users pay gas fees to participate, with no say in how the system works.

That’s why games need their own chains. Not just contracts deployed on someone else’s terms, but customizable appchains—where developers own the logic, communities shape the experience, and the infrastructure evolves with the game.

At Syndicate, we’re building that foundation. And to show what’s uniquely possible, we built a game that uses sequencer-enforced randomness—always up to date, built into the chain itself. You can’t do that anywhere else.

Introducing Adrift: The First Gaming Appchain From Syndicate

You’re a lone vessel at sea. Each day, you must check in to repair your ship and weather whatever the ocean throws your way. Some days you’ll be lucky. Others, not. Miss a check-in, and your boat begins to fall apart. Miss enough, and you’re gone—swallowed by the waves.

This is Adrift—the first game and gaming appchain released by Syndicate, and a live demonstration of what programmable onchain sequencing makes possible.

The game play is simple:

Create an account.
Check in every day.
Miss a day, and you're out.

Each check-in comes with a randomized event—a perk or a punishment. The longer you last, the higher you climb on the leaderboard. The game continues until only one player remains.

But once the game begins, no new entrants will be allowed in. It’s a true test of endurance, timing, and ritual. And it starts soon.

Registration is open now. The game begins on July 9th. Once it starts, the gates close. Sign up here today—or miss your shot to survive.

How Onchain Sequencing Powers Adrift

What seems like a simple check-in mechanic hides a complex and powerful infrastructure. At the core of a “proof of survival” game is randomness. Every daily check-in comes with a random outcome: in the context of Adrift, some events help your ship stay afloat; others make it harder to survive. The randomness matters. And that’s where traditional blockchain infrastructure runs into problems.

Most chains rely on Verifiable Random Functions (VRFs) that operate across multiple blocks. VRFs protect against exploitation—but introduce latency, added complexity, and slower game loops. To reduce those issues, some developers use faster, single-block randomness systems—but those open the door to manipulation. Players can revert, wrap, or delay execution to avoid bad outcomes.

Sequencer-enforced randomness removes the tradeoff. It’s low-latency, natively verifiable, and embedded directly into the chain—so gameplay stays fast, fair, and impossible to rig.

On Syndicate:

Every user interaction with the game is preceded by a randomness update injected directly by a TEE (Trusted Execution Environment).
The randomness is added after the user has submitted their transaction—so they can’t front-run or censor based on the result.
If the required randomness isn’t present, the sequencer rejects the transaction outright.
Reverts don’t help. Wrapper contracts don’t work. The outcome is final.

This creates tamper-proof, low-latency randomness as a native primitive. Game developers don’t need fragile multi-step flows or external randomness oracles. The logic is clean, the gameplay is fast, and the results are verifiable.

Even more powerful: this enforcement logic is entirely programmable. Adrift’s sequencing rules are encoded inside of transparent smart contracts, defining exactly how transactions are bundled, validated, and ordered. And because it's an appchain, those rules belong to the game—not to the platform.

A New Era of Gaming Appchains

Adrift shows how developers can build games where the infrastructure serves the gameplay, not the other way around. Where communities aren’t just players—they’re participants in shaping the logic, sequencing, and incentives that power the game. Where new primitives like randomness, ordering, and transaction dependencies are native to the stack.

This is the first of many appchains we’re launching at Syndicate under our new experimental track—each one pushing the boundaries of what’s possible when you can own and program the sequencer.

Join the Adrift Game Today

Adrift begins on July 9th. Once the game begins, no new players will be allowed in.

Adrift is the first of many appchains Syndicate is launching—designed to explore what becomes possible when games are built on fully programmable infrastructure.

It’s also the starting point for something bigger. Appchain infrastructure gives developers full control over gameplay logic, randomness, and coordination—and unlocks entirely new design spaces for games that are fast, fair, and community-owned from the ground up.

Join the game here, or get in touch to launch your own appchain.

Introducing Adrift: Syndicate’s First Gaming Appchain