What is BoundWorlds?

BoundWorlds is a sprite-based online "massive single-player world building game". Players can create worlds and explore worlds created by other players. Players can also create doorways, or Gates, that link their world to other player's worlds.

Back to BoundWorlds

What makes BoundWorlds different?

BoundWorlds is not the only level building game or game creation tool out there, but it has a number of qualities that make it unique.

External Links:

How complete is BoundWorlds?

BoundWorlds is currently in Open Beta. Some features have yet to be implemented, and the game is updated regularly. However, the main elements of the game, including the world editor and exploration system, are fully functional.

How much is there currently?

BoundWorlds already has a good few hours of gameplay consisting of user-created content. I'd suggest playing a few worlds by Kamani to get a feel for what's possible. If you're looking to make some stages of your own, you'll certainly find something that interests you here.

Download Here

This is a Windows app which is basically just a connection to the BoundWorlds website.

BoundWorlds Gameplay


The default controls are as follows:

  • Arrow Keys - Walk
  • Space - Interact with objects, talk to people
  • Shift - Lock on to targets. Targetable objects will have a yellow circle around them, which will turn red when you have locked on. While holding Shift, you will continue to face the targeted object.
  • Z - Attack enemies. Attacking repeatedly will drain stamina, making your attacks weaker.
  • X - Defend. Reduces damage from attacks.
  • C - Jump. The player can jump across one-tile pits.
  • X + C - Spring Jump. Allows you to jump over obstacles.

Over the course of your journey, you may discover places that let you transform into different objects. Each object has different abilities and will create a different playing experience. You may also find equipment that modifies your abilities.

The Menu

During gameplay, press Q to open the menu. This allows you to use or equip items you have collected. Some items can be transported from world to world, but others will be lost if you leave your current area. Not all items work in all worlds.

Gates and Worlds

The BoundWorlds universe is made up of Worlds, each World being composed of numerous areas, called Rooms. You can travel from Room to Room by walking over Gates.

Creating your First World

To use the World Builder, you must first log in on the main menu. Once you log in, you can create a world by simply clicking the "create new world" button under the world list. You will have to give a unique name to your world, which will be used as its ID for linking Gates to it (more on this later.) You can change the title of a world afterwards, which affects how it will appear in the World List, but the name will remain.

Once you create your first World, the World editor will open. Here, you can create global objects and rooms, and save your world to the server. You can also create and import packages, which will be explored in detail later. To exit the World Editor, click the "X" in the corner of the World Editor. Make sure to save first!

Your first step will be to create a new Room. Do this by clicking the "New" button under the "Rooms" list. Once you create a room, you will be sent to the room editor.

To return to the World Editor from the Room Editor, click the "X" in the corner of the Room Editor box.

Creating a Room: Adding Layers

A Room in BoundWorlds is a rectangular area that you (or other players) can explore. Rooms are made up of Layers and are connected to each other through Gates. Everything that goes on in the game happens in a Room. Similar to Worlds, a Room has both an ID (used for connecting Gates) and a visible title. Unlike Worlds, you can change a Room's ID after creating it, but be warned that doing so will break all Gates leading to that Room.

When you first create a room, you will want to first set its width and height (in tiles), and then to create a Layer. Layers can be thought of as "planes" in which objects interact with each other. Every object in a Room must occupy a Layer, and objects can normally only interact with other objects in their own Layer.

Although BoundWorlds has semi-3D physics and objects may have Z-position values, and objects in "higher" Layers appear to be above those in lower ones, Layers are not physically "above" or "below" other Layers. An object in a "higher" Layer will always appear "above" an object in a "lower" Layer and the two will never collide.

Simple rooms rarely need more than one layer, except for creating backgrounds and foregrounds. For your first Room, simply create one Layer and name it whatever you like. This will open up the Layer Editor.

Adding a Gate

Gates are the entrances into your Room. In order to travel from one Room to another, whether within the same World or to a different World, players must pass through a Gate. You will also need a Gate to test out your Rooms.

To create a new Gate, open the "Gates" list in the Layer Editor and click "New". When editing a Gate, just click on the screen to place it in the Room. You can make a Gate multiple tiles across by holding Shift and dragging the mouse to select its area. To test out your Room, click on the "Test Gate" button. Your avatar should appear on your Gate and can be controlled as normal. You have just created your first Room!

Of course, there's not a whole lot to do here yet. When you're ready to return to the World Builder, click the "Open World Builder" button.

Adding a Tilemap

You're probably going to want more than just a black screen to walk around in. To add more features to your Room, you'll want to create a tileset. By now, you should know how to add one - click the "New" button under the Tilesets menu.

Tilesets are images made up of 32x32 pixel square tiles, which can be placed anywhere in a Layer. While you will automatically be given a simple white square to work with, you will probably want something a little more elaborate. To import a tilemap image, click the "Manage" button in the Tileset Editor. This will open up your BoundWorlds file system, where you can import images or upload your own. Your file system will be shared by all the Worlds you create, so feel free to organize it as you choose.

If you don't happen to have any tileset images on your computer, you can make use of the Public Resources folder. You can also find tilesets all over the Web by searching for "32x32 Tilesets". Choose whatever image you like as your tileset, and it will appear in the Tileset Editor.

