Scratch Coding Challenge: Build Flappy Bird

In this challenge, you will build your own version of Flappy Bird in Scratch.

Flappy Bird was one of the most downloaded mobile games in the early days of touchscreen devices. The idea is simple:

• Your bird falls because of gravity
• Every time you press a key, the bird flaps upward
• Obstacles move across the screen
• Your goal is to fly through the gaps without crashing

This isn't meant to be cookbook coding.

Great programmers learn by breaking problems into pieces and experimenting with solutions.

So first you’ll see the core pieces of the game, then you can try building them yourself. After that, you can scroll down for a full walkthrough solution.

---

The Game Design Challenge

Before looking at the solution, see if you can build these features.

1. Create a Bird

Your game needs a main character.

Your bird should:

• Start near the middle left of the screen
• Be small enough to move easily between obstacles
• Have two flying costumes so it can flap its wings

---

2. Add Gravity

The bird should constantly fall downward.

When the game starts:

• Gravity should begin pulling the bird down
• The bird should fall faster over time

Hint:
Use a variable to represent gravity.

---

3. Add Flapping

When the player presses a key:

• The bird should jump upward
• The bird should flap its wings
• The player should not be able to hold the key to fly forever

Hint:
You may need to wait until the key is released before allowing another flap.

---

4. Create the World

Your game needs a background.

Ideas:

• A blue sky
• Clouds

---

5. Create Obstacles

Flappy Bird is about flying between obstacles.

Your obstacles should:

• Appear on the right side of the screen
• Move toward the left
• Disappear when they leave the screen
• Spawn every few seconds

Hint:
Use clones to create new obstacles.

---

6. Randomize the Obstacles

To make the game interesting:

• Obstacles should appear at different heights
• Players should not be able to memorize the pattern

Hint:
Use the pick random block.

---

7. Detect Collisions

The game should end when:

• The bird touches an obstacle

When this happens:

• Show a Game Over message
• Stop the game

Hint:
Use broadcast messages.

---

8. Add a Score

Each time the bird successfully passes an obstacle:

• Increase the score by 1

---

Full Walkthrough Solution

Below is one way to build the game.

Your solution may look different — and that’s okay!

Here is a Scratch build of the game: https://scratch.mit.edu/projects/1287185411

---

Step 1: Create the Bird

1. Open Scratch
2. Click Create
3. Delete the default cat sprite
4. Click Choose a Sprite
5. Select a bird (for example, Toucan)

Position the bird:

when green flag clicked
go to x: -120 y: 0
set size to 50%
switch costume to flying costume

---

Step 2: Create Gravity

Create a variable called:

gravity

Then add this code:

when green flag clicked
set gravity to 0
forever
    change gravity by -1

Now make the bird move using gravity:

forever
    change y by gravity

The bird will now fall and accelerate downward.

---

Step 3: Add Flapping

Now allow the player to flap upward.

if <space key pressed>
then
    set gravity to 10
    switch costume to flap
    wait until <not space key pressed>

This does three important things:

• Gives the bird an upward push
• Shows the flapping animation
• Prevents the player from holding the key to fly forever

---

Step 4: Create the Background

Click Stage → Choose Backdrop → Paint

Create a simple sky:

• Light blue background
• Optional clouds or ground

---

Step 5: Create the Obstacles

Create a new sprite called Obstacle.

Draw a pipe or tall rectangle.

Hide it at the start:

when green flag clicked
hide

---

Step 6: Spawn Obstacles

Create clones every few seconds.

when green flag clicked
forever
    wait 3 seconds
    create clone of myself

---

Step 7: Move Obstacles

Tell clones what to do when they appear.

when I start as a clone
show
go to x: 270 y: (pick random -100 to 100)
repeat until <x position < -250>
    change x by -5
end
delete this clone

Now obstacles move across the screen.

---

Step 8: Add Collision Detection

Create a new sprite called Game Over.

Add this code:

when green flag clicked
hidewhen I receive [Game Over]
go to x:0 y:0
show
stop all

Now detect collisions in the bird sprite:

forever
    if <touching obstacle>
    then
        broadcast [Game Over]

---

Step 9: Add Scoring

Create a variable called:

score

In the obstacle sprite, add this before deleting the clone:

change score by 1
delete this clone

Each time an obstacle leaves the screen, the player earns a point.

---

Step 10: Test Your Game

Try to beat your high score!

Your game should now include:

