Scratch Creating Animations

Introduction to Scratch

Scratch is a block-based visual programming language that helps young learners create stories, games and animations by snapping code blocks together. It uses colorful blocks (like puzzle pieces) so students can focus on logical thinking and creativity without typing complex code.

Main parts of Scratch:

• Stage – the area where the animation plays (backgrounds can be changed).
• Sprite – a character or object that you can animate (each sprite can have multiple costumes).
• Blocks palette – categories of blocks such as Motion, Looks, Sound, Events, Control, and Sensing.
• Scripts area – where you drag blocks together to make a script for a sprite.

How animations are made: Animations are usually created by changing a sprite’s costume repeatedly to show movement, and by moving the sprite across the stage. You trigger scripts with Events (for example: when green flag clicked), use Control blocks (repeat, forever) to loop actions, and use Motion blocks (move steps, go to x: y:, glide seconds to x: y:) to change position.

Important concepts for animation:

• Costume change – switch costumes to make a sprite appear to move (frame-by-frame animation).
• Timing – use wait or glide blocks to control how fast the animation plays.
• Loops – repeat costume changes and movements to create continuous action.
• Events & Broadcast – start animations and coordinate multiple sprites by sending and receiving messages.

Stage coordinates: The Scratch stage uses an (x, y) coordinate system. x runs left (negative) to right (positive), and y runs bottom (negative) to top (positive). The usual visible ranges are about x: −240 to 240 and y: −180 to 180. Knowing coordinates helps place sprites and make them move along paths.

Simple steps to create a basic animation (example workflow):

1. Choose or draw a sprite and give it 2–4 costumes for different frames.
2. Place the sprite on the stage where you want it to start.
3. Use an Event block: when green flag clicked.
4. Use a Control loop: forever or repeat N times.
5. Inside the loop, use next costume, move 10 steps, and wait 0.2 seconds to show movement and timing.
6. Use if on edge, bounce or change direction to make the sprite turn at edges.

Scratch makes it easy to experiment: change numbers, add sounds, or broadcast messages to create richer animations.

The Scratch Interface is the screen where you build animations and small programs using colourful blocks. It is designed for young learners to drag and snap blocks together to control sprites (characters) and the stage (background). Understanding the main parts of the interface helps you create animations faster and more easily.

• Stage: The large area on the left where your sprites move and your animation plays. You can change the backdrop and see x, y coordinates below the stage.
• Sprites Pane (Sprite List): Shows all sprites (characters) in your project. Click a sprite to edit its scripts, costumes, or sounds.
• Blocks Palette: The column of block categories (Motion, Looks, Sound, Events, Control, Sensing, Operators, Variables). Each category contains blocks you use to make actions.
• Scripting Area (Scripts Pane): The workspace where you drag blocks from the palette and snap them together to make scripts for the selected sprite.
• Costumes Tab: Lets you edit or add different looks for a sprite. Switching costumes creates frame-by-frame animation.
• Sounds Tab: Add or record sounds and play them in your animation.
• Toolbar and Green Flag / Red Stop: Use the green flag to start scripts that begin with the 'when green flag clicked' block and the red stop button to stop the project.
• Backdrop Library / Stage Editor: Choose or draw backgrounds for different scenes of your animation.
• Coordinate Display: Shows the sprite's current x (left-right) and y (up-down) positions. Useful for moving sprites to exact places.

How animations are usually made: Choose a sprite → add costumes for different frames → write scripts using Events (to start), Looks (next costume), Control (wait and repeat), and Motion (move, turn) blocks → test using the green flag → adjust timing and positions.

Tips for Class 4 students: use the 'next costume' block inside a 'repeat' or 'forever' loop with a small 'wait' block to make smooth animations; use 'go to x: y:' to place sprites exactly; use the 'when this sprite clicked' or 'when green flag clicked' blocks to start actions.

What is a Sprite?
A sprite in Scratch is any character or object that appears on the stage. Each sprite can move, speak, change size, and perform actions using blocks of code.