Once you have a Tileset, click on the image to select your tiles, then click on the main screen to place them. You can click the small white square under the tile editor to erase tiles instead. Also, you can use both the left and right mouse buttons to select and place two different tiles at a time.

If your Room is more than 16x16 tiles in size, you can drag the screen around by holding the mouse button. You can also select a rectangular area by holding the Shift key; this will allow you to place multiple tiles at once.

Now open the Gate menu and click on the Test button to walk around. Cool, right? But not much of a game, since the tiles don't do anything yet. You're probably going to want tiles that represent walls, so you can set boundaries or make mazes for players.

To create solid walls, click a tile in the Tileset Editor and then check the "Solid" checkbox underneath. This will cause that tile to represent solid blocks. Now you can make mazes!

Linking Rooms

Once you have created multiple Rooms, you'll want some way to link them together. This is where Gates come in.

Gates can be given a target location - the target being a Gate in another Room. When a player steps on a Gate that has a target location, they will instantly be sent to that location. Using this, you can link Rooms in your World together, creating a World!

Creating Sprites

Sprites are the main objects that do things in the BoundWorlds universe. Anything in a Layer that is not a tilemap, a background, or a Gate is a Sprite. Sprites have a great deal of functionality - they can be given basic stats, or can be programmed from the ground up to behave exactly as you want! Creating new sprites is the most complicated part of world building, so there are several chapters dedicated to sprite creation.

Going Public

Once you feel your World is ready, it's time to create a Public Gate. This Gate is the means by which other world builders can create links to enter your World. Creating a Public Gate is as simple as selecting a regular Gate and clicking the "Public" checkbox. The title of the Gate is what will appear to other users, so make sure to name it something relevant.

When creating a Public Gate, you may also want to select a list of tags to describe your World. This will allow other users to find it, as well as drawing Random Gates. Use a small amount of relevant and commonly-used tags to maximize the chances of visitors.


Sparks are the base "currency" of the BoundWorlds universe. Sparks are earned in two basic ways: by exploring, and by building.

Collecting sparks through exploration is fairly straightforward. You can earn sparks by collecting items, defeating enemies, or completing challenges.

When building a world, you can add sparks by creating objects that have a number in their "Increase Sparks" field under the "Basic Player Interaction" menu. Such items can be used as incentives or rewards for players exploring your world, or to create trails that lead them toward a desired exit. You earn sparks by getting players to explore your world and collect sparks. In general, the key to maximizing your earnings from a player is to add neither too many nor too few opportunities to earn sparks.

The maximum sparks a player can obtain from a given world is equal to the number of seconds they spent in that world. The world builder gains up to one-fifth of this maximum. If the player collects fewer or more than one-fifth of the maximum, the world builder will gain fewer sparks as a result.

This means that to maximize the sparks you collect from a given player, you should ideally give one spark for every five seconds you expect them to spend in your world. However, offering the opportunity to earn more than this by completing extra challenges can offer incentive for players to stay longer.

In addition, the value of any items gained or lost while traveling through a world is regarded as adding or subtracting sparks from the player's total while making this evaluation.

When playing one of your own worlds, you can view the current spark-to-time ratio using the meter in the lower-left corner of the screen. The yellow part of the bar represents the ideal amount of sparks you should have, and the third number indicates how many sparks the world will recieve if you exit at that moment. Try to construct the world in such a way that an average player will exit the world with the white bar close to the yellow part. If a skilled player is capable of going over the limit, you are giving too many sparks!

Important: Only players who exit a world through a Gate will earn sparks, for both themselves and the world builder! If a player quits to the Main Menu, any sparks they earned from that world will be lost. Avoid trapping your players without a means of exit!

Gate Properties

If you've started to build a world, you probably already know about Gates. There are, however, many nuances that can allow you to ensure smooth connections between different areas of your world, and with other worlds.

Gates can occupy multiple tiles. To create a multi-tile Gate, hold the Shift key and drag the mouse across the tiles, or simply change the width and height in the Gate Editor. Since Gates create backtracking paths, this is much better than adding multiple one-tile Gates to connect two rooms.

Gates retain the player's position. When a player steps onto a Gate, their position is saved and they will be automatically placed in a corresponding position of the destination Gate. If the Gates are different sizes, the position will be adjusted relative to the Gate's total size.

There are eight kinds of Gates, each one with slightly different properties.

Shift: These are the most primitive kind of Gate, simply moving the player from one Gate to the other. They retain the player's X and Y position and have no transition effects. When accessing a random Gate, Shift Gates can connect to any other Gate, but will prefer to connect to other Shift Gates or Bed Gates.

Walk: Most Gates leading off-screen will be Walk Gates; generally representing a pathway from one area to another, or a path between an "overworld" area and a local region. Walk Gates should almost always be given a direction, representing the direction that the player is expected to enter. When entering through a Walk Gate, the player will be placed next to the Gate's tile and will automatically face in the appropriate direction. Only the coordinate perpendicular to the Gate's direction will be stored when entering through a Walk Gate. Walk Gates strongly prefer to connect to other Walk Gates leading in the opposite direction. When placing a Gate on the edge of a room, the Gate will automatically be set as a Walk Gate facing in the appropriate direction.

