Cloud Data

(☁ var)

This article or section uses Cloud Data. Users who are New Scratchers or are using the Offline Editor cannot make projects using Cloud Data or use it in other users' projects. To use Cloud Data, the Scratcher status is needed and the Online Editor has to be used.

The process to create a cloud variable in Scratch 3.0 is much the same as creating a regular variable; the only difference is checking the "cloud variable" box. By default, cloud variables are enabled for all sprites.

The note that appears after creating the first cloud variable in a project.

A cloud variable in the list of variables

Cloud data is a feature that allows users to store number-containing variables "in the cloud," or on Scratch's servers. These variables are shared between all computers running a project, which allows different user's computers to communicate. Cloud variables have the character "☁" (a cloud icon in the font Scratch uses) in front of them, to distinguish them from regular variables. It may appear as something other than the standard cloud symbol if a user's computer does not support the default Scratch font.

Cloud variables update automatically, as opposed to requiring a refresh before updating. While the update is not instant, it is usually updated relatively quickly.

“	If both Scratchers have a reasonably fast Internet connection (DSL/Cable), and there are no restrictive firewalls on the computers/network, updates should be transmitted in milliseconds. However, many computers have firewall software running in them, and if the firewall software blocks outgoing connections to TCP port 531 and TCP port 843, the time-lag becomes one-second.	”
– FAQ Page

Cloud data can't be used by New Scratchers. The Scratch Team does not want people new to Scratch misusing cloud variables, as it could put a large load on the system that it cannot handle, most likely leading to the feature not working (see section "Issues with Cloud").

Cloud variables use the regular blocks associated with variables. The only difference is that the value is truly global, and is reflected across all copies of the project being viewed on the Scratch Website.

Cloud data is referred to as "persistent" in the code and some early development versions.

Since cloud data is stored on the server, cloud variables cannot be used in the Offline Editor.

Though it is possible to create chatrooms with cloud data, such projects are forbidden by the Scratch Team because they are too difficult to moderate.

Functionality

Cloud variables are maintained through a secure Websockets connection.

To avoid overloading the cloud data infrastructure, cloud data updates are limited to a certain number per second when a project is being run. One should always avoid attempting to update a cloud variable in a fast loop that does not wait between updates. Generally, one should carefully consider how often a cloud variable is updated and try to limit any updates to only times when it is needed, such as when the value actually changes, and to limit how often the variable is updated on the server.

If a variable is being updated too often, the cloud data server will drop the connection temporarily and updates will not be sent to the cloud data servers until the connection is automatically re-opened after a variable waiting period.

