Documentation

Guides for the Leap alpha: design your game's meta and economy, build systems, playtest your design and deploy it to your game.

Getting Started

Create your first project, learn your way around Leap Studio, and use workspaces to change your design safely.

Start here. This section introduces the Leap alpha, walks you through creating a project, shows you around Leap Studio, and explains workspaces — the isolated copies of your design you edit before merging them into Main, the shared, read-only state of your project.

Introduction to Leap — What Leap is, the building blocks of a design, and how a design goes from Leap Studio to your game.
Creating a Project — Create your first Leap project, name it, and see what Leap sets up for you automatically.
Navigating Leap Studio — Find your way around Leap Studio: the tabs, the project tree, the Element Explorer and the Inspector.
Working with Workspaces — Create a workspace, make changes safely, resolve conflicts, and merge your work back into Main.

Resources

Create what players earn, spend and accumulate — currencies, energy, XP, wins — and set the limits and starting values that shape them.

Resources are everything a player earns, spends or accumulates: soft and hard currencies, energy, experience, and counters such as total wins. This section covers creating them, and the limits and starting values that shape how each one behaves.

Creating Resources — Create resources such as gold, gems and energy, and set their limits and starting values.

Constants

Define the fixed tuning values of your design — base damage, XP per level, daily limits — that it reads but never changes.

Constants are the fixed tuning values of your design: a base damage value, the XP needed per level, a daily limit. Conditions, value expressions and formulas read them, but nothing in your design can change them. This section covers creating and using them.

Creating Constants — Create constants for the fixed tuning values of your design, and read them in conditions, expressions and formulas.

Flags

Track yes/no facts about a player — tutorial finished, hard mode unlocked — with flags.

Flags are yes/no facts about a player: whether they finished the tutorial, unlocked hard mode or claimed a one-time offer. Every flag starts false. This section covers creating flags, setting them from operations, and checking them in conditions anywhere in your design.

Creating Flags — Create flags, set them to true or false from operations, and check them in conditions.

Achievements

Create achievements that unlock automatically when a condition becomes true, and decide what they grant.

Achievements are goals that unlock automatically as soon as their condition becomes true — first victory, a hundred wins, a full collection. Each one can grant rewards when it unlocks and carry the matching IDs for each platform store. This section covers creating and configuring them.

Creating Achievements — Create achievements, set their unlock condition, choose what they grant, and add platform IDs.

Entitlements

Define what a store purchase grants — starter packs, ad removal, premium content — and when it can be bought.

Entitlements describe what a player receives from a store purchase — a starter pack, ad removal, premium content — together with the product IDs on each store and the conditions under which it can be bought. This section covers creating and configuring them from the Element Explorer.

Creating Entitlements — Create entitlements, link them to store products, and choose what they grant when purchased.

Groups

Organise your design with groups and folders, and learn how groups shape the paths your game uses.

Groups give your design structure. A group is a namespace: your game addresses the elements inside it as group.element, and groups can contain other groups. Folders organise the project tree for your team without affecting your game. This section covers both, and the rules for which elements can use which.

Creating Groups — Create groups from the project tree, add elements to them, and see how they change runtime paths.
Organizing Your Project — Use folders and groups to organise the project tree, and learn the slug and reach rules they bring.

Custom Operations & Events

Define the actions of your design with custom operations, and the signals that move systems with events.

Custom operations and events are the verbs of your design. A custom operation checks its conditions and then applies its effects; an event is a named signal that moves systems from one state to the next. Marking either as callable by game clients is how your game triggers them.

Custom Operations — Create custom operations that check conditions and apply effects, and let your game call them directly.
Events — Create events — named signals that move systems forward — and fire them from operations or your game.

Concepts

The shared editors you meet in every inspector — conditions, values, formulas and effects — and Element Flow.

Some building blocks appear in almost every inspector in Leap Studio. The condition editor decides when something happens, the value editor and formulas decide how much, and the effects editor decides what changes. Learning them once pays off everywhere; Element Flow then shows how it all connects.

Conditions — Build conditions from resources, flags, achievements and system states, and combine them with All, Any and NOT.
Values and Expressions — Use fixed numbers, element values, formulas and random curves wherever Leap expects a value.
Formulas — Name a calculation once as a formula and reuse it in any value across your design.
Operations and Effects — Change resources, flags and achievements, fire events and run custom operations with effects.
Element Flow — See how your elements and systems connect — what produces, reads, runs and fires what.

Systems

Build state machines for quests, tutorials and any other player flow, with states, randomizers and exits.

A system is a state machine: a player is always in exactly one of its states, starting in the first, and moves on when an exit's conditions pass or an event it waits for is fired. Randomizers pick a weighted outcome and pass straight through. This section covers building systems on the canvas.

Creating Systems — Create a system from the project tree, set its properties, and understand the GameSetup system.
States and Randomizers — Add states where players stay and randomizers that draw a weighted outcome, and choose the start state.
Exits and Transitions — Connect states with exits taken automatically or when an event fires, and drive systems from your game.
Working on the Canvas — Arrange, search and save your systems on the canvas, and learn which changes save immediately.

Playtest

Play your merged design as a brand-new player, one action at a time, and read what each action changed.

Playtest plays your merged design as a brand-new player, one action at a time, so you can check your systems, custom operations and events behave the way you intended. This section covers starting a playtest, choosing actions, and reading what each action changed.

Playtesting Your Design — Start a playtest on your merged design and take actions one at a time as a new player would.
Reading a Playtest — Read the player state, the run history and the changes each action made during a playtest.

Going Live

Tag versions of your merged design and deploy them to the environments your game connects to.

Once your design works, it is time to ship it. Merging updates Main; a version tags Main at a moment in time; and deploying a version to an environment is what game clients connecting to that environment receive. This section covers versions, environments and deployments.

Versions and Deployments — Create versions of your merged design, manage environments, and deploy a version to an environment.