Here <-> Inside: Used to represent the entrance to a cave or building. Functionally very similar to Walk Gates, except that they prefer to connect to Here <-> Outside Gates.

Here <-> Outside: Used to represent the exit of a cave or building. Functionally very similar to Walk Gates, except that they prefer to connect to Here <-> Inside Gates.

Ground Hole: Placed over a pit, these Gates will only activate when the player falls into the pit. You can make large Ground Holes that cover over a large area of a room and link them to a Sky Hole on a "lower floor", allowing the player to fall into the lower room whenever they fall into a pit. Gates placed over pit tiles will be set as Ground Holes by default. Prefers to connect with Sky Holes.

Sky Hole: Opposite of a Ground Hole. Sky Holes will not activate normally.

Bed: Represents the entrance to a "dream world". Unlike most Gates, the player's position will not be stored when entering or exiting a Bed Gate. May have other functionalities later. Prefers to connect with Shift Gates.

Teleport: Represents a teleporter. Does not store the player's position when entering or exiting, instead placing them directly in the center of the Gate. In order to enter a teleporter, the player's hitbox must be positioned completely inside the Gate's area. Prefers to connect with other Teleport Gates.

Global and Local Tilesets

Tilesets come in two main varieties, global and local. A global tileset is added to the World Editor at the top level, and can be used by any room in that World. All packaged tilesets are global. A local tileset is added to a layer directly and is used only by that layer.

When editing a layer, you will see a list of the global tilesets that are not being used in that layer. To add a global tileset to the layer, click the small green (+) icon next to the tileset's name. This will allow you to place tiles in the layer.

Tileset Properties

Tiles have several properties that will affect all objects that walk over them. Each individual tile can be given any combination of properties. When creating tilesets, there are several things to keep in mind.

Tiles overwrite tiles in tilesets "below" them, unless they have no type. While this is not really an issue in simple rooms with only one tileset, if you make multiple tilesets in a single room it is possible to "overlay" tiles with new tile types. For example, if you place a Floor tile over a Solid tile, the tile will be considered a floor. This is based on the tileset order in the layers.

The "Blank Tile" is a tile. It is easy to think of the blank tile as a simple "delete tile" option, but the blank tile can be given attributes just like any other tile. This is especially notable if you choose to give the blank tile the "Pit" property; this will cause all blank tiles to function as pits. This is especially important in conjuction with the previous fact; if you have a regular room and then add a tilemap with the "Pit" property, even without actually adding any tiles, the entire room will be a pit. This is the main reason why the "Floor" attribute was created, as it cancels out this common issue.

The tile attributes are as follows:

Floor: Floor tiles behave as normal blank tiles, but the Floor attribute cancels out the Pit and Drop attributes on the same tile. The main purpose of this is to deal with multi-tileset layers.

Solid: Represents solid walls. Blocks the movement of any sprite that does not have the Ghostly attribute.

Pit: Any object that is affected by gravity and cannot fly will fall into a pit and be destroyed. An object's entire hitbox must be positioned over a pit for it to fall in.

Slick (incomplete): Creates slippery tiles with low friction.

Sticky (incomplete): Creates sticky tiles with high friction.

Water: Creates water tiles. While in water, sprites use their swimming abilities to move. Sprites with no swim speed will not pass over water tiles.

Grass (incomplete): Creates tall grass tiles. Objects will be able to hide in the grass.

Sprites and Classes

Every object in the BoundWorlds universe, aside from tilemaps and gates, is a sprite. BoundWorlds does not make any hard distinction between collectable items, interactive NPCs, puzzle elements, or enemies - all of these are just sprites with different behaviors. In order to really begin creating a world, you need to create sprites.

Every sprite is part of a class. A class is a "type" of sprite, and multiple sprites may belong to the same class. For example, you might have a single class called "sign", but there may be many signs in a world. Each individual sign is a sprite, while the "sign" category is the class.

Classes may be global, which allows them to be used in any room of the same world, or they may be tied to a specific layer in a specific room. This allows you to make classes that will be used in many different rooms, or unique local classes that will only be used in one place, saving clutter. To create a global class, simply create the class while the World Builder is navigated outside of any particular room.

You can edit a class by double-clicking it in the class list, or clicking the "E" edit button. When you have a class selected and have a layer opened in the World Builder, you can place sprites in the layer by clicking on the screen, then selecting the direction the sprite should face. You can also select individual placed sprites by clicking the "Select" button under the class list. Right-clicking deletes sprites, and you can also hold Shift to align them to tiles.

Individual Attributes

You don't have to create a new class whenever you want to make slight variations on a basic template. The Class Editor allows you to create "individual attributes" by ticking the green checkboxes next to their attributes.

Creating an individual attribute allows you to set that attribute for each individual sprite after placing it. For example, the "sign" class may its "text" attribute set individually. This allows each individual sign to have different text, without having to create a whole new sign class. In addition to saving on space and loading time, this is also especially useful when you want to export your classes for public use, as it allows them to be far more versitile. Almost all basic properties can be set individually, except for graphic, function, and technique-related attributes.

To change an individual attribute, click the "select" button below the object list and simply click on the sprite you want to edit. You can also use this to reposition the sprite.

Sprite Graphics

When creating a class, your first priority will probably be to give it graphics. To do this, open up the class in the World Builder and click on the "Edit Graphics" button near the top.

Every sprite gets its graphics from a spritesheet, which is an image file that is divided up into tiles of a specific width and height. You can upload a spritesheet from your computer or choose one from the public resources by clicking the "manage" button. This will load the spritesheet into the Graphic Editor.

To actually make the sprite's graphics appear, you must create animations. For simple sprites, you can create animations automatically by selecting an option from the "Animation Convention" tab. This is useful for simple, one-frame sprites, or from spritesheets made by Charas Project or for RPG Maker. Otherwise, you will have to create your own animations. Fortunately, BoundWorlds does a lot of the work for you.

Every animation in a BoundWorlds sprite can have multiple directions depending on which way the sprite is facing - north, south, east, or west. BoundWorlds supports several conventions for sprite facing directions - 1 way, 2 way, 4 way, 4 way diagonal, and 8 way. There is also a "free rotation" option for sprites that automatically rotate toward the direction they are supposed to be facing, like ships in Asteroids-style games.

You will see several animations available by default, these will be used based on the sprite's current behavior. The most important animations are _stand and (if you want your sprite to move) _walk. You can also add custom animations that will be used in functions or techniques.

If a sprite does not have an animation for a given action, it will use the most appropriate one it can find. For example, a sprite missing a _walk animation will use its _stand animation while walking.

To add frames to an animation, simply select the animation and click on the spritesheet. You can also "flip" individual frames horizontally or vertically by clicking the small icon above the frame.

Adding Physics

Once you have created a class and given it graphics, you're probably going to want it to actually do something. Time to start using the Class Editor.


The first thing you're going to want to do is give your sprite a hitbox. Hitboxes allow sprites to collide and interact with each other. The only sprites that should not be given a hitbox are intangible things like graphic effects and function controllers. Hitbox controls are under the "Basic Options" tab in the Class Editor.

BoundWorlds sprites have two kinds of hitboxes - circular and rectangular. Generally, mobile sprites like people and creatures should have circular hitboxes, while solid, stationary objects like blocks and doors should have rectangular hitboxes. To create a radial hitbox, set a number in the "Hitbox Radius" field. To create a rectangular hitbox, use the "Hitbox Size" field to set the object's X and Y values. If you create a radial hitbox, you'll be able to visualize the size of the hitbox based on the sprite's shadow (although you can override this by setting the "Shadow Size" field to a value other than -1).

Basic Properties

Besides hitboxes, other attributes under the Basic Properties tab affect certain qualities of the sprite.

Targetable Unit: Makes the sprite targetable by both the player and NPCs. NPCs will ignore non-targetable sprites. Generally, if a sprite is going to be doing any fighting, it should be a targetable unit.

Hittable: Allows the sprite to be hit by normal hitboxes.

Solid: Solid objects will prevent other sprites from moving through them. Note that most mobile objects should not be solid, as it is easy for the player to get stuck behind them if they move into the wrong place. Solid objects should be reserved for things like doors, walls, and non-moving guard NPCs.

Bullet: Bullets will not collide with other bullets, only with non-bullet sprites. This makes processing faster if there need to be many bullets on screen.

Effect: Designates the sprite as a special effect. Effects do not collide with other sprites at all, speeding up processing time.

Ghostly: Allows a sprite to pass through solid objects. The sprite will still process any collision events associated with the object.

Lock to grid: Forces the sprite to remain aligned with the tile grid. Physics for these sprites are simplified; they do not experience normal acceleration or knockback. Suitable for non-moving or rarely-moving obstacles.

Motion and Physics

Sprites can be given various stats affecting their ability to move around. These are selected under the "Physics and Motion" tab in the Class Editor. Note that the options in this tab will not affect a sprite's AI or behavior - unless they are given idle behaviors and/or combat AI, a sprite will remain still, even if it technically has the ability to move. If the player is transformed into a mobile but behavior-less sprite, they will be able to move.

Mass: The weight of the sprite. This mainly affects collisions and knockback. When hit by an impact, the force of the impact will be divided by the mass of the sprite. If mass is set to -1, the sprite will be entirely unaffected by knockback effects.

Push Force: The force that the sprite will push away other sprites that touch its hitbox. The actual amount the other sprite will be pushed depends on their mass.

Walking Speed: The walking speed of the sprite, measured in pixels per frame. While walking, a sprite will stop and start moving instantly, and has perfect control. This is also the "starting" speed of a sprite when running.

Top Speed: The top speed of the sprite while running, measured in pixels per frame. Sprites with a top speed of 0 will be unable to move under their own power. If set to -1, the sprite will not have its speed capped. WARNING: If top speed is too high, the sprite may clip through walls when moving too quickly. For best results, do not allow normal, colliding sprites to move faster than around 16 pixels per frame.

Acceleration: The amount of acceleration the sprite will experience when moving. If set to -1, the sprite will instantly reach their top speed when moving.

