Read a stop, then play the games to earn ⭐ and grow your garden! 🌱
Key Point: Position update on x-axis when using 'change x by S': x_new = x_old + S
What is Scratch?
Scratch is a block-based visual programming language made for beginners (especially children). Instead of writing text code, you snap together colorful blocks that represent commands. It helps learn fundamental programming ideas—sequence, loops, conditions, events and variables—by creating interactive stories, animations and games.
Main parts of the Scratch environment
Basic programming ideas in Scratch
How to create a simple script — example: Make a sprite move and say hello when green flag is clicked
1. Events: when green flag clicked
2. Motion: go to x:0 y:0
3. Looks: say "Hello!" for 2 seconds
4. Control: repeat 10
Motion: change x by 10
end
This script starts with an event, sets position, shows a message, then moves the sprite to the right in 10 small steps.
Why Scratch is useful
Scratch builds logical thinking and creativity. Students see immediate visual results, which makes abstract computing ideas concrete and fun. It is used to create animations, interactive stories, quizzes and games.
Key Point: Stage coordinate limits: x in [-240, 240], y in [-180, 180]
Scratch is a block-based coding environment where children build programs by dragging and snapping colored blocks. The Scratch interface is the screen layout that helps you create, test and control your projects. Knowing each part of the interface helps you quickly make animations, games and stories.
1. Stage: The big area where your sprites act and where the project is shown. It uses a coordinate system with x (left to right) and y (bottom to top).
2. Sprite Pane (Sprites List): Shows all sprites in the project. You can add, delete, or choose a sprite to edit.
3. Sprite Info: Under the stage you see the selected sprite's name, x and y position, direction, size and costume. You can directly change these values to place the sprite.
4. Blocks Palette: The left side contains categories of blocks (Motion, Looks, Sound, Events, Control, Sensing, Operators, Variables). Each category has color-coded blocks you drag into the Scripts Area.
5. Scripts Area (Coding Area): The central panel where you drag and snap blocks together to make scripts for the selected sprite.
6. Tabs for Costumes and Sounds: For the selected sprite you switch to Costumes to draw or change appearance and to Sounds to add audio.
7. Toolbar and Green Flag / Stop: Top controls include the green flag to start scripts, the red stop button to stop them, and project options like save, share and project name.
Blocks snap together like puzzle pieces. An Event block (for example when green flag clicked) starts a script. Control blocks (repeat, if) change flow. Motion blocks change position and direction. Blocks are executed from top to bottom. You can test scripts by clicking blocks or the green flag.
- Stage coordinate ranges: x from -240 to 240 and y from -180 to 180. - Sprites have costumes and can be moved with motion blocks or by changing x and y values. - Use Events and Control blocks to make the sprite respond to clicks, key presses, or repeat actions.
Key Point: Position on stage: a sprite has coordinates (x, y). Origin (0,0) is the center of the stage. x increases to the right, y increases upward.
What is a sprite? In Scratch a sprite is a character or object that can move, look, and interact on the stage. Each sprite has properties like position (x, y), direction (which way it faces), size (percentage), visibility (show/hide) and one or more costumes.
What are costumes? Costumes are different appearances or images for the same sprite. By switching costumes quickly, a sprite can be animated (for example, walking, talking, or changing clothes) without needing multiple sprites.
Teaching tip for Class 5: Use familiar examples (a person waving, a car with changing wheels, a traffic light) to show how the same sprite changes its look instead of creating new sprites.
Key Point: Stage width = 480 px; Stage height = 360 px.
What is the Stage?
The Stage in Scratch is the background area where your sprites act. It is the scene or “stage” of your project and holds backdrops (different background images). Sprites always appear in front of the Stage.
Stage size and coordinates
What are Backdrops?
Backdrops are images used on the Stage to show different scenes (for example: classroom, playground, night sky). A project can have many backdrops and you can switch between them to create scenes, levels, or animations.
How to add and edit backdrops
Blocks to control backdrops
How to use backdrops in projects
Tips
Key Point: new_x = x + 10 (move right 10 steps using 'change x by 10')
What are blocks? In Scratch, a block is a small piece of code you drag and snap with other blocks to tell a sprite what to do. Blocks are the building blocks of programs — they fit together like puzzle pieces so you do not have to write text code.
Where you use them: You drag blocks from the block palette into the scripts area (work area) for a sprite. Stacks of blocks that make a set of instructions are called scripts.
Block shapes and how they behave
Main block categories (each category has its own color and purpose):
How blocks work together: You usually start with an Events hat block (for example, when green flag clicked), then add Control blocks (repeat, if) and command blocks (Motion, Looks) to create an action. Reporter and Boolean blocks provide values and conditions for other blocks.
Simple rules and tips:
Key Point: When a sprite moves 's' steps while facing direction 'd' (degrees in Scratch), the change in coordinates is approximately: Δx = s × sin(d × π/180) Δy = s × cos(d × π/180) (Use sin and cos with d converted to radians; this matches Scratch directions where 90° → right and 0° → up.)
In Scratch, Motion blocks make a sprite move, turn, and change position on the stage. The stage is a coordinate plane with an x-axis (left <– > right) and a y-axis (down <– > up). Motion blocks let you change a sprite's x and y coordinates, point it in a direction, glide smoothly, or make it bounce off the edge.
Common Motion blocks and what they do:
How movement works (intuitively): when a sprite moves, its x and y positions change. If it is pointing right, its x increases; if it is pointing up, its y increases. Combining moves and turns lets sprites travel in straight lines, curves, or follow paths.
Simple rules to remember:
Teachers' tip: use small numbers first (move 10 steps, turn 15°) so students can see how each block changes position. Use the "x position" and "y position" monitors to watch coordinates change as a script runs.
Key Point: Say/Think syntax: say [text] for (seconds) OR think [text] for (seconds)
What are Looks blocks? In Scratch, the Looks blocks control how a sprite or the stage appears: what it says, how it looks (costumes, size, color effects), and whether it is visible or hidden. Looks blocks let you change a sprite's costume to animate it, show messages with speech/thought bubbles, change size and visual effects, and arrange which sprites appear in front.
You combine Looks blocks with Motion, Control and Sensing blocks. For example, while a sprite moves (Motion) you change its costume (Looks) at short time intervals (Control wait) to create a walking animation. Or when a sprite collides with an object (Sensing), you change its color effect (Looks) and reduce size to show damage.
Key Point: Seconds per beat = 60 ÷ tempo (in beats per minute). Example: at tempo 120 BPM, 1 beat = 60 ÷ 120 = 0.5 seconds.
In Scratch, Sound Blocks let you add music, effects and spoken words to projects. They control what sound plays, how loud it is, how long it lasts and the speed (tempo). Sound blocks are in the Sound category and are often used with Events and Control blocks to make interactive stories and games.
Common Sound blocks and what they do:
How to use them in a project: choose or record sounds in the Sounds tab, then drag sound blocks into scripts. Use "play sound until done" for single-step narration or music, and "start sound" when you want sound effects while other actions continue. Use tempo and beats when composing melodies so note durations match.
Tips: use small volume changes for subtle effects, place "stop all sounds" when restarting a scene, and use beats + tempo formula to time music precisely.
Key Point: when [event] -> do [actions] (general event-action pattern)
What are Events?
In Scratch, an event is something that happens and tells the program to start a set of blocks (a script). Events are like signals or triggers. Event blocks (called hat blocks) sit at the top of a stack and begin action when the event occurs.
Why events are important
Events let sprites and the stage react to clicks, key presses, messages, or other changes. They make projects interactive and allow many scripts to run at the same time (concurrency).
Common event types in Scratch
How to use events
Choose an event hat block as the top block of a script. Under it, attach blocks that tell the sprite what to do when the event happens. Use broadcast and when I receive to make different sprites or scripts react to the same signal.
Tips for beginners
Keep each script focused on a single event (for example, one script for key presses, another for broadcasts). Use broadcasts to separate tasks: one broadcast to start the game, another to end it.
Key Point: Total time for repeated wait: total_time = repeat_count × wait_seconds (e.g., repeat 20 with wait 0.5 → total_time = 20 × 0.5 = 10 seconds).
What are Control Blocks?
Control blocks in Scratch are the blocks that tell a program when to start, how many times to repeat actions, how long to wait, and what to do when certain conditions or events happen. They manage the flow of the script — the order and timing of actions.
Main types of control blocks (with short meaning):
How they work together: Control blocks are used with motion, looks, sound and sensing blocks to build animations, games and interactive programs. For example, a forever loop can keep checking if a sprite is touching the edge, and an if block can make it bounce back.
Tips for students: Use wait to control speed, repeat for a fixed number of steps (like walking a set distance), and broadcast to make different sprites work together.
Key Point: Conditional example: if (touching color "#ff0000"?) then (change x by -10)
Sensing blocks in Scratch are blocks that let a sprite "sense" events, player actions, or values from the environment. They give information (answers) that scripts can use to make decisions — for example, whether a key is pressed, how loud a sound is, where the mouse is, or what the user typed.
Common sensing blocks and what they do:
How sensing blocks are used: usually a sensing block is placed inside an if or repeat until control block or combined with operators to decide what the sprite should do next. For example, a sprite can ask the user their name and then say "Hello, [answer]!" or it can move back when touching a wall color.
Simple script examples (in words):
Tips for students: test sensing blocks often (for example, watch the value of answer or timer) and combine sensing blocks with operators (and, or, not) to make smart decisions in your game or animation.
Key Point: Assignment (set): set [score] to 0 — puts a value into the variable.
What is a variable?
A variable is like a labelled box that stores information (a number or text) that a program can use and change. In Scratch, variables let your project remember things such as scores, lives, names, or timers.
How to create and use a variable in Scratch
set [variable] to [value], change [variable] by [number], and show variable [variable] / hide variable [variable].What can variables store? Numbers (for counting, measuring) and text (names, messages). You can use variables inside conditions (if ... then), loops (repeat, forever), and to control sprite behaviour.
Simple example in words: Create a variable called score. At the start of the game set score to 0. Each time the player collects a star use change [score] by 1. Show the score on the stage so the player can see it.
Key Point: Circle drawing (approximation): angle per step = 360 / n (where n is number of steps); use move and turn repeated n times.
What are Extensions in Scratch? Extensions are extra sets of blocks you can add to Scratch to give sprites new abilities not included in the basic blocks. Common extensions for Class 5 are Pen, Music, and Video Sensing. You add them from the blue "Extensions" button in the Scratch editor.
1. Pen Extension
The Pen extension lets a sprite draw on the stage like a pen. Main blocks include: pen down / pen up, set pen color, change pen shade, set pen size, clear. Use these blocks to draw shapes, patterns and pictures.
2. Music Extension
The Music extension adds blocks to play notes, drums and to set tempo. You can create melodies, accompaniments, and sound effects.
3. Video Sensing Extension
Video Sensing lets Scratch use a camera to detect motion and brightness. It can detect how much movement is in front of the camera or whether a color or brightness threshold has changed. This is useful for interactive projects controlled by body movement or gestures.
Simple example scripts (pseudocode)
// Pen: draw a square
when green flag clicked
clear
pen down
repeat 4
move 100
turn 90
pen up
// Music: play a simple melody
when green flag clicked
set tempo to 120
play note (C4) for (1) beats
play note (D4) for (1) beats
play note (E4) for (2) beats
// Video Sensing: change color when motion detected
when green flag clicked
turn video on
forever
if <(video motion) > 15> then
change color effect by 25
end
end
Tips for classroom use
Key Point: Distance between two x positions (approximate steps needed): steps_needed = abs(x2 - x1) (useful to decide how many 'move' steps to glide).
What is designing a Scratch project? Designing a Scratch project means planning what your program will do before you start dragging blocks. Good design helps you make projects that work, are fun, and are easy to change.
Steps to design a Scratch project
Key Scratch design ideas to remember
Tips for Class 5 students
Key Point: Algorithm = Step1 -> Step2 -> ... -> StepN (an ordered list of instructions)
Computational Thinking is a way of solving problems so a computer (or a person) can follow the steps. In Class 5 Scratch block coding, computational thinking helps us break problems into small parts and plan instructions using blocks.
Key Point: STOP - THINK - ASK (memory formula): Stop before acting + Think if it’s safe/kind + Ask an adult when unsure.
What it means: Safe and Responsible Use means using computers, the internet and apps (like Scratch) in ways that keep you, your friends and your work safe, respectful and healthy. It includes protecting personal information, being polite online, following rules, and using devices in a balanced way.
Key ideas:
Simple rules to remember: