GameSalad from Scratch: a guide for teachers

A concept map from Scratch to GameSalad, coordinate conversions, the misconceptions students hit most, and a six-lesson transition unit.

Why this guide

Your students' Scratch skills transfer to GameSalad, but the way a game "thinks" changes. This guide is for teachers who already teach computational thinking with Scratch and want to move students into GameSalad.

Every core idea carries over: sequence, loops, conditionals, events, variables and decomposition. What changes is how instructions run.

In Scratch, a script is a list of steps that runs top to bottom and can pause. In GameSalad, an actor holds rules that the game re-checks many times every second. Most student confusion comes from carrying the first picture into the second world.

By Tan Tran · September 30, 2026

The big shift: from scripts to rules

Scratch scripts are recipes followed step by step; GameSalad rules are standing instructions that are always being checked. A Scratch script can stop at a wait block and pick up later. A GameSalad Rule never waits. At each moment it is either true or false.

A useful analogy is a classroom with posted rules. "When the bell rings, line up" is not a script someone reads once. Everyone keeps it in mind all day, and it applies the instant the bell rings.

GameSalad re-checks the game about 60 times per second, which is twice Scratch's 30. Each check is called a frame. Inside a Rule, behaviors fall into three kinds.

Kind Examples What happens inside a Rule
Instant (actions) Change Attribute, Spawn Actor, Destroy, Play Sound, Change Scene, Change Image Fire once at the moment the Rule becomes true. They do not repeat while it stays true.
Continuous Move, Rotate, Accelerate, Constrain Attribute, Collide, Display Text Run every frame for as long as the Rule stays true, and stop when it turns false.
Timed Interpolate, Move To, Rotate to Angle, Animate, Timer Run over a set time, then finish. They stop early if the Rule turns false, unless "Run to Completion" is checked.

An instant action re-fires only when its Rule goes false and then true again. If the action is outside a rule, it fires once, when the actor spawns. So a Rule "when the space key is down, Change Attribute score to score + 1" adds exactly one point per press. Holding the key does not keep adding points. Releasing the key and pressing it again will.

Every Rule can also have an Otherwise section. Its behaviors run whenever the Rule's condition is false, including at the moment the scene starts. Instant actions in Otherwise fire once each time the Rule switches from true to false.

Concept map

The table below pairs each Scratch idea with its closest GameSalad feature and the difference students will notice.

Scratch concept GameSalad equivalent What's different
Sprite Actor The actor in the Library is a blueprint (prototype). Copies placed in a scene are instances that share its rules.
Costume Image; Change Image; Animate Animate plays a list of images at a set speed. There is no costume number to step through.
Stage Scene A game has many scenes (levels, menus). A scene can be larger than the screen and scroll with a camera.
Backdrop / switch backdrop Scene background color or a background actor; Change Scene Switching backdrops usually means changing scenes or changing a background actor's image.
Script under a hat block Rule with a condition The condition is checked every frame, not triggered once.
Command block Behavior Each behavior is instant, continuous or timed (see above).
forever Nothing needed Behaviors placed directly in an actor run automatically all the time.
if / if-else Rule with Otherwise A Rule stays "live"; it re-checks every frame.
wait (n) secs Timer (After) Nothing pauses; the Timer runs its contents later.
repeat / repeat until Timer (Every) or Loop Loop repeats instant actions while (or until) a condition holds. It has no count box; use a counter attribute.
Variable "for this sprite only" Actor attribute (self) Every instance, including spawned ones, gets its own copy.
Variable "for all sprites" Game attribute Shared by every actor and kept across scene changes.
List Table Tables are grids with rows and columns, stored at the game level.
Clone / create clone Spawn Actor The new actor is a fresh copy of the blueprint, not of the spawning actor.
when I start as a clone The spawned actor's own rules They start as soon as it appears.
Broadcast / when I receive No direct equivalent Use a game attribute as a flag that other actors' Rules watch.
Green flag Scene starts All actors' top-level behaviors begin when the scene loads.
when key pressed Rule: key is down Keys are only "down" or "up".
when this sprite clicked Rule: touch is pressed Works for mouse clicks and finger taps.
touching sprite? Rule: overlaps or collides with Uses the actor's rectangle or circle shape, not its pixels.
say / think Display Text Text is drawn on the actor itself; there are no speech bubbles.
move (n) steps Move Move sets a speed in pixels per second, not a jump per step.
glide Interpolate or Move To Interpolate changes any number smoothly over a set time.
stop all Pause Game, Reset Scene or Reset Game There is no single stop button inside a game.

Events, control flow and timing

In GameSalad, an "event" is just a condition that becomes true, and the Rule notices it on the next frame. The available conditions are key down or up, touch (pressed, released, inside, outside), mouse button and mouse position, "overlaps or collides with", and comparisons of attributes or expressions. Conditions can be combined with all (every one must be true) or any (at least one).

Because nothing pauses, sequencing works differently. A Scratch script "say Hello, wait 2, say Bye" becomes a Timer set to After 2 seconds holding the second step. Longer sequences are easier to build with a state attribute, such as a text attribute set to "intro", "playing" or "gameover", with one Rule per state.

The Timer has three modes, and together they replace most Scratch timing blocks.

Timer mode Scratch pattern it replaces
Every n seconds forever + action + wait n
After n seconds wait n then an action
For n seconds Do something for a while, then stop

Timing is based on real seconds, not frames. Scratch loops run once per frame, so repeat 30 takes one second at 30 frames per second. GameSalad behaviors like Move and Rotate use per-second rates, so they behave the same whatever the frame rate. Numbers copied straight from a Scratch project usually need re-tuning.

For example, Scratch's "forever, move 10 steps" moves 300 pixels per second. That happens to be the Move behavior's default speed of 300. On a 1024 × 768 scene everything is about 2.13 times bigger, so the same on-screen pace is about 640.

Data: variables and lists become attributes and tables

Scratch variables become attributes, and the main new idea is where an attribute lives. GameSalad has three scopes students create themselves.

Scope Scratch equivalent Lives for
Actor attribute (self) "For this sprite only" That one actor, until it is destroyed or the scene ends
Scene attribute No equivalent The current scene only
Game attribute "For all sprites" The whole game, across every scene

Attributes have a type: integer, real (decimal), text, boolean (true/false), angle or index. Types quietly change values. An integer attribute rounds anything stored in it, and an angle attribute wraps into the 0–360 range.

Actors cannot read each other's attributes. If an enemy needs the player's position, the player copies its x and y into game attributes, and the enemy reads those. Students coming from Scratch will look for the sensing block (x position) of (Sprite1), which has no GameSalad equivalent.

Scratch lists become tables. A table is a grid with named, typed columns and numbered rows starting at 1. Change Table Value and Add/Remove Row modify it, and table functions in the expression editor read from it.

GameSalad can also save data between play sessions. Save Attribute and Load Attribute store a value under a name on the device, and Save Table stores a whole table. This makes high scores and saved progress possible, which Scratch cannot do without cloud variables.

Motion, physics and collisions

GameSalad positions, angles and edges all use different conventions from Scratch, so ported coordinates must be converted.

Idea Scratch GameSalad How to convert
Origin (0, 0) Center of stage Bottom-left corner of scene —
x −240 to 240 0 to scene width GS x = Scratch x × 2.13 + 512
y −180 to 180 0 to scene height GS y = Scratch y × 2.13 + 384
Angle 0 points Up Right GS angle = 90 − Scratch direction (add 360 if negative)
Positive turning Clockwise Counter-clockwise "Turn right" in Scratch lowers the GS angle
Angle range −180 to 180 0 to 360 (wraps) —

Examples: Scratch 90 (right) is GameSalad 0. Scratch 0 (up) is 90, Scratch 180 (down) is 270, and Scratch −90 (left) is 180.

Scratch's stage is 480 × 360, while a Creator 2 scene defaults to 1024 × 768. Both are 4:3, so one scale factor (1024 ÷ 480 ≈ 2.13) works for x and y; the formulas above assume that default size.

Actors can leave the screen. Scratch always keeps at least a sliver of a sprite visible, but GameSalad does not stop actors at the edge. An actor is removed automatically once it is farther outside the scene than the scene's larger side (1024 px on the default scene), unless that edge wraps. Students need walls, a position rule, or scene edge-wrapping to keep things in play.

GameSalad has a built-in physics system, which Scratch lacks. Each actor has settings for movable, density (weight), friction, bounciness, drag and a collision shape (rectangle or circle). Scenes have a gravity setting, which is zero until you change it.

One behavior and one condition handle contact.

  • Collide makes an actor physically bounce off or stop at another actor type or tag. It is continuous.
  • Overlaps or collides with is a Rule condition. It detects contact so you can change score, play a sound or destroy something.

Most games need both: Collide for the physical response, and a Rule for the game logic.

Tags group actor types, for example "Enemy" or "Wall", so one Rule can target all of them. Collision uses the actor's rectangle or circle, not its visible pixels. Transparent corners of an image still count as "touching", and there is no "touching color" condition.

Scratch's layer stack becomes scene layers. A scene has several layers drawn back to front, and actors are ordered within each layer. A layer can be set to scroll with the camera or stay fixed, which is how score displays stay on screen. Spawn Actor lets you place the new actor in front of or behind the spawner, or at the front or back of the layer.

Communication and cloning

GameSalad has no broadcast block, so actors communicate through shared game attributes. The sender changes a game attribute, and receivers have Rules watching it. Think of a class noticeboard rather than a loudspeaker.

A Scratch "broadcast Game Over" becomes three steps.

  1. Create a game attribute, for example a boolean named GameOver.
  2. The sending actor uses Change Attribute to set GameOver to true.
  3. Each receiving actor has a Rule "when GameOver is true" containing its response.