What is a Costume?
A costume is one appearance (look) of a sprite. A single sprite can have many costumes. Changing costumes quickly creates the effect of animation—like turning pages of a flipbook.

How sprites and costumes create animation

• Give the sprite several costumes that show small changes (for example, a person with left foot forward, then right foot forward).
• Use blocks such as next costume or switch costume to inside a loop.
• Add a wait block between costume changes to control the animation speed.

Common Scratch blocks used

• Looks: next costume, switch costume to [costume], show, hide
• Motion: move (10) steps, turn (15) degrees, go to x: ( ) y: ( )
• Control: repeat, forever, wait (0.1) seconds
• Events: when green flag clicked, when this sprite clicked, broadcast [message]

Practical points

• Design costumes in the Costume tab by drawing or importing images.
• Set the sprite’s rotation center (the small cross) to control how it turns.
• Use layering (go to front/back) so sprites appear above or below others.
• Use broadcasts to sync animations between multiple sprites (for example, background changes when a sprite finishes dancing).

Simple animation pattern (idea of blocks)
When green flag clicked
  forever
    next costume
    wait (0.1) seconds
    move (5) steps
  end

This sequence changes the sprite’s look and moves it, creating a running animation.

What are Backdrops and Scenes?

In Scratch, a backdrop is the background image for the Stage. A scene is one part of an animation or story that shows a particular backdrop and arrangement of sprites (characters and objects). By changing backdrops in order, you create different scenes and tell a story or show an event step-by-step.

Why use backdrops and scenes?

• They set the place and mood (for example: school, forest, night).
• They help the viewer understand changes in time or place (morning → afternoon → night).
• They make animations clearer and more interesting by separating actions into parts.

How to make scenes in Scratch (step-by-step)

1. Choose or create backdrops in the Backdrops tab (for example: "Morning", "Noon", "Night").
2. Place and dress sprites (costumes) so each scene looks correct.
3. Use control blocks to switch backdrops: switch backdrop to [backdrop name] or next backdrop.
4. Use wait [n] seconds between changes so viewers can see each scene.
5. Use broadcasts (messages) to tell sprites when to act: e.g., broadcast [NextScene] and in sprites use when I receive [NextScene] to start actions for the new scene.
6. Repeat or loop scenes if needed (for example, to make the scene cycle).

Useful Scratch blocks for scenes

• Events: when green flag clicked, when I receive [message]
• Looks: switch backdrop to [name], next backdrop, change color effect
• Control: wait [n] seconds, repeat, forever
• Events/Control: broadcast [message]

Simple example script (sequence of scenes)

When green flag clicked:
switch backdrop to "Morning"
wait 3 seconds
switch backdrop to "Noon"
wait 3 seconds
switch backdrop to "Night"

Tips for good scenes

• Keep changes simple: change one or two things per scene (backdrop and maybe a sprite pose).
• Use sound and movement together with backdrop changes for better effect.
• Plan scene order on paper first (storyboard) so the animation is clear.

What are Events?
In Scratch, an event is something that happens which makes a script start running. Events are used to tell a sprite when to begin its actions. Events are represented by hat-shaped blocks (called hat blocks) that sit at the top of a script.

Common event (hat) blocks:

• when green flag clicked — starts scripts when the green flag is clicked (often used to start the whole project).
• when this sprite clicked — starts a script when the user clicks that sprite.
• when key pressed — starts when a keyboard key (like space or arrow) is pressed.
• when backdrop switches to or when I receive [message] — start a script when the backdrop changes or a broadcast message is received. This is used to coordinate many sprites.

Starting scripts
A starting script is any sequence of blocks that begins with a hat block. When the event named by the hat block happens, Scratch runs the blocks connected under that hat. You can have many starting scripts in a project; each one runs when its event happens.

How to use events to create animation:

1. Choose an event hat block to begin the action (for example when green flag clicked).
2. Attach motion, looks, sound, and control blocks under that hat to make a short animation.
3. Use wait blocks to control timing and next costume to animate costume changes.
4. Use broadcasts (broadcast [message] and when I receive [message]) to start scripts in other sprites so many things happen together or in sequence.