Friction: Sprites with higher friction have better control when running. If set to -1, the sprite will stop instantly when not actively accelerating.

Gravity: The sprite will accelerate downwards at this rate when in midair.

Terminal Velocity The top speed the sprite can accelerate downwards due to gravity.

Jump: The sprite will attain this upwards velocity when jumping.

Flight Ascent: The speed the sprite can accelerate upwards while in mid-air. Enables flying.

Hover Altitude: The sprite will automatically attempt to hover at least this number of pixels off the ground. The sprite must be capable of flight in order to actually hover. If incapable of flight but capable of jumping and the hover altitude is not 0, they will jump constantly.

Maximum Altitude: The highest the sprite is capable of flying. This is not a "hard limit" on the sprite's altitude, but they will be unable to accelerate upwards if above this level.

Turning Speed: The number of degrees the sprite is capable of turning per frame. If set to -1 (the default), the sprite will face in any direction instantly.

Basic Interaction

While BoundWorlds has a lot of options for advanced users, it is quite simple to create basic interactions for simpler sprites without even opening up the Functions menu. The "Basic Interactions" menu has two sections, one determining what event should trigger the interaction and the other describing what should happen when the sprite is triggered.

Want to make a basic collectible that rewards the player with sparks? Set the sprite to trigger when touched by the player, and make it destroy itself and increase the player's spark count.

Want to make an NPC that displays a message when the player checks it? Set the sprite to trigger when checked, and make it display a message when triggered.

Want to make an enemy that transforms into a different enemy when it is defeated? Set the sprite to trigger on death, and make it transform when triggered.

And so on.

One option under basic interactions lets it trigger other sprites that have a matching "trigger code". This allows you to create interactions across multiple sprites. For example, a switch that opens all doors with a particular code when pressed. You can even chain triggers together by making the triggered sprite also have a trigger code.

While this system is quite flexible, don't go overboard with it. Once you're ready to really start adding extra functionality to your world, it's time to start working with functions.

Basic Combat

Unless their team is set to 0, Sprites will fight with other sprites that belong to a team not their own. Sprites will attempt to attack and defeat any targetable unit that enters their Aggro Radius, and will continue to fight until one of the following conditions are met:

  1. One of the combatants is defeated.
  2. The distance between the sprite and its target is greater than the attacker's Max Aggro.
  3. The distance between the attacker and its original position is greater than its Maximum Leash.

Aside from walking around, everything a sprite does while in combat is a technique. Most techniques have either a cooldown period or an MP cost; after using a technique the sprite must wait for it to become available again.

While waiting for its combat techniques to become available, a sprite will enter "stalking" mode. While stalking an enemy, the sprite will attempt to remain within a "ring" at a distance from its opponent greater than its Avoidance Distance, and closer than its Max Stalking distance.

Roaming Behavior

The "Roaming Behavior" tab in the Class Editor determines the behavior of a sprite when not talking, fighting, or following a scripted behavior. For the most part, this amounts to walking around aimlessly.


Textboxes are found throughout object parameters and events in BoundWorlds. While they are for the most part fairly self-explanatory, there are a number of special options you can use to improve on them as well.

You can add special properties to text within a textbox by adding bracketed commands.

Command Description Example Example appearance
[b] Bold text [b]Bold[/b] Bold
[i] Italic text [i]Italic[/i] Italic
[u] Underlined text [u]Underlined[/u] Underlined
[s] Strikethrough text [s]Strikethrough[/s] Strikethrough
[c] Color text [c=#FF0000]Red Text[/c] [c=#0A0]Green Text[/c] [c=blue]Blue Text[/c] Red Text Green Text Blue Text
[n] Creates a new line. Generally not necessary since dialogue boxes handle new lines alread, but could be useful for dynamically-generated text. This is the first line,[n]and this is the second line. This is the first line,
and this is the second line.
[size] Text Size [size=32]Big Text[/size] [size=8]Small Text[/size] Big TextSmall Text
[font] Font family [font=monospace]Monospace Text[/font] [font=sans-serif]Sans-serif Text[/font] [font=serif]Serif Text[/font] Monospace Text Sans-serif Text Serif Text
[speed] Set typing speed (in frames per letter, higher values are slower) [speed=5]Slow Text[/speed] [speed=1]Fast Text[/speed] [speed=0]Instant Text[/speed] (Not shown)
[wait] Waits for a certain number of frames. Does not use closing tags. If no numeric value is given, waits for player input instead. If you're already here,[wait=10] why not stay a while? (Not shown)
[next] Waits for player input, then opens a new text box. Does not use closing tags. Hello! Welcome to our town![next]Enjoy your stay! (Not shown)
[align] Align text to left, right, or center [align=center]Centered Text[/center]
Centered Text
{code} Replaces the text with a variable You have {@.$potion} potions. You have 6 potions.
\ Escape the next character To make red text, type: \[c=#FF0000]Red Text\[/c] To make red text, type: [c=#FF0000]Red Text[/c]

Functions, Flowcharts and Techniques

Functions, flowcharts and techniques are the deepest part of BoundWorlds. They allow you to create flexible scripts that can make your world unique!

These objects are very similar in many ways. All are sequences of events that are run one after another; they allow classical programming operations including getting and setting variables, conditions, and loops. The events available for each are mostly the same. In addition, they can "call" each other, allowing you to combine them. However, they are fairly different in their precise application.

Functions are a series of events that play out in sequence. There are several built-in functions which are called at particular points during the sprite's operation, such as when it is created, when it dies, when it encounters the player, or every frame. A function will run each event in sequence, sometimes waiting for a response from the player, before moving to the next event. Functions are generally used for updating custom variables, controlling events in the room, creating conversations, or running cutscenes.

Flowcharts are basically a more intuitive way of creating certain functions and are especially designed for dialogue trees and cutscenes. You can manipulate the "flowchart space" of a class freely, and visualize text boxes and selectable options as nodes in the flowchart. You can also run tradiitional functions within the flowchart. Flowcharts must have a "start" node to run and can be called either through basic player interaction or through traditional functions. A sprite may only be at a particular point in its "flowchart space" at a time; moving to a different "node" cancels the current one.

Techniques are designed to be run by the sprite's AI, or used manually by the player while playing as the sprite. They have built-in parameters for things like cooldown, MP cost, usage frequency, and the circumstances and targets on which it can be used. Unlike functions, techniques take a specific amount of time to run, and can be directly associated with an animation. While functions are run in sequence, each frame of a technique is its own function and always takes exactly one frame to complete; any event that takes multiple frames (such as a jump) will be triggered, but the function will proceed immediately to the next event. Most importantly, a sprite may only use one technique at a time; using a new technique interrupts any that are currently in use. It is also often possible to interrupt a technique by hitting the sprite with an attack. Most techniques will be used in combat, aside from those designed to be used by the player for moving around or random periodic behaviors to be used by the AI.

There are several default functions that are called at specific times:

_create: Called when the sprite is created, or when the room first starts.

_update_before: Called before running AI functions in a frame update.

_update: Called before calculating physics, including motion, collisions, and damage.

_update_after: Called after calculating physics, but before adjusting HP to keep it below maximum HP or calculating whether the sprite should die. Useful for functions that incorporate things like overhealing or saving a sprite from death.

_ondeath: Called when the sprite runs out of HP. Not called if the sprite is destroyed by a "Destroy Sprite" event.

_collide: Called whenever the sprite collides with another sprite. When running the function, _other refers to the sprite being collided with.

_touched: Called when the player collides with the sprite.

_checked: Called when the player interacts with the sprite.

_trigger: Called when the sprite is triggered by one of the "basic player interaction" criteria.

Event Reference

Set Variable

This sets a variable to a particular value, essential for programming custom functions. You can create custom variables to store information or edit preset variables to change the behavior of objects in the function.

Numbers, strings, or objects may be stored as variables. BoundWorlds is weakly coded; variables do not need to be defined before use. All undefined variables are presumed to be 0. Boolean values are 1 (for true) or 0 (for false). ("True" and "False" are not keywords in BoundWorlds; if you try to use them they will simply be considered custom variables.)

To specify a variable as a text string, enclose it in "double quotes".

All preset variables begin with an underscore (examples include _speed, _turn, _accel, _text, _layer, _room, and so on). You cannot create a custom variable that begins with an underscore.

@ is a special variable that always refers to the player.

Variables that begin with $ refer to items in a sprite's inventory. Example: If you create an item called "potion", $potion will refer to the number of potions in the sprite's inventory. $ by itself refers to the number of sparks the sprite contains. This is generally relevant for the player, although it is possible to use this to modify enemy drops or shopkeeper inventory mid-game.

Variables that begin with # are local variables. These variables are contained within the function they are referenced. You can use this when running multiple functions at once to ensure that the functions do not alter each other. # by itself generally refers to a context-specific variable, for example the current item in an Each loop.

You can reference variables contained inside another object by using periods to separate them. For example, @.$ will always refer to the player's spark count. _layer._maps is an array of all the tilemaps in the sprite's layer.

To practice with this, use the in-game object editor while in testing mode. This will allow you to freely view and edit all variables of a sprite by clicking on it.

Set Temporary Variable

Only relevant for techniques. This sets a variable which will be reverted back automatically at the end of the technique, or if the technique is interrupted. For example, if you want a sprite to be unable to move while using a particular technique, you can temporarially set its _speed to 0.

Unset Temporary Variable

Only relevant for techniques. Reverts a temporary variable back to its original value.


Begins a conditional block. If the expression evaluates to false (or 0), it will be skipped. Otherwise, it will perform the actions inside the code block.


Runs a conditional block until the expression parameter evaluates to false (or 0), or until a Break Loop event is executed. Be warned that unless you add a Wait or command-type event inside a loop statement, the loop will continue to run within a single frame. This can create infinite loops, which will cause your world to break. (If a function hangs for more than 1 second, the game will assume it is an infinite loop and will close the world.)


Runs a code block on each object in a given array. For example, _layer._sprites will perform an action on every sprite within the layer. You can set the current object to a variable, or simply use # to reference it.

Break Loop

Immediately exits a Loop or Each statement.

Continue Loop

Moves to the next iteration of a Loop or Each statement, without executing the events that come after.

Else / Else If

If placed after an If statement but before an End statement, creates a block of code that runs if the If condition was not met. If a condition is defined in the Else event, only runs the subsequent code if the new condition is met. Else statements can be chained to create a function with multiple conditions.


Closes an If, Loop, or Each block.


Logs text to the console. Used for debugging purposes.


Pauses the function for a certain number of frames. Useful for cutscenes or to run an infinite loop without breaking the world. Not available in techniques, since each keyframe in a technique can last only one frame.

Create Sprite

Creates a sprite at a designated location, either at an absolute position in the room or relative to the creator. This sprite can be designated as a spawn, which will copy the creator's team over it and also add its spawn value to the creator's total spawn count. The sprite can be assigned to a variable, which can be used to modify it after.

Destroy Sprite

Destroys either the current sprite, or an object stored in a variable. Note that this is not the same as killing a sprite - the _ondeath and any basic interactions will not run and the sprite will not drop its items, instead it will simply disappear.


Transforms the current sprite or a designated target into a different class. This event has a number of interesting properties besides changing the class. The sprite's HP, MP, and TP ratio relative to their max value will remain the same - for example, if a sprite with 50 HP and a max HP of 100 transforms into a class that has a max HP of 150, their HP will be set at 75. However, if the sprite transforms due to an action that runs on its death, it will be revived and its HP will be fully replenished. If transforming into a class with a default team of 0, the sprite will retain the team it had originally. Finally, inventory will not be adjusted, even if the class has a default inventory set.

Set Tile

Changes a tile at a given tile position into a different tile. This allows you to modify tilemaps during gameplay. Note that the tile position is different than the pixel position of a sprite on that tile. You can get a sprite's tile position using the _tpos variable, or the _tx and _ty for the individual axes.


Runs the default function created by a sprite's "basic player interaction" parameters.


Instantly moves a sprite to a given position. In addition, the sprite's jumping positions, quick text, and origin points will be adjusted along with them. This will rarely be used, but with good coding it can be used to create the illusion of infinite scrolling areas.

Start Cutscene

Begins a cutscene. When a cutscene begins, the sprite that called the event is designated as the "Cutscene Master". During a cutscene, sprites can be set to certain levels of inactivity, ranging from disengaging from combat to ceasing all physics and animation.

Sprites that are given specific commands through the current function (such as Walk or Jump) are "exempt" from the cutscene's "rules" until that action completes.

If the cutscene level is "Disable All Physics" or higher, affected sprites will not run their normal _update events.

Add Cutscene Exception

Specifies a particular sprite to follow its own rules during a cutscene. For example, if you want most sprites to remain frozen, but are also creating new sprites during the cutscene that you want to be able to move without giving them direct commands, you can add cutscene exceptions for these new sprites.

Remove Cutscene Exception

Removes a sprite from being exempted from the cutscene.

End Cutscene

Ends the current cutscene.


Commands a sprite to walk to a given position. The next event will run when they reach the position. Alternatively, you can choose to continue immediately, in which case the sprite will continue to walk while the rest of the function continues.


Commands a sprite to jump to a given position. Sprites in mid-jump will follow a parabolic path and will not interact with any solid blocks they encounter along the way - this is mainly used for cutscenes or to reposition a sprite in its proper area. The next event will run when they land. Alternatively, you can choose to continue immediately, in which case the sprite will continue to jump while the rest of the function continues.

Text Box

Displays a text box. While displaying a text box, the player will be unable to move (unless you select the "allow player movement") and the talking sprite will not run any AI events. The default color and font style of the text box will be based on the sprite's default text parameters, but can be given unique parameters if you so choose.

You can also designate option boxes to create a player reply, and store the reply as a variable. This allows you to create dialogue trees in a function, however it is almost always better to use flowcharts for lengthy or complex dialogue.

Open Shop

Opens an item shop window, with the sprite's inventory used as the purchase options. The player will be able to buy and sell items for sparks.

Quick Text

Displays quick rising text, similar to what appears when sprites are damaged, healed, or pick up items.

Apply Status Effect

Creates a sprite and applies it as a status effect to another sprite. As with the Create Sprite event, you can store the created sprite as a variable.

Remove Status Effect

Removes a status effect of a particular class from a target sprite.

Flash Effect

Applies a color flash effect to an object. The object may be a sprite, a layer, a tilemap, or the entire room. You can use the timing parameters to adjust how quickly the flash appears and fades, and even use cubic-bezier functions to customize the color flash further. You can also bind the flash effect to a sprite, which will cause the effect to disappear if the sprite is destroyed - this is mainly useful if you want to apply it along with a status effect. You can store the flash as a variable, which allows you to adjust it later. Flash effects will cause the script to stop until the flash is done, unless you select the "Continue Immediately" option.

Sound Effect

Simply plays a sound effect. You can also specify a speed and volume to play the sound at.

Set Music

Sets the music of the room. If the same music is already playing, this event does nothing.

Create Hitbox

Creates a hitbox and attaches it to the sprite. Hitboxes are used to calculate collisions, mainly for combat purposes. A hitbox is attached to a position relative to the sprite's direction and will move and rotate with the sprite. For example, if the hitbox is positioned at (8,0) it will attach to a point 8 pixels in front of the sprite's position, regardless of which direction they are facing.

Hitboxes can deal damage, apply force, play sounds, apply a flash effect, create status effects, and even run custom functions on contact. You can also designate an expression to determine whether or not a hitbox should be able to hit a particular target (for example, to create an "earthquake" attack that only hits targets on the ground, you can make a hitbox with the criteria {_other._midair = 0}).

Hitboxes can also have elemental effects, allowing them to deal increased or reduced damage to particular targets. To calculate damage, the total power of the hitbox is divided according to the ratios of all its elements, then each of those values are multiplied by the target's weakness to that element. Physical damage is considered like its own element; this is the only element that a sprite's basic defense will protect against.

Example: An explosion's elements are listed as 1 physical, 2 "fire", and 1 "sound". The attack normally deals 100 damage total and hits an enemy with a physical damage multiplier of 0.75 and a fire damage multiplier of 2.

Total of all elements is 4 (1 + 2 + 1), and 100 / 4 is 25, so each "part" of the attack deals 25 damage.

25 physical damage is multiplied by 0.75, or 18.75. 50 (25 x 2) fire damage is multiplied by 2, making 100. 25 sound damage is left as is. So the total damage dealt by this hitbox to this target is 143.75.

Permit Interrupt

Normally, when a sprite uses a technique all of its other techniques are disabled until the technique is done. By permitting interruptions, you can allow a sprite to choose to switch to a different technique. You can even permit techniques that are normally disabled, allowing you to create complex multi-button combo techniques. This is best used for sprites that are intended for player use. When non-players are permitted to use a new technique, the timer for the next check of that technique resets.

Forbid Interrupt

Forbids a technique that was permitted earlier.

Aim at target

Aims for a position based on the current sprite and the target sprite. If all parameters are left as their defaults, the position is simply the position of the target. Otherwise, the actual position selected is constrained by the chosen specifications, and will be the point that is closest to the target without being out of range.

Min Distance and Max Distance limits the distance between the user and the target point.

Horizontal Angle and Horizontal Spread creates a "cone" of valid positions based on the sprite's current direction. For example, Horizontal Angle of 0 and Horizontal Spread of 45 can target anything within a 90 degree cone (45 degrees on each side) in front of the user.

Vertical Angle and Vertical Spread works the same way.

Distance from Target and Direction Relative to Target will aim for a particular distance away from the target itself. Direction Relative to Target rotates this point away from 0 being the point closest to the user. If it is 180, the user will aim for the opposite side of the target.

Dash to aimed position

Commands the user to dash toward a previously aimed position. Dashing is similar to jumping, except that a dash does collide with solid objects in the way.

Fire Projectile at aimed position

Creates a sprite and propels it toward the target position at a given speed. The projectile is automatically set as a spawn of the user.

Set Camera

Sets the camera to follow a particular sprite. You can make an invisible camera sprite to control the camera freely.

Set Avatar

Allows the player to control a different sprite. The player's normal avatar will remain in place until they switch back.

Preload Room

Preloads all media resources of a particular room. This is mainly done to ensure that music plays at the right time. It is recommended to create a simple "atrium" area at the beginning of a world to ensure that all resources are loaded smoothly.

Offload Room

Resets a persistent room. This is important for freeing up memory in large worlds with many persistent areas, and also allows you to do things like reset dungeons and the like. All persistent rooms will be reloaded when the player leaves the world regardless of this.

Change Layer

Moves a sprite to a different layer.

Go To

Sends the player to a designated Gate. The parameters will determine what kind of Gate the player was presumed to have exited from, and where they will return to (if relevant).

Roll Credits

Displays the auto-generated credits reel.

Start Function

Begins to run a function. The main function will continue when the sub-function is complete.

Start Flowchart

Begins a flowchart at the selected start node. You must create a start node in order for this to work.

Start Technique

Begins a technique. If you are already in the middle of a technique, the current technique ends.

Exporting Packages

Once you have created some interesting classes or tilesets, you might want to export them for other players to make use of. To do this, you need to create a package in the World Builder. Only global classes and tilesets can be added to a package.

When you open up a new package, you can add objects to it by clicking on them in World Builder menu. Objects that make use of each other should be packaged together; for example, an entity that spawns bullets should be packaged together with those bullets, and objects that transform into other classes should be packaged along with their alternate forms. You can also package hidden objects by selecting the "hidden" option in the Class Builder. Hidden classes will not appear in the class menu, preventing players from adding them directly to a room.

While you can organize your classes in packages without saving them, you must save a package in the file system before you can make it public.

Note that editing and saving an existing package will automatically update that package in all worlds that make use of it. Saving a world that contains a package after editing the object in that package will also update it. Make sure to test changes before updating.

Nesting Packages

It is possible for packages to include other packages. This allows you to create single packages that are used by many different objects. For example, you might create multiple creatures that all make use the same special effects; instead of packaging a copy of the effects along with each creature you can put the "effects" in their own package and include the package with each creature. This will ensure that the effects are only loaded once, even if a world uses several of your creatures. This will speed up loading, make updating easier, and avoid cluttering up the class menu with duplicate objects.