Newly Enhanced Cloud Variables

CreatiCode

Introduction

Cloud variables are a powerful tool in MIT Scratch for creating multiplayer programs. CreatiCode has enhanced them further, making them even more capable. In this tutorial, you’ll learn how cloud variables work in the CreatiCode playground.

Basics of Cloud Variables

When creating a new variable, you can check the “cloud variable” box:

If the project is shared and opened by other users, the value of that cloud variable will be synchronized across all their computers automatically.

For example, imagine 10 users are running the same project at the same time. If one user changes the value of a cloud variable, the other 9 users will instantly see the updated value.

Here’s what happens behind the scenes:

User A changes a cloud variable using a “set variable to” or “change variable by” block.
User A’s computer sends the new value to the CreatiCode server.
The server broadcasts the update to the other 9 users running the same project.
Each of those users receives the message and updates the cloud variable on their own computer.

A Simple Example

Here is an example project: play.creaticode.com/projects/68473cea3d952dd83a76d160

It has one dog sprite with this code:

When the program starts, the sprite keeps saying the value of the cloud variable “counter.”

Whenever any user clicks the sprite, the value of “counter” increases by 1— and all other users running the same program will instantly see the new value.

You can try this by opening the project in two browser windows (one normal and one incognito). Make sure you’re logged in, as cloud variables only work when you’re signed in. Of course, you can also try this with a friend on 2 computers.

Here’s what it looks like across two sessions:

The “When Variable Changes” Block

To make working with variables easier — especially cloud variables — CreatiCode has added a new event block:

This block runs whenever the selected variable changes (i.e., when its value becomes different). Note that if you set a variable to its current value, then this block won’t be triggered.

It works with both regular and cloud variables. This means you no longer need a forever loop to constantly check the variable — you can run code only when the value actually changes.

Here’s how we can rewrite the earlier example using this block:

When the green flag is clicked, start a long wait so the program stays running. Cloud variable updates won’t work if the project isn’t running.
When the sprite is clicked, increase the counter as before.
When the counter changes, the sprite says the new value.

You can try it here: play.creaticode.com/projects/684747163d952dd83a76d79c

Number of Cloud Variables

MIT Scratch limits you to 10 cloud variables per project. In CreatiCode, you can use up to 100. This allows you to build much more advanced multiplayer projects.

Accepted Values and Update Frequency

In MIT Scratch, cloud variables:

Can only store numbers
Can only update at most 10 times per second

These limits were put in place to block users from building chat rooms, but they also make cloud variables harder to use.

In CreatiCode, cloud variables support any type of value, with some important rules:

If the value contains letters (a–z), it must pass a moderation check to filter inappropriate content. These values can only be updated once per second per user. That’s still fast enough for chat room projects.
If the value does not contain letters, like 120 or "1_23_44", it bypasses moderation and can be updated up to 20 times per second per user. This is useful when you want to send multiple numbers in a single update. For example, to send X = 50 and Y = 80, you can combine them into one value of "50_80".

Cloud Sessions

In MIT Scratch, everyone running the same shared project receives the same cloud variable updates. To isolate groups, you’d have to make separate copies of the project.

CreatiCode introduces cloud sessions, which limit cloud updates to just the users in the same session. If a user hasn’t joined a session, they’re placed in the default session.

To join a session, use this block from the “Variables” category:

This block takes about 1.5 seconds to run and should be used before updating any cloud variables.

The session name is just a string that users agree to use. Only users in the same session will receive each other’s cloud variable updates—even if they’re running the same project.

Here’s how to add the block to our earlier example:

Private Cloud Variables for Clones (Advanced)

In MIT Scratch, cloud variables are always global — shared across all sprites and clones. This creates problems when you’re working with clones.

For instance, suppose a car sprite creates 2 clones: Clone 1 and Clone 2. If you use a global cloud variable like “facing direction,” then changing it to 90 will affect both clones — even if you only meant to rotate one.

To fix this, CreatiCode lets you create private cloud variables for each sprite or clone:

Now, each clone will have its own cloud variable, separate from the others. For example, all users’ “Clone 1” will share one variable, and “Clone 2” will share another.

Example for Private Cloud Variables

Here is an example project: play.creaticode.com/projects/6847575f1c49cae45091d685

When the green flag is clicked, the original dog sprite hides and creates two clones, with IDs 1 and 2:

Each clone shows itself, says its clone ID, and moves to one side of the stage:

Now, when a clone is clicked, it increases its own private cloud variable called “direction” by 15. This triggers only that clone to rotate:

As a result, when any user clicks on a dog clone, that specific clone rotates on every computer — but the other clone is unaffected:

We hope you enjoy these new features, and we can’t wait to see the amazing multiplayer projects you’ll build with them!