Example script (in words)
Attach this under a hat block:

move 10 steps
wait 0.2 seconds
next costume
repeat 10

Important ideas
- Events start scripts, but the blocks under the hat decide what happens.
- Multiple scripts can run at the same time (concurrency).
- Broadcasts help coordinate actions between different sprites.
- Use wait to control the speed of animations and to make actions happen in order.

Teaching tip: Try different events (click, key press, broadcast) to see how the same animation can start in different ways.

In Scratch, Motion blocks control where and how a sprite moves on the stage. The stage uses an (x, y) coordinate system with the centre at (0, 0). Motion blocks include commands like "move __ steps", "go to x: __ y: __", "glide __ secs to x: __ y: __", "change x by __", "change y by __", "point in direction __", "turn clockwise __ degrees", "turn counterclockwise __ degrees", and "if on edge, bounce".

Key ideas:

• Position: A sprite has an x (horizontal) and y (vertical) position. Increasing x moves right, decreasing x moves left. Increasing y moves up, decreasing y moves down.
• Steps: "move <n> steps" moves the sprite forward in the direction it is pointing. In Scratch, a step is about one pixel on the stage.
• Direction: Direction is measured in degrees. In Scratch 0 means up, 90 means right, -90 (or 270) means left, and 180 means down. Turning changes the direction value.
• Glide vs move: "move" instantly shifts position by steps each time it runs; "glide" smoothly moves the sprite to a location over a set time (so it relates distance and time).
• Bounce: "if on edge, bounce" makes the sprite reflect its heading when it reaches the stage edge (like a ball bouncing).

Using these blocks we can make animations, control speed and direction, and design behaviour like walking characters, flying objects, or bouncing balls.

What are Looks Blocks?

In Scratch, Looks blocks change how a sprite or the stage appears. They control costumes, size, graphic effects (colour, brightness, ghost), visibility, speech/thought bubbles and backdrops. Looks blocks do not move a sprite (that is Motion blocks) — they only change appearance so sprites can talk, change clothes, glow, or disappear.

Common Looks blocks and what they do

• switch costume to [costume] — change the sprite's outfit or image.
• next costume — go to the next costume (useful for animation).
• show / hide — make the sprite appear or disappear.
• say [Hello!] for (2) seconds / say [Hello!] — make the sprite speak using a bubble.
• think [Hmm...] for (2) seconds / think [Hmm...] — show a thought bubble.
• switch backdrop to [backdrop] — change the stage background.
• change [color/brightness/ghost] effect by (10) — add or remove visual effects.
• set size to (100)% / change size by (10) — make the sprite bigger or smaller.

How Looks blocks create animations

To animate a sprite you often combine Looks blocks with Control blocks. Example pattern: repeat → next costume → wait → next costume... This flips costumes quickly so a sprite looks like it is moving (for example, a walking character or flapping bird). Changing graphic effects over time can make sprites glow, fade or change colour.

Tips for young programmers

• Use small wait times (like 0.1 seconds) between costume changes for smooth animation.
• Use show/hide to make things appear or disappear at the right moment.
• Combine speech blocks with costumes to make characters talk and move at the same time.

What are Sound Blocks?
In Scratch, sound blocks help you add music, effects and spoken sounds to your projects. They are found in the Sound category and let sprites and the Stage play, stop and change sounds. Sound blocks make animations livelier and help show what is happening (for example, a jump sound when a sprite leaps).

Common Sound Blocks and what they do

• play sound [sound] until done — plays the chosen sound and waits until it finishes before moving to the next block.
• start sound [sound] — starts the sound and immediately continues with the next block (sound plays at the same time as other actions).
• stop all sounds — stops every sound that is playing now.
• play drum [drum] for [beats], rest [beats], play note [note] for [beats] — music blocks used to compose tunes using beats and notes.
• set volume to [ % ] and change volume by [ % ] — control how loud a sound is.
• set tempo to [BPM] and change tempo by [BPM] — control how fast the beats play (BPM = beats per minute).
• change [effect] by [value] (for example, change pitch or robot effect) — change how a sound sounds without replacing it.