There is a limit of ten (10) cloud variables per project. Cloud variables can contain only numbers (unlike regular variables, they can't contain letters or symbols). A character limit of 256 digits per variable has also been implemented (formerly 128 digits). Hexadecimal numbers are no longer supported. Cloud Variables can only be updated ten times per second at most.

Example Uses

• High Scores/Leaderboards

if <(local score) > (☁ high score)> then
  set [☁ high score v] to (local score)
  else
  say [You didn't beat the high score!]

• Win/Loss (so long as scores don't end in zero digit)

if <(human score) > (computer score)> then
  set [☁ won v] to (join (join (human score) [.]) (computer score))
else
  set [☁ lost v] to (join (join (human score) [.]) (computer score))

• Surveys

ask [Vote for Option 1 or Option 2!] and wait
if <(answer) = [Option 1]> then
  change [☁ option 1 votes v] by (1)
else
  if <(answer) = [Option 2]> then
    change [☁ option 2 votes v] by (1)
  else
    say [Sorry! That answer wasn't recognized.]
end

Cloud Lists

Many Scratchers have suggested that the Scratch Team add cloud lists into Scratch. The ST has rejected these suggestions.

During Scratch 2.0's earliest alphas, Cloud Lists were shown as an option, but this was removed before release.

“	However, cloud lists would require similar restrictions as listed above, and the issues currently presented with cloud variables would only grow with the addition of cloud lists. You can still use cloud variables to create a list which contains entries everyone can see, but the Scratch Team will not be adding an easy official way to make cloud lists.	”
– Za-Chary, The Official List of Rejected Suggestions

Cloud List Engines

Main article: Encoding and Decoding Cloud Data

Main article: Simulating a Cloud List

Main article: Global High Scores

Warning:

Using this functionality for cloud chat projects that use blacklisting or whitelisting of individual words can't be shared on Scratch, and can lead to a temporary ban.

Cloud list engines are projects or scripts that store lists in cloud variables. To do this, they encode a list as a number and store the number in a cloud variable. Later, the same code can turn the cloud variable back into a list. This was developed based on the idea that anything in the world can be represented with numbers. For example, all letters in the alphabet could be stored as a number by assigning each letter a number from 1 to 26. A few examples of cloud list engines can be found here and here. It can use base 11 for only numbers and convert it to base 10. Then to decode it, it will have to convert to base 11.

Basic Logic

Since cloud variables support only numbers, the goal of cloud lists is to convert each character into a numeric code. Even <space> should have its own. Separation of entries will also have its code. Two custom blocks, encoding and decoding the list, will be provided. All codes should be saved in a list.

Encoding

Encoding the list is very simple. The encoder will convert the characters into the numeric code and join the entry separator's code at the end. But a case detector will also be needed to detect the correct case.

Decoding

To decode the list, another list will be needed. The character codes would be separated and stored in this list. To do this, every numeric code should be of the same length i.e., 001, 002 or 00, 01, etc. The codes will then be converted into characters.

Cloud Data History

When the Scratch Team released the beta version of cloud data, they set up public logs for projects with cloud data in them showing the time cloud data was modified, who modified the data, the current value of the data, and the type of action of the data modification (such as del_var, rename_var, and set_var). To get onto the log simply click on the cloud data button at the bottom of a project page. This will then show the users who changed the cloud data and at what time. If a user who is not the owner of the project changes cloud data blocks by seeing inside, any changes they make to the cloud data will not be saved to the server.

Upon the release of Scratch 3.0, the Scratch Team mistakenly set the limit to eight cloud variables per project instead of ten. On January 9, 2019, the Scratch Team announced that this was fixed.

Sharing Broadcasts

Cloud data is similar to Mesh. Both features allow sharing of variables across multiple simultaneous uses of the same project. By using variables, cloud data can also simulate broadcasts across projects, as shown in the scripts below:

when gf clicked
set [old broadcast v] to (☁ broadcast)
forever
 if <not <(old broadcast) = (☁ broadcast)>> then
  broadcast (cross-project message v)
 set [old broadcast v] to (☁ broadcast)

when I receive [cross-project message v]
. . .

when [space v] key pressed // This script will "broadcast"
change [☁ broadcast v] by [1]

An optimized version would replace

broadcast (cross-project message v)

for with a When I Receive block for each possible broadcast.

Due to cloud data limitations, a project using this method of broadcasting can only use broadcasts with numbers for messages.

Using Hexadecimal

This article or section documents something not included in the current version of Scratch (3.0). It is only useful from a historical perspective.

Cloud data used to be able to store hexadecimal numbers, but this feature was removed.^[when?]

Numbers encountered everyday are called "base 10" or "decimal" numbers. This is because 10 different digits are used (0 through 9). However, hexadecimal (often shortened to "hex") is another way of representing numbers. It uses 16 different digits. Since 16 digits do not exist when working with base-10, the "digits" a-f are used to represent digits 10 through 15. This means that "14" in base-10 is "e" in base-16. Cloud Data supports base-16, if the value starts with a "0x". For example, to set a Cloud Variable to "e" (14) one would run the block set [☁ Variable v] to [0xe]

Since each digit of a hexadecimal number stores more information than its decimal equivalent, it may help store more data before reaching the character limit (useful if a project requires lots of storage in Cloud Variables). To encode a base-10 number into a base-16 number one could run the following script (assuming that a whole number [integer] is being converted):

define convert to base-16 (number)
set [digits v] to [0123456789abcdef]
set [output v] to []
set [temp v] to (number)
repeat until <(temp) = (0)>
set [output v] to (join (output)(letter (((temp) mod (16)) + (1)) of (digits))) // Remainder on division by 16
set [temp v] to (([floor v] of (temp)) / (16))
end
set [output v] to (join [0x] (output)) // optional; use if one want to ensure decoding works

Use (output) to get the result from this. To convert back, simply run any of the following blocks and they will all return the base-10 value of the block:

((☁ HexVariable) + (0))
((☁ HexVariable) - (0))
((☁ HexVariable) * (1))
((☁ HexVariable) / (1))

Scratch retains the case of the hexadecimal digits, so it will remember if a variable was saved as "0xe" or "0xE" on the Cloud. To detect case read this article. Therefore base-22 can be used by using uppercase A-F and lowercase a-f as separate digits, to produce the 22 digits: "0123456789abcdefABCDEF". This will no longer allow for simple conversion back to base-10. To convert from base-22 to base-10, the following custom blocks must be used:

define letter number of (character) in (string)
set [counter v] to [1]
set [output v] to [0] // This will be what happens if it is not found
repeat (length of (string)) // For every character
if <<(character) = (letter (counter) of (string))> and <case sensing :: grey>> then // If a match is found
set [output v] to (counter)
stop [this script v]
end

define to base-10 (hex)
set [placevalue v] to [1] // Represents how much each hex digit is worth
set [counter v] to (length of (hex)) // Represents the digit it is decoding
set [result v] to [] // This will store the final output
repeat (length of (hex)) // It starts from the end and works its way back
letter number of (letter (counter) of (hex)) in [0123456789abcdefABCDEF]
set [result v] to (join (result) ((output) * (placevalue)))
change [counter v] by (-1) // Because it is working in reverse
set [placevalue v] to ((placevalue) * (16))
end
// The base-10 output is stored in the variable "result"

Issues with Cloud

In October of 2016, the cloud infrastructure started to fail occasionally. As a result, many multiplayer-focused projects did not work correctly. This has been attributed to the ever-increasing number of active users who are using cloud variables, with some projects sending up to 30 requests per cloud variable per second. This effectively "spammed" the cloud server with a load that couldn't be handled by the current infrastructure and shut it down.

As a temporary fix, cloud variables have switched to using a different polling method, which is more reliable but significantly slower. Furthermore, the polling interval time was increased, to prevent spam. This new method works but may cause cloud variables to "rubber band" and reset to a previous value after it has been changed, as well as making many multiplayer projects less "real-time" or completely breaking them in general.

Hacking Cloud Data

Some people try to hack cloud variables, such as to get the highscore. See Hacking Cloud Variables for more info.

Long-term

As of August 2017, a new cloud data system was in beta. It used secure WebSockets as the communication channel. To use the new system, one could add ?newcloud to the end of the URL address to a project. The system is now the default.

Remixing or Backpacking

If a New Scratcher remixes a project with cloud data or backpacks a sprite or script with cloud data blocks, or a Scratcher imports a sprite from the backpack and the resulting number of cloud variables in the project and the new backpack item are more than ten, the/some of the new cloud variables will become normal variables but will still have cloud icons that cannot be removed.

See Also

• Global High Scores
• Variables Blocks
• Mesh
• Variable
• Creating a Multiplayer Game
• Sending Cloud Data Signals
• Encoding and Decoding Cloud Data