✔ Gravity
✔ Flapping controls
✔ Moving obstacles
✔ Random obstacle positions
✔ Collision detection
✔ Game over screen
✔ Score counter

---

Make Your Game Even Better

Try improving your game with new features:

• Add sound effects when the bird flaps
• Add a sound when you crash
• Add a floor that causes game over
• Speed up obstacles as score increases
• Add background music
• Create different levels

---

Challenge:
Can you make your game harder the longer someone survives?

That’s how many of the best arcade games work!

Development Guide: Code a Mini Economy Town in Scratch

This guide explains how to build a dice-powered city simulator in Scratch. You will learn how to manage a virtual economy, use cloning to build a visual city, and create a multi-level progression system.

You can check out this project on Scratch. Dicy City Scratch

We made a more polished version here. Check out the YouTube video below.

---

Step 1: The Economy Engine

The Goal: Create a dice-rolling mechanic that generates money.

• Setup Variables: Create variables for Coins, Dice Total, and Roll Count.
• The Dice Sprite:
  • Give your Dice sprite 6 costumes (one for each side).
  • When the sprite is clicked, use the pick random 1 to 6 block to set the Dice Total.
  • Switch the costume to match the number.
• The Payout System:
  • Use a Broadcast called Check Payout.
  • When the dice stops rolling, send the broadcast. Every building you own will "listen" for this and check if the Dice Total matches its specific winning number to give you Coins.

Step 2: Visual City Building (Cloning)

The Goal: Make buildings appear on the screen when you buy them.

• The Building Sprite:
  • Create one sprite for every building (Wheat Field, Cafe, Mine, etc.).
• The Buying Logic:
  • Create "Buy" code for each building. When clicked, check: if Coins > Cost.
  • If successful, subtract the cost from Coins and Create a Clone.
• Cloning the Building:
  • Now update the code for When I Start as a Clone.
  • Inside that block, update the Payout to the value of what happens when the dice rolls that number.
  • Add a script: when I start as a clone, use go to x: (random) y: (random) to place the building in your city area.
• Check Payout
  • When I receive Check Payout, check to see if the Dice Roll equals the activation number.
  • Update the number of coins by the payout value.

Step 3: Strategic Synergies (Math Operators)

The Goal: Create advanced buildings that give bonuses based on other buildings you own.

• Tracking Collections: Create variables to track totals, such as Total Flower Gardens or Total Mines. Every time you buy one, change that variable by 1.
• The Synergy Logic:
  • For a building like the Flower Shop (which pays out based on how many gardens you have), use the Operator blocks.
  • When the dice hits the Flower Shop’s number, use: change Coins by (Total Flower Gardens * 3).
  • This rewards the player for planning their city layout instead of just buying random items.

Step 4: Level Progression & Resets

The Goal: Create a sense of achievement by unlocking new items and clearing the board for a new challenge.

• The Level Variable: Create a variable called Level.
• Unlocking Content:
  • On your "Buy" buttons, use an if block: if Level > 2 then show else hide.
  • This keeps the screen clean and introduces new buildings (like the Mine or Restaurant) only when the player is ready.
• The Level-Up Script:
  • Create a script that constantly checks: wait until Coins > Goal.
  • When the goal is hit, show a "Level Up!" message.
  • The Reset: To start the new level, set Coins to 5, set Roll Count to 0, and use broadcast Clear City.
  • All building clones should have a script: when I receive Clear City, delete this clone.

Step 5: Adding Visual "Juice"

The Goal: Use motion to show the player exactly when and where they are earning money.

• Flying Coins:
  • Create a small "Coin" sprite.
  • When a building clone triggers a payout, it should create clone of Coin.
• The Animation Script:
  • Inside the Coin clone: when I start as a clone.
  • go to [Building Sprite] (the one that just paid out).
  • show.
  • glide 0.5 secs to [Coin Counter Display].
  • delete this clone.
• Unlocking the Second Die:
  • At Level 3, show a new button: "Roll 2 Dice."
  • When clicked, change the math to: set Dice Total to ((pick random 1 to 6) + (pick random 1 to 6)). This allows the player to finally hit high-number buildings like the Mine (11 or 12).

---

Summary of Logic

By the end of this project, you have mastered:

1. Events: Using broadcasts to coordinate between the dice, the shop, and the city.
2. Cloning: Managing dozens of visual objects without creating dozens of separate sprites.
3. Conditionals: Checking if a player has enough money or has reached the correct level to proceed.
4. Math Operators: Creating complex economic bonuses that make the game strategic.

