Introduction
This page introduces Rush and its core concepts.
Last updated
This page introduces Rush and its core concepts.
Last updated
🚧 Rush is under heavy development. Expect bugs, crashes, breaking changes, and partial experiences so we can ship fast, break things, and iterate to bring you the best onchain game development experience. This page is Updated Daily.
Rush is a declarative and rapid Entity-Component-System (ECS) framework completely built with Rust that obsessively pursues a single goal: use already-proven techniques of developer experience abstractions to reduce the complexity of integrating with blockchain technology into already-known developer tooling: Game Engine SDKs and APIs.
Rush envisions a future where any game that’s already built or going to be built can easily be turned into a Fully-Onchain Game / Autonomous World simply by using Rush with their favorite Game Development stack.
Typically, a Game Developer uses a Game Engine to create games. With a Game Engine, the complexity of the underlying logic is greatly reduced. Game Developers can focus on their Game Design and Game Mechanics because the Game Engine is designed to take on the complexity.
On the other hand, Full Onchain Games (FOCG) and Autonomous Worlds (AW) are only possible with a decentralized data store such as the Blockchain because its decentralized nature allows data to persist much more resiliently than if it was stored on a single data repository. However, this doesn’t come without a cost.
The Game Developer must now worry about the implementation details of the Blockchain end-to-end tech stack.
This can be solved either by the Game Developer learning it or hiring an already expert both of which cost resources and are often big hurdles for Game Developers to overcome before they consider FOCGs or AWs.
This is why Rush came to be. Rush intends to remove all of this complexity by using already-proven effective developer experience abstractions.
With Declarative Configuration, Entity-Component-System (ECS), and Code Generation being the main developer experience abstraction strategies used.
The Game Developer doesn’t have to learn Blockchain technology’s end-to-end stack.
The Game Developer just needs to use Rush.
To paint a better picture of how Rush works, here’s a typical user journey of a Game Developer using Rush.
Build a game with their favorite Game Engine
Download the Rush CLI tool from the Sonic repository
Create Blueprints of their Game World to be stored onchain with Rush TOML DSL
Use Rush CLI to parse Blueprints and generate the following:
Smart Contract Code
SDKs that can interact with the Smart Contract
Use the SDKs generated for their favorite Game Engine
Use Rush CLI to deploy and manage the onchain program
The following principles drive Rush:
Declarative - no knowledge of control flow and logic is required to be productive.
Rapid - iterating should be easy with lightweight tooling and loosely coupled integration.
Entity-Component-System (ECS) - games are reduced to simple and digestible pieces of data.
Simple - developer experience is the top priority
Product-First - value is accrued by Product-Community fit and not by Complexity and Confusion driving short-term FOMO.
Ship faster, break things - the goal is to reduce assumptions and increase facts by iterating with lightning speed even at the expense of things breaking
Fun - I mean… why not?
Rush as a tool comprises 7 subatomic concepts called the Rush Subatomics.
Much like how neurons, protons, and electrons make up an atom Rush is made up of its World, Entities, Components, Systems, Instances, Blueprints, and Gaming Primitives.
Onchain data tracking the state of instances in the Game World.
Entity is a structure of data that represents a certain Gaming Primitive. For example, a Sheep entity may have an X, Y, Width, Height, and Speed.
Components determine the data that the Entity holds. For example, a Sheep entity's X or Y position is each a component.
Systems take a set of inputs and define the allowed state transitions that can occur onchain with those inputs. For example, a MoveForward system can only allow a Sheep entity to move forward.
Instances are actual data in an Entity. For example, a Sheep entity could be represented like below:
An instance on the other hand instantiates this Entity’s data structure into actual data like below:
Blueprints define the structure of a Game World in Rush DSL format, with TOML being the only one currently supported. It specifies what data should be stored per Entity that is available in the World.
Gaming Primitives are a certain definition of an entity onchain. For example, a Sheep Gaming Primitive can be represented via the Blueprint.
Rush is currently in Prerelease to gather feedback and feature requests directly from the community.
