Scratch Christmas Animation: Code a Festive Holiday Scene

A Scratch project does not have to be a game to teach meaningful coding concepts.

In this Scratch Christmas animation, kids can explore how loops, timing, broadcasts, costumes, graphic effects, sound, variables, and custom blocks work together to turn a static holiday scene into an animated program.

Our Christmas scene includes a flickering fireplace, twinkling Christmas lights, presents that shake and change color, a moving star, music, and several other animated effects.

Each individual movement is fairly simple. The more interesting part is what happens when all of those small programs run together.

Click the green flag and suddenly the entire scene comes to life.

Play the Scratch Christmas animation below, then click See Inside to explore how each part works.

Open the Christmas Animation on Scratch →

How This Scratch Christmas Animation Works

The project begins with a decorated Christmas room.

There is a tree, wrapped presents, a fireplace, stockings, a wreath, holiday lights, and other seasonal decorations.

When the green flag is clicked, Scratch broadcasts a message called:

startScene

That message tells different sprites to begin their individual animations.

Instead of putting all of the instructions into one enormous script, each sprite is responsible for its own behavior.

The fireplace handles the fire.

The lights handle their costume changes.

Individual presents can shake, brighten, distort, or cycle through colors.

The star rotates.

Another script controls the music.

This is a useful example of how a larger animation can be built from many smaller programs running together.

Start the Entire Scene with a Broadcast

A broadcast is one of the easiest ways to coordinate multiple Scratch sprites.

When the green flag is clicked, one of the scripts sends:

broadcast [startScene]

Other sprites can listen for that message with:

when I receive [startScene]

Each sprite then begins its own job.

This means the fire, presents, lights, music, and other effects can all start from the same event without being physically connected in one stack of blocks.

That is especially helpful in an animation with many independent objects.

We can think of startScene as the signal that says:

The Christmas animation is beginning. Everyone start your part.

Make the Fireplace Flicker with Graphic Effects

The fire sprite uses a custom block called:

fireFlicker

When the green flag is clicked, Scratch calls that block.

Inside fireFlicker, a forever loop repeatedly changes the appearance of the flame.

The script changes the whirl effect by 45, waits 0.2 seconds, increases brightness, switches to the next costume, and then changes the effects back in the opposite direction.

The sequence includes:

change [whirl] effect by 45
wait 0.2 seconds
change [brightness] effect by 5
next costume
change [whirl] effect by -45
wait 0.2 seconds
change [brightness] effect by -5

Then the loop begins again.

That combination makes the flame appear much less static.

Instead of only switching between two images, the program changes multiple visual properties at once.

Use Graphic Effects to Animate Without Moving a Sprite

Scratch includes several graphic effects that can change how a sprite looks.

This project uses effects including:

• Brightness
• Color
• Fisheye
• Whirl

Graphic effects are useful because animation does not always require changing a sprite’s x- or y-coordinate.

The fireplace stays in the fireplace.

The present stays beneath the tree.

What changes is how the sprite looks.

That lets us create movement and visual interest without actually relocating the object.

Shake a Christmas Present with Rotation

One present uses a custom block called:

presentShake

When the sprite receives startScene, it first changes its rotation settings and points in direction 90.

Then presentShake begins.

Inside a forever loop, the present:

1. Waits 0.5 seconds.
2. Turns 5 degrees one direction.
3. Increases brightness.
4. Waits another 0.5 seconds.
5. Turns 5 degrees back.
6. Decreases brightness.

The present is only rotating a small amount.

That small movement is important.

Turning a wrapped present by 90 degrees would not look like shaking. Alternating between small positive and negative rotations creates the illusion that something inside the package might be moving.

This is a good example of using small repeated changes to create animation.

Combine Movement and Brightness for a Stronger Effect

The shaking present does not only rotate.

Its brightness changes at the same time.

That makes the effect more noticeable without requiring a complicated animation.

This is a useful programming idea because one sprite can have several properties changing inside the same loop.

The computer can modify:

• Direction
• Costume
• Brightness
• Color
• Position
• Size
• Other visual effects

Animation often becomes more convincing when several small changes are layered together.

Make Presents Change Color

Another present uses the Scratch color effect.