Code a Mini Economy Town: A Development Guide

This guide breaks down the creation of Dice City Tycoon, a browser-based economic simulator. We developed this game in five distinct phases, moving from a simple text-based engine to a polished, multi-level city builder.

This page is all about building the game in HTML for a Web Browser. This is where I like to prototype my games before building a polished version in a game engine.

A Scratch Version of this Guide is available.

---

Phase 1: The Core Engine (Randomized Income)

Objective: Establish the "Game Loop." We needed a way for the player to spend money (Input) and earn it back through luck (Output).

• How it was accomplished:
  • Data Structure: We used a JavaScript object (state) to track coins and buildings, and an array (buildingData) to define what each building does.
  • Randomness: We used Math.floor(Math.random() * 6) + 1 to simulate a 6-sided die.[1][2]
  • Logic: Every time the player rolls, the code loops through their buildings. If the roll matches a building's "trigger" number (e.g., a Wheat Field triggers on a 1), it adds coins to the total.

Phase 2: Visual Feedback (The Emoji City)

Objective: Make the game feel like a "City Builder" rather than just a spreadsheet. We wanted the player to see their progress physically.

• How it was accomplished:
  • The City Window: We created a dedicated CSS div (the "green field") using Flexbox.
  • Dynamic DOM Injection: In the buyBuilding function, we added a line that creates a new <span> containing an emoji (🌾, ☕, ⛏️) and appends it to the city window.
  • CSS Animations: We used a @keyframes "pop-in" effect to make buildings bounce into existence, giving a satisfying sense of "impact" when buying.

Phase 3: Strategic Depth (Synergy Buildings)

Objective: Move beyond simple payouts and introduce strategy. We wanted buildings that "talk" to each other.

• How it was accomplished:
  • Conditional Payouts: We added "Synergy Buildings" like the Flower Shop and Furniture Factory.
  • Dynamic Calculation: Instead of a flat payout number, we wrote a function that checks the current state. For example, the Flower Shop calculates: (Count of Shops) * (3 * Count of Flower Gardens).
  • Strategy Shift: This forced players to decide between "Reliable" income (Wheat Fields) or "High-Ceiling" combos (Flower Shop + Gardens).

Phase 4: The Progression System (Levels & Unlocks)

Objective: Prevent the player from being overwhelmed and create long-term goals.

• How it was accomplished:
  • Level Gatekeeping: We added a minLvl property to each building. The "Market" code was modified to only show buildings if game.level >= building.minLvl.
  • The Level-Up Trigger: After every roll, a checkLevel() function compares the player's coins to a target goal (e.g., Level 1 goal = 12 coins).
  • The "Second Die" Mechanic: We locked the ability to roll two dice until Level 4. This created a major gameplay milestone that felt like a reward for mastering the early game.

Phase 5: Polish & "Juice" (Animations & Resets)

Objective: Make the game feel professional and implement a "Prestige" loop where the game gets harder but more rewarding.

• How it was accomplished:
  • Coordinate Math: For the sliding coins, we used getBoundingClientRect(). This allowed JavaScript to find the exact pixel location of the dice and the pixel location of the coin counter on your screen.
  • Coin Flying: We created temporary "flying coin" elements and used CSS transitions to move them between those two coordinates.
  • The Great Reset: To keep the game challenging, we added a reset logic on level-up. When a goal is hit, the code clears the buildingsOwned object, empties the City Window HTML, and sets coins back to 5. This forces the player to use their newly unlocked buildings to reach the next, higher goal.

---

Final Project Architecture Summary

1. HTML: Provides the skeleton (the city field and the control sidebar).
2. CSS: Handles the "Vibe" (grass colors, dirt borders, and button styling).
3. JavaScript: Acts as the brain, managing the level logic, coin math, and animations.

Key takeaway: By starting with a simple dice roll and layering on visuals, strategy, and then progression, you can build a complex simulation starting from just a few lines of code.

DOWNHILL SKIER GAME CODING CHALLENGE

The Challenge

Your mission is to create a downhill skiing game.
The skier stays near the top of the screen while the world moves toward them.

Goal:
Avoid obstacles for as long as possible.

This game uses a classic trick in game design:
If the environment moves, it feels like the player is moving.

---

The Big Idea

Even though it looks like the skier is racing downhill:

• The skier only moves left and right
• The obstacles move upward toward the skier
• The player survives by dodging obstacles

Obstacles can include:

• Flags
• Rocks
• Trees

Play our html version of the game.

---

Step 1: Create Your Skier (Player Sprite)

Start with your skier — this is your avatar.

Requirements:

• Place the skier near the top of the screen
• Allow the skier to move left and right

Tip #1: Player Movement

Think carefully about how the skier should move.

You might:

• Use the left and right arrow keys
• Make the skier move toward the mouse

There is no single correct solution — choose what feels best for your game.

---

Step 2: Add Your First Obstacle

Obstacles create the challenge.

Start simple:

1. Create one obstacle
2. Spawn it at the bottom of the screen
3. Move it up the screen toward the skier
4. When it goes off screen, reset it to the bottom

Tip #2: One Obstacle First

Do not add everything at once.

• Get one obstacle working
• Make sure it moves correctly
• Then add more obstacle types

---

Step 3: Create the Downhill Illusion

The skier does not move downhill — the obstacles do.

Obstacle Rules:

• Move at a constant speed
• Only move on the Y-axis
• No left or right movement

Tip #3: Keep the Physics Simple

Simple movement makes debugging easier.

• No X movement
• Only Y movement
• Smooth, steady speed

This keeps the focus on gameplay, not complex math.

---

Step 4: The Game Loop

Every frame, your game should:

1. Move the skier left or right
2. Move obstacles upward
3. Check for collisions
4. Repeat

This loop continues until the skier hits an obstacle.

Check out our MakeCode Arcade Version of the Game!

---

Game Over

When the skier touches an obstacle:

• End the game, or
• Display a Game Over message

---

Extension Challenges (Optional)

Want to take your game further?

Try adding:

• A score based on time survived
• Faster obstacles over time
• Sound effects
• Multiple levels or difficulty modes

---

Final Thought

Start small. Test often.
Every great game begins with something simple.

Happy coding.

Overview

Design a LEGO build that transforms from a desk into a bed, inspired by Sarah E. Goode’s folding cabinet bed. This challenge highlights how engineers solve real problems—like limited living space—by creating furniture that serves multiple purposes.

Watch the full build video: https://youtu.be/h9pIRXLIa8w

Best for: Grades 2–6
Kits: LEGO Spike Prime or Spike Essential
Time: 45–60 minutes

---

Who Was Sarah E. Goode?

Sarah E. Goode was an inventor and furniture store owner who lived in the late 1800s. As cities grew, many families lived in very small apartments with limited space. Sarah noticed that people needed furniture that could do more than one job.

Her solution was a folding cabinet bed—a piece of furniture that could be used during the day and transformed into a bed at night. She became one of the first Black women to receive a U.S. patent.

Big idea: Good design makes life easier by solving everyday problems.

This image is an AI enhancement of the blurry photograph.

---

Real Invention: Key Features

Sarah Goode’s folding cabinet bed needed to:

• Save space in small apartments
• Transform smoothly between uses
• Be strong and stable when used as a bed
• Fold away neatly during the day

This invention helped families live more comfortably in tight spaces.

---

LEGO Robot Challenge

Your mission: Build and program a LEGO model that transforms from a desk into a bed using motion and structure.

Build Requirements

• A desk configuration and a bed configuration
• At least one hinge or pivot point
• One motor to assist with the transformation
• The transformation must be controlled and repeatable

Optional Add-Ons

• Add a button to switch between desk and bed modes
• Include supports or legs that lock into place
• Add a second transformation (bed → desk)
• Add sound or light when the transformation begins

---

Suggested Materials

• 1 Motor
• LEGO beams, connectors, hinges, and plates
• Hub (Spike Prime or Spike Essential)

---

Programming Concepts

• Motor direction and power
• Timers / wait blocks
• Sequences
• Loops

Extension: Use conditionals so the build only transforms when it is safe.

---

Discussion Questions

• Why was space such a big problem in apartments?
• How does furniture that does multiple jobs help families?
• What could go wrong if the bed wasn’t stable?
• What other furniture could be redesigned to save space?

---

Learning Objectives

Students will:

• Understand how constraints influence design
• Practice mechanical transformation and sequencing
• Explore structural stability
• Connect historical inventions to modern design

---

Extensions & Challenges

• Design furniture for a tiny apartment
• Compare Sarah Goode’s invention to modern Murphy beds
• Test how much weight the bed can support
• Create a full transforming room