"Broadcast and wait" has no direct match either. When one actor must wait for another to finish, use a second attribute as a reply, such as a Done flag the receiver sets. A text state attribute ("menu", "playing", "won") often replaces a whole set of broadcasts at once.

Spawn Actor replaces cloning, with one difference. A Scratch clone is a copy of the sprite that made it, including its current variable values. A spawned actor is a fresh copy of the blueprint, starting with its default values.

Each spawned actor gets its own actor attributes, just like "for this sprite only" variables. Game attributes stay shared by everyone. You cannot hand a spawned actor special values when it is created, so pass information through game attributes instead.

A common pattern is a separate, invisible controller actor. It holds a Timer (Every 2 seconds) with a Spawn Actor inside. The spawned actor carries its own Move behavior and its own clean-up Rule.

Prototypes and instances are new to Scratch students. Edit the actor in the Library, and every copy in every scene changes. To make one placed copy different, use "Unlock instance from prototype"; its changes then affect only that copy. To override a single attribute on a placed copy, click the lock icon beside that attribute (it has no hover label).

Common misconceptions

These are the traps students hit most often, with what you will see and how to fix it.

What students say What you'll see Fix
"My Change Attribute only works once." A Rule adds 1 to score, but holding the key or staying in contact adds only one point. This is correct: instant actions fire when the Rule becomes true. For repetition, put the action inside a Timer (Every), or use Constrain Attribute for a value that updates constantly.
"Where is the forever block?" Students hunt for a loop to wrap their behaviors in. Behaviors placed directly in an actor already run all the time. A top-level Move moves the actor forever.
"Wait didn't pause anything." Students expect the next behavior to wait for a Timer, and everything happens at once. Nothing pauses. Place the later steps inside a Timer (After), or use a state attribute to step through.
"My actor disappeared." An actor walks off the screen and never returns, or vanishes entirely. There is no automatic edge stop. Add wall actors with Collide, a Rule that keeps x and y inside the scene, or turn on edge-wrapping.
"It points the wrong way." A ported direction of 90 makes the actor face up, not right. GameSalad's 0 points right and angles grow counter-clockwise. Use GS angle = 90 − Scratch direction.
"It moves way too fast (or slow)." "Move 10" barely creeps along. Move's speed is pixels per second, not per step. Scratch "move 10 per frame" is 300 pixels per second, or about 640 on a 1024 × 768 scene.
"It stops as soon as I let go." A Move inside a "key is down" Rule stops when the key is released. Continuous behaviors stop when their Rule turns false. That is usually what you want for arrow-key controls.
"Everything bounces." A player lands on a platform and bounces like a ball. Bounciness starts at full. Set it to 0 on players, platforms and walls, and make floors non-movable.
"They touched, but not really." Collisions trigger before the visible art meets. Collision uses the actor's rectangle. Trim transparent space from images, or choose the circle shape for round objects.
"How do I get another actor's value?" Students look for Scratch's (x position) of (Sprite) block. The owner copies the value into a game attribute with Constrain Attribute, and others read that.
"My equals test is sloppy." A Rule checking x = 100 is also true at 100.05. Number equality in conditions allows a 0.1 margin. Use > or < when precision matters.

Classroom guidance

A short transition unit of five or six lessons works best when students port a game they already understand. They can focus on the new model instead of new game design.

Suggested sequence

  1. Rules, not scripts: rebuild a single Scratch sprite that moves with arrow keys. Contrast "key is down + Move" with "key is down + Change Attribute".
  2. Instant versus continuous: students predict, then test, what each behavior does when its Rule stays true. Introduce Otherwise.
  3. Coordinates and angles: convert five Scratch positions and directions on paper, then place actors to check.
  4. Attributes and communication: add score and lives as game attributes, shown with Display Text. Replace a broadcast with a game-attribute flag.
  5. Collisions and physics: add walls with Collide, tags for enemies, and an "overlaps or collides" Rule for scoring. Tune bounciness and friction.
  6. Spawning and timers: add a controller that spawns objects with a Timer (Every). Add a Change Scene for game over.

Starter project: Pong or "catch the falling objects"

Both are common Scratch projects and touch every topic above. Pong exercises key controls, bouncing, walls, a shared score and a win scene. The catch game adds Spawn Actor, Timers, destroying objects and edge clean-up.

Have students keep their Scratch version open while porting. Each time a block has no direct match, they record the GameSalad pattern they used and why.

Assessment ideas

  • Prediction questions: show a Rule and ask, "Does this happen once, or every frame? What happens when the condition turns false?"
  • Translation cards: give a short Scratch script and ask for the GameSalad Rule, Timer and attributes that match it.
  • Bug hunts: hand out a project containing one misconception from the table above. Students describe the symptom, name the cause and fix it.
  • Data design: ask students to justify, for each value in their game, whether it belongs on the actor, the scene or the game.

Bring GameSalad to your classroom

Lesson plans, step-by-step tutorials, a Teacher Dashboard, and Bowlbot with per-class controls. Tell us about your classes and we'll send a quote.

Request a quote

Request a quote