How to use sound blocks in an animation

• Add background music using a start sound inside a forever loop or by broadcasting a message that starts a long sound.
• Use play sound until done when you want an action to wait (for example, show a message only after a short tune finishes).
• Use change volume by to fade sounds in and out during a scene.
• Combine motion and sound: when a sprite jumps, use start sound 'boing' while moving the sprite to make the action more realistic.

Tips for students

• Test sounds at different volumes so they match the scene and are not too loud.
• Use the Sound editor (Scratch) to trim or record short sounds to use with the blocks.
• When looping music, use play sound until done inside a repeat or forever block so the next loop starts only when the sound ends.

What are Sensing Blocks?
Sensing blocks in Scratch are blocks that let a sprite find out information from the program, the mouse, the keyboard, or the environment. They help a sprite 'sense' things like mouse position, key presses, if it is touching another sprite or color, answers from the user, loudness, and distance to targets. These blocks return values (numbers, true/false, or text) that other blocks (like if or move) can use.

Common Sensing Blocks (simple description)

• ask [question] and wait — shows a question and waits for the user to type an answer.
• answer — gives the text the user typed after ask.
• mouse x and mouse y — give the current X and Y coordinates of the mouse pointer.
• mouse down? and key [space] pressed? — tell if the mouse or a key is pressed (true/false).
• touching [mouse-pointer / color / sprite]? — tells if the sprite is touching another object or color.
• distance to [sprite / mouse-pointer] — gives how far the sprite is from a target.
• loudness — measures sound level from the microphone (if available).
• timer — gives the time since the timer was last reset.

How to use them
Use sensing blocks inside scripts to make decisions or change actions. For example, ask the user for their name and then use the answer to greet them; or check if <touching color ?> to make a sprite react when it hits a colored wall.

Small example scripts

when green flag clicked
ask 'What is your name?' and wait
say (join 'Hello, ' answer) for 2 seconds

when this sprite clicked
repeat until 
  move 10 steps
end

forever
  if <(distance to [mouse-pointer]) < 50> then
    say 'Too close!'
  end
end

Why they are useful for animations
Sensing blocks make animations interactive: characters can respond to clicks, keyboard presses, or the mouse; they can collide with objects using color or touching checks; and they can move toward or away from the mouse using distance and coordinates. This makes animations lively and fun.

Animation is making pictures move. In Scratch, you can create animations by changing a sprite's appearance, position, or showing many sprites quickly. There are several simple techniques you can use together to make lively animations.

• Frame-by-frame (costume changes): Give a sprite several costumes (different drawings) and switch costumes quickly in a loop. This is like a flipbook and is great for walking or flapping wings.
• Motion (move and glide): Change a sprite's x and y coordinates to move it. Use small steps repeatedly or the glide block to move smoothly from one position to another.
• Timing (wait and loops): Control how fast the animation runs by using wait blocks between frames or repeats. Short waits make faster animations; longer waits slow them down.
• Tweening (interpolation): Make smooth motion by dividing a large move into many small moves (steps). This creates gradual change in position, size, or rotation.
• Broadcasts and events: Use broadcast messages to start or stop parts of the animation (for example, start background music when the character starts walking).
• Cloning: Create copies of a sprite (clones) for repeated objects like falling leaves, stars, or raindrops. Each clone can run the same script to animate many items at once.
• Looks, sound and layering: Combine costume changes with sound blocks and backdrop changes. Use the go to front/back blocks to layer sprites correctly.

Simple Scratch script patterns (pseudocode):

when green flag clicked
repeat forever
  next costume       // frame-by-frame animation
  move 5 steps       // small step for smooth motion
  wait 0.1 seconds   // controls frame rate
end

Tips: change the wait time to control speed, break large moves into many small moves for smoothness, and use broadcasts to coordinate multiple sprites.

The Paint Editor in Scratch is the tool you use to draw and change sprites (characters or objects) and backdrops (backgrounds for the Stage). You can open it to create a new sprite or backdrop, or to edit an existing costume or backdrop.

How to open the Paint Editor:

• Click the Choose a Sprite button and select Paint to draw a new sprite.
• Click the Backdrops tab (Stage) and choose Paint to draw a new backdrop.

Main tools in the Paint Editor:

• Brush: draw freehand lines.
• Line and Shape tools: draw straight lines, rectangles, circles, and polygons.
• Fill bucket: fill an area with color.
• Text: add words to a sprite or backdrop.
• Eraser: remove parts of the drawing.
• Select/Move: select, move, resize and rotate parts of the drawing.
• Stamp or Duplicate: repeat shapes or copy parts.
• Zoom: magnify details to work carefully.

Costumes and frames:

• A sprite can have many costumes. Switching costumes creates simple animations (for example, running legs in costume 1 and 2).
• To animate, make small changes between costumes and use the next costume block in Scratch to play them in sequence.

Backdrops:

• Backdrops are the backgrounds of the Stage. You can paint several backdrops and switch between them in your program to show scene changes.

Important practical points:

• Vector mode vs Bitmap mode: Vector keeps shapes crisp when scaled and lets you edit points. Bitmap acts like a photo and is easier for pixel-style drawing.
• Layers and order: items drawn later appear on top. You can move parts forward or backward with layer controls.
• Use short, clear names for costumes and backdrops so you can switch them easily in code.
• Use the duplicate costume feature to make small edits for animation frames instead of drawing each from scratch.

Scratch coordinate system:

• Scratch Stage uses x and y coordinates. X goes left (negative) to right (positive), roughly from -240 to 240. Y goes down (negative) to up (positive), roughly from -180 to 180.
• Understanding coordinates helps place sprites precisely on the Stage.

Tips for Class 4 students:

• Start simple: draw basic shapes and colors.
• Make two or three costumes for small animations like blinking or walking.
• Save work often and use Undo if you make a mistake.
• Try drawing a character and a backdrop from real life: your classroom, a playground, or a pet.

What this topic means
When you create a project in Scratch (an animation, story, or game), saving means keeping a copy so you do not lose your work. Sharing means putting your project on the Scratch website so other people can see and try it. Exporting means making a file (usually a Scratch project file or image) that you can store on your computer, send by email, or use in other places.

Why it is important
Saving protects your work from being lost. Sharing lets others see and learn from your project. Exporting lets you keep a copy outside Scratch or use pictures and sounds from your project in other programs.

How to save a project

1. In the online Scratch editor: Click the File menu and choose Save now. If you are signed in, your project will be stored in your Scratch account.
2. To save a copy to your computer: choose File > Save to your computer. This downloads a .sb3 file (the Scratch project file) that you can keep on your computer or USB drive.
3. Give your project a clear name so you can find it later (for example: MyAnimation_v1).
4. Use small incremental saves (or version numbers) like v1, v2 so you can go back if needed.

How to share a project on the Scratch website

1. Sign in to your Scratch account.
2. Open your project in the editor and click the Share button (usually at the top right).
3. Add a clear project title, short instructions so others know how to use it, and tags or notes about what it teaches.
4. Decide if you want to allow remixing. If you allow remixing, others can make their own copies and change them.
5. After sharing, you can send the project link to classmates or post it in your Scratch studio.

How to export parts of a project
You can export the whole project (.sb3) or export individual parts like costumes and sounds:

• Export the whole project: File > Save to your computer and get a .sb3 file.
• Export a costume or backdrop: click the costume, then use the option to download as an image file (PNG) if available.
• If you want a video or GIF of your running animation, you can use a screen recorder to record your Scratch stage and save as MP4 or GIF (Scratch itself does not always provide direct GIF/video export).

Good habits and tips

• Save often while you work.
• Use meaningful names and include the date (for example, SpaceShip_Game_2026-01-05).
• Keep backups: save one copy in your Scratch account and another on your computer or USB drive.
• When sharing, write short instructions and list controls (which keys to press) so others can play your project easily.