---

Video Connection

🎥 Watch the full build video: https://youtu.be/h9pIRXLIa8w

---

Part of the Black History LEGO Robotics Series

This build is part of our Black History LEGO Robotics Challenge—exploring inventors, engineers, and innovators through hands-on LEGO robotics.

What problem would you solve with transforming furniture?

Overview

Build a LEGO robot that opens and closes a door automatically—no hands required. This challenge is inspired by Alexander Miles, the inventor whose automatic elevator door system made buildings safer and helped shape modern cities.

Watch the full build video: https://youtu.be/CT-ELr0o-v0

Best for: Grades 2–6
Kits: LEGO Spike Prime or Spike Essential
Time: 45–60 minutes

---

Who Was Alexander Miles?

Alexander Miles was an inventor who noticed a serious safety problem in the late 1800s: elevator doors were often left open by mistake, leading to dangerous accidents. After a close call himself, Miles designed an automatic elevator door system that opened and closed on its own. His invention reduced human error and made elevators much safer to use.

Big idea: Automation can protect people by removing dangerous human mistakes.

---

Real Invention: Key Features

Alexander Miles’s automatic door system needed to:

• Open and close automatically
• Stay synchronized with elevator movement
• Prevent doors from being left open
• Operate smoothly and safely

These ideas are still used in modern elevators and automatic doors today.

---

LEGO Robot Challenge

Your mission: Design and program a LEGO door that opens when someone approaches and closes automatically after a short delay.

Build Requirements

• 1 motor to move the door
• 1 sensor (distance or color) to detect presence
• Door opens without touching
• Door closes automatically

Optional Add-Ons

• Emergency stop button
• Sound or light indicator
• Adjustable open/close timing
• Two doors that open in opposite directions

---

Suggested Materials

• 1 Motor
• 1 Distance Sensor (or Color Sensor)
• LEGO beams, connectors, and plates
• Hub (Spike Prime or Spike Essential)

---

Programming Concepts

• Sensors as inputs
• Motor direction and power
• Timers / wait blocks
• Loops

Extension: Add conditionals so the door stays open while someone is detected.

---

Discussion Questions

• Why were automatic doors safer than manual ones?
• What problems could happen if a door didn’t close?
• Where do you see automatic doors today?
• How does automation help people with mobility?

---

Learning Objectives

Students will:

• Understand how automation improves safety
• Practice sensor-based programming
• Explore cause-and-effect logic
• Connect historical inventions to modern technology

---

Extensions & Challenges

• Design an elevator system around the door
• Compare early elevators to modern smart elevators
• Test different sensor distances
• Create a building with multiple automatic doors

---

Video Connection

🎥 Watch the full build video: https://youtu.be/CT-ELr0o-v0

---

Part of the Black History LEGO Robotics Series

This build is part of our Black History LEGO Robotics Challenge—exploring inventors, engineers, and innovators through hands-on LEGO robotics.

What will you automate next?

Build a working LEGO traffic signal inspired by Garrett Morgan, the inventor whose improved traffic light design helped make roads safer. In this challenge, students design a motorized signal system, learn why timing and clear communication matter, and connect history to real engineering decisions.

Watch the Video! Click Here

Who Was Garrett Morgan?

Garrett Morgan was an inventor and entrepreneur who saw a dangerous problem on early 1900s streets—cars, horses, and pedestrians all competing for space. After witnessing a serious accident, he designed an improved traffic signal that warned drivers before it was time to stop. His ideas laid the foundation for modern traffic lights and saved countless lives.

Big idea: Engineering starts with noticing a problem and designing a safer solution.

Real Invention: Key Features

Morgan’s traffic signal needed to:

• Clearly tell people when to stop and go
• Include a warning phase before stopping
• Be simple and reliable so drivers could understand it quickly
• Improve safety at busy intersections

LEGO Robot Challenge

Your mission: Build a LEGO traffic signal that controls movement using timing and visual signals.

Build Requirements

• One motor to rotate or switch the signal
• Visual indicators (colors, panels, or arms)
• A programmed timing sequence (stop → warning → go)

Optional Add‑Ons

• Add a button to change modes
• Add a sound for the warning phase
• Create two directions of traffic

---

Suggested Materials

• 1 Motor
• LEGO beams, connectors, and plates
• Light elements or colored bricks
• Hub (Spike Prime or Essential)

---

Programming Concepts