When startScene is received, the program first sets the color effect to 0.

That gives the sprite a predictable starting appearance.

Then it calls the custom block:

presentColor

Inside that custom block, Scratch repeatedly:

change [color] effect by 25
wait (pick random 0.5 to 3) seconds

The result is a present that keeps changing color while the music plays.

The random wait time makes the changes less mechanical.

Instead of changing at exactly the same interval every time, the sprite can pause for different lengths of time.

Use Random Timing to Make Animation Feel Less Repetitive

The color-changing present uses:

pick random 0.5 to 3

for its wait time.

That means Scratch chooses a new value within that range each time through the loop.

Randomness can make an animated scene feel more natural.

If every light, present, flame, and decoration changed at exactly the same moment, the scene could start looking overly synchronized.

Small differences in timing help each element feel independent.

Distort a Present with the Fisheye Effect

Another wrapped gift uses Scratch’s fisheye graphic effect.

When the scene begins, the project resets the fisheye effect to 0.

Then it calls:

presentFisheye

The custom block changes the fisheye amount and then alternates between increasing and decreasing it.

That causes the present to appear to bulge and shrink.

The sprite itself is not changing costumes or moving around the Stage.

Scratch is mathematically distorting the image.

This gives kids another way to think about animation:

Sometimes the object moves. Sometimes the image itself changes.

Animate a Present with Brightness

Another present uses a custom block called:

presentBright

The structure is similar to the fisheye animation.

Scratch first resets brightness to 0.

Then the custom block repeatedly changes brightness by positive and negative values.

The effect makes the present pulse between brighter and darker versions of itself.

This is also a good place to discuss why resetting an effect before beginning an animation is helpful.

If we do not reset the effect, a sprite may begin from whatever value was left over from a previous run.

Starting from 0 makes the animation more predictable.

Use a Variable to Control How Long Effects Run

Several of the present animations use a condition involving:

musicLoop

For example:

repeat until <musicLoop = 5>

That connects the visual animation to another part of the program.

The sprite is not simply told:

Repeat this 10 times.

Instead, it watches a variable that is being changed elsewhere in the project.

That means multiple pieces of the animation can respond to the same shared information.

The musicLoop variable becomes part of the project’s overall state.

Play Jingle Bells While the Scene Animates

The music script also begins when startScene is received.

The custom music block repeats the sound several times.

The code:

repeat 5
    set volume to 50%
    play sound [jingle bells] until done
    change [musicLoop] by 1

Each completed loop increases musicLoop.

That is important because other sprites are watching that variable.

The music is therefore doing two jobs.

It creates the soundtrack for the animation.

It also provides a way for other scripts to know how far the scene has progressed.

Music Credit

The Jingle Bells music used in the Scratch project is from Edward Hall/Epidemic Sound.

Most sprites and the backdrop were compiled and/or created by Our Family Code using external resources.

Make the Christmas Star Move

Not every sprite needs complicated code.

The star uses a very small script.

When it receives startScene, Scratch sets its rotation style and then repeatedly turns it by 15 degrees.

That creates continuous rotation with only a few blocks.

It is a useful reminder that good animation does not require complicated code.

Sometimes one repeated change is enough.

Make Christmas Lights Twinkle with Costumes

The Christmas lights use costume changes to create their animation.

When the green flag is clicked, the sprite calls:

twinkleLights

Inside the custom block, Scratch switches to a starting costume and then repeatedly waits and advances to the next costume.

The basic pattern is:

wait 0.5 seconds
next costume
wait 0.5 seconds
next costume

The different costumes show different light states.

Switching between them creates the illusion that the lights are blinking.

This is one of the simplest forms of frame-by-frame animation in Scratch.

Understand Costume Animation

Scratch sprites can have multiple costumes.

Normally, costumes are thought of as different appearances for a character.

They can also act like animation frames.

Imagine drawing two pictures of a string of Christmas lights.

In the first image, one group of bulbs is illuminated.

In the second, another group is illuminated.

Switching quickly between those images creates apparent movement even though nothing on the Stage has changed position.

The same technique can be used for:

• Blinking eyes
• Walking characters
• Flames
• Water
• Signs
• Holiday lights
• Facial expressions
• Spinning objects

Coordinate Many Animations at the Same Time

The most important idea in this project is not any single block.

It is that all of these animations can happen together.

While the fire flickers, the presents can shake.

While the presents change color, the lights can twinkle.

While the star rotates, the music continues playing.

These scripts are running concurrently.

Scratch allows separate stacks of blocks to execute alongside one another.

That makes it possible to build a scene from independent behaviors instead of trying to write one gigantic sequence.

Why Custom Blocks Help Organize the Christmas Animation

This project uses several descriptive custom blocks:

fireFlicker

music

presentShake

presentColor

presentFisheye

presentBright

twinkleLights

Those names make the program much easier to understand.

If we see:

when I receive [startScene]
presentShake

we already have a pretty good idea of what that sprite is supposed to do.

That is one of the benefits of decomposition.

The larger problem of animating an entire Christmas room gets divided into smaller problems.

Then put all of those pieces together.

Experiment with Scratch Graphic Effects

One of the easiest ways to remix this project is to experiment with the effect values.

Try changing the fire’s whirl amount from 45 to 15.

What happens?

Increase the brightness changes on a present.

Change the fisheye value.

Make the star rotate by 5 degrees instead of 15.

Change the twinkling lights from 0.5 seconds to 0.2.

These changes are small enough that kids can make a prediction before running the project.

Then they can test whether the result matches what they expected.

That is a simple but meaningful form of debugging and iterative design.

Test Timing in the Christmas Animation

Timing has a huge effect on animation.

A present that changes every 0.1 seconds may look frantic.

A present that changes every 5 seconds may barely appear animated.

Scratch’s wait blocks give us direct control over pacing.

Try changing just one timing value while leaving everything else unchanged.

Then compare the two versions.

This helps kids see that animation is not only about what changes.

It is also about when and how quickly it changes.

Remix the Scratch Christmas Animation

There are many ways to build on this project.

Kids could add falling snow, animate the stockings, make an ornament swing, change the fireplace animation, create a blinking wreath, add another sound effect, or animate presents using different Scratch graphic effects.

They could also experiment with broadcasts.

For example, a new broadcast could trigger a special animation near the end of the music.

A sprite might receive:

finale

and suddenly make every Christmas light flash at once.

The goal is not simply to add more objects.

Choose a behavior, decide how it should work, and then determine which Scratch blocks can create that effect.

Open and Remix the Christmas Animation on Scratch →

What Kids Learn from This Scratch Christmas Animation

This project introduces and reinforces:

• Animation
• Loops
• Forever loops
• Timing
• Wait blocks
• Custom blocks
• Decomposition
• Broadcast messages
• Event-driven programming
• Variables
• Costume animation
• Sound
• Brightness effects
• Color effects
• Whirl effects
• Fisheye effects
• Rotation
• Random numbers
• Parallel programming
• Testing and debugging
• Iterative design

It also demonstrates that coding does not always have to produce a game.

Programming can be used to build interactive art, animated stories, digital scenes, simulations, and creative displays.

In this project, each individual script is fairly approachable.

The complexity comes from combining many small animations into one coordinated Christmas scene.

That makes it a great next step for kids who have already experimented with basic Scratch blocks and are ready to see how multiple sprites and scripts can work together to create something larger.

More Scratch Coding Activities for Kids

Keep coding with another Our Family Code Scratch project:

• Scratch Space Game: Build a Timed Star Collector — explore clones, variables, broadcasts, collision detection, timers, and game-state logic.
• Scratch Rainforest Coding Activity — combine science classification with movement, Boolean logic, variables, and lists.
• Scratch Maze Game: Halloween Trick-or-Treat Candy Hunt — practice maze navigation, sensing, variables, random placement, and game design.
• Scratch Animation Project: Halloween Skeleton Dance Party — explore loops, costumes, coordinates, custom blocks, parameters, sound, and animation.
• Scratch Collision Detection Halloween Coding Activity — experiment with sensing, collisions, nested conditionals, and broadcasts.
• Scratch Conditional Statements: Witch Wardrobe — work with user input, if/then logic, Boolean conditions, and decision-making.