Safety and privacy
Only share projects that follow Scratch community rules. Do not include private information (your full name, school address, phone number). If working in a classroom, check with your teacher before making projects public.

Planning means deciding what you want your animation to do before you start building it in Scratch. In planning you choose the main idea (for example: a butterfly flying), the characters (sprites), the background, the costumes (different looks for the sprite), and the steps needed to make the animation.

Sequencing means putting the steps in the right order. In Scratch this is the order of the blocks (scripts) that tell a sprite what to do. A correct sequence makes actions happen smoothly—for example, telling a sprite to change costume, then move, then wait, so the motion looks like walking.

Debugging means checking your animation to find and fix mistakes. You test the animation, watch what happens, find where it is wrong (for example: sprite starts in the wrong place or costumes skip), change the script to fix the problem, and test again until it works well.

Simple steps to follow:

• Plan: decide goal, sprites, backdrop, costumes, sounds, and steps.
• Write the sequence: pick event blocks (like when green flag clicked), then put motion, looks, control blocks in the right order.
• Test the animation: click the green flag and watch.
• Debug if needed: find the problem, try a fix, and test again.

Good planning and careful sequencing make debugging easier and help you create smoother animations.

What this topic covers
In Scratch, creating animations means making sprites (characters) move, change costume, make sounds and respond to events so they look alive. Activities teach young learners how to use motion, looks, sound, control and event blocks together to build short animated scenes.

Simple steps to make an animation

• Plan your scene: choose sprites, backgrounds, and the story (what happens first, next, last).
• Give each sprite scripts: start with when green flag clicked or when this sprite clicked.
• Use Motion blocks: move 10 steps, go to x: y:, glide 1 secs to x: y:.
• Use Looks blocks: switch costume to or next costume to create walking or talking illusions.
• Use Control blocks: repeat, forever, wait 0.5 seconds to time animation frames.
• Add Sound and Events: play sound and use broadcast to coordinate sprites.

Class activity ideas
Activities are short, guided tasks where students try one idea at a time: make a sprite walk, make a ball bounce, or make a sprite change costume when clicked. These teach use of specific blocks and debugging (fixing when something does not move as expected).

How to combine blocks for a simple walking animation (example)
1. Put two or three costumes for walking in a sprite.
2. Script: when green flag clicked → forever → move 10 steps → next costume → wait 0.2 seconds.
3. Add if on edge, bounce so it turns at stage edge.

Learning outcomes
Students learn sequencing, cause and effect (event → action), timing (using waits), loops (repeat/forever), and simple logic (if touching edge or another sprite → action).

What is Digital Citizenship and Safety?

Digital citizenship means using computers, the internet and apps in a safe, respectful and responsible way. For Class 4 students making animations in Scratch, it means being kind to others online, protecting your personal information and following rules when you share, remix or comment on projects.

Why it matters

When you use Scratch or other websites you leave a digital footprint — the things you share or say can stay online. Being a good digital citizen keeps you and others safe and helps the online community stay friendly and fun.

Simple rules to follow

• Be kind: Treat others online the same way you would in class.
• Protect personal information: Never share your full name, address, phone number, school name, passwords, or photos without permission.
• Ask before you post: Check with a parent or teacher before sharing a project or image.
• Credit others: If you remix or use someone else’s sprite, sound or idea, give them credit (say who made it).
• Use strong passwords and keep them secret from friends (except parents/guardians).
• Report problems: If you see mean comments, bullying, or something that makes you uncomfortable, tell a trusted adult and use the site’s report tools.

Tips for Scratch-specific safety

• When sharing a project, use a nickname (not your full name) on your profile.
• Read and follow Scratch’s community guidelines — they help keep the site friendly.
• If you remix a project, add a note saying who made the original and what you changed.
• Don’t click unknown links posted in comments; ask a teacher or parent first.

What to do if something goes wrong

• Stop: Do not respond to mean messages or share more information.
• Save: Take a screenshot if something bad happens.
• Tell: Tell a parent, teacher or trusted adult right away.
• Report: Use the website’s report or block features if someone is being hurtful.