• Timers / wait blocks
• Motor control
• Sequence order
• Loops

Extension: Add conditionals to handle pedestrian crossings.

Discussion Questions

• Why was a warning signal important?
• What could go wrong if the timing is too fast or too slow?
• How does this robot help keep people safe?
• What improvements would you make today?

---

Learning Objectives

Students will:

• Understand how inventions solve real-world problems
• Practice sequencing and timing in code
• Explore how safety influences engineering design
• Connect history to modern technology

---

Extensions & Challenges

• Design a pedestrian crossing button
• Add a second intersection
• Compare old traffic signals to modern smart traffic systems
• Track how many cars safely pass through

---

Video Connection

🎥 Watch the full build video: https://youtu.be/o2VpeirX9PY

Read More About Garrett Morgan

After spending four years in Cincinnati, in 1895 Morgan moved to Cleveland, where he took a job sweeping floors at the Roots and McBride Co. Over time, he grew familiar with the company’s sewing machines, teaching himself how to operate and repair them. Not only did Morgan become a skilled machinist, but he also found inspiration for his first invention — a belt fastener for sewing machines.

In 1907, Morgan started his own business where he repaired and sold sewing machines. Two years later he opened a tailor shop: The Morgan Skirt Factory. While his wife Mary sewed clothes, Morgan built and maintained the sewing machines. He also began experimenting with a liquid for polishing sewing machine needles, preventing them from burning fabric as they sewed. When he discovered the liquid also could straighten hair, he used it to develop a hair cream, and he soon established the G. A. Morgan Hair Refining Co. Morgan then began investing his profits into developing more inventions.

Morgan found the motivation to develop one of his most impactful inventions when he learned about the devastating Triangle Shirtwaist Co. fire that caused the deaths of 146 garment workers in New York City in 1911. Understanding that the firefighters had struggled with smoke inhalation, Morgan began to devise a solution. In 1912, he filed for a patent on his breathing device, a “safety hood” that was designed to give a first responder the ability to “supply himself at will with fresh air from near the floor [and] at the same time forcibly remove smoke or injurious gases from the air tube.” Two years later, he established the National Safety Device Co.

In 1916, the importance of Morgan’s safety hood invention was demonstrated at the site of a tragic accident in Cleveland. Following an explosion at the Cleveland Waterworks that killed 18 workers, survivors were trapped as a gas-filled tunnel collapsed under Lake Erie. Without effective safety equipment, rescuers had been unable to reach them because smoke, dust and fumes blocked their way. But when some volunteers — including Morgan himself — put on safety hoods, they were able to successfully reach and rescue several survivors.

Despite his invention’s obvious lifesaving potential, Morgan found difficulty in selling his safety hood to white fire chiefs who refused to buy products from a Black inventor. In response, Morgan sought the advice of the famous entrepreneur J.P. Morgan, who suggested he remove his first name from the product. Following this advice, the inventor began calling his device the “Morgan Safety Hood.” He also hired white actors to promote the product at conventions, helping him to avoid racist objections. Morgan’s new marketing strategies worked, and fire departments across the country finally began to buy his early gas masks.

By the 1920s, Morgan had established himself as a successful businessman and had purchased an automobile. While driving through Cleveland one day, he witnessed a collision between a horse-drawn carriage and another vehicle at an intersection. This experience compelled Morgan to once again use his talents and skills to develop an invention that would improve the safety and welfare of his fellow citizens.

Building a Mars Rover with LEGO Robotics

A rover is an automated motor vehicle that propels itself across the surface of a celestial body. A rover may examine territory and interesting features, analyze weather conditions, or even test materials, such as soil and water.

What does it take to go to Mars?

People have long been fascinated by Mars, the planet in our solar system that’s most like Earth. Uncrewed missions have sent orbiters, probes, and rovers to explore the planet since the 1960s, but what would it take to carry out a successful human mission to Mars?

Mission Mars Unit Overview

In this unit, your students will work as scientists and engineers. They’ll immerse themselves in motivating STEM activities that prompt creative problem-solving, communication, and exploration.

Mission: Activate Communications

Mars Mission : Activate Communications - Sprattronics

Mission: Vent Bot

VENT Bot Maze Mission - Sprattronics

Mission: Ice Collection

Mars Mission : Ice Collection Challenge - Sprattronics

Mission: Rocket Launcher

Lesson Video

Step by Step Build Directions

Mission: Supply your Base