Level Up with Scratch: Intermediate Coding for Kids
Learning to code has never felt this rewarding! In Level Up with Scratch, every lesson is a new adventure kids explore, experiment, create, and surprise themselves with what they can build.
From mastering smart game logic to syncing multiple characters in an interactive story, students gain skills that go far beyond Scratch. They build real confidence, real creativity, and a real portfolio project to show the world.
The best part? Kids don't even realize how much they're learning because they're having too much fun doing it!
- 1 Month
- intermediate
What you'll Learn
Advanced motion controls: Dynamic pointing, random paths & physics
Variables & data: Scores, timers, health points & user inputs
Loops & conditionals: Nested loops, if-else chains & logic operators
Broadcasting & synchronization: Multi-sprite coordination & events
Cloning & lists: Dynamic instances, inventories & data structures
Capstone project: Build a full interactive game or simulation
Our Curriculum
- 6 Modules
- .
- 18 Activities
- .
- 18 Projects
This module aims to review foundational motion concepts at the beginner level and advance to more responsive, precise, and interactive controls, such as dynamic pointing, random paths, and conditional movements, helping students create fluid, user-responsive interactions in multi-sprite environments.
It refreshes prior knowledge in an engaging way through challenges and remixing, preparing learners for complex projects with a focus on precision, randomness, spatial algorithms, and introductory physics-like simulations, fostering deeper problem-solving and creativity.
- Review beginner motion: move steps, turn degrees, glide to x/y, position changes, edge bounce
- Advanced positioning: point towards mouse/sprite, go to random position, rotation styles
- Randomness: pick random for steps, directions, positions
- Debugging: overlapping movements, boundary issues, step testing
Activity:
Physical motion reenactment: path-replication challenges.
Project:
"Follow the Mouse Trail" with random detours, edge bouncing, speed variations.
- User controls: key/mouse events with speed variables
- Multi-sprite: pursuits using point towards, distance calculations
- Conditional motion: if-then for direction changes, thresholds
- Extensions: simulate gravity/bouncing with y-position change
Activity:
Pair pursuit building; real-world motion discussions.
Project:
"Leader Chain Formation" with random breaks/reforms.
- Path optimization: glide vs. steps, efficient routes with math
- Sensing preview: touching/distance for triggers
- Remixing: add obstacles/goals, peer evaluations
Activity:
Obstacle design contests; efficiency remixes.
Project:
"Random Explorer Bot" avoiding zones with turns, checks.
The objective is to introduce variables as tools for storing, manipulating, and displaying dynamic data such as scores, timers, health points, and user inputs, enabling the creation of adaptive programs with changing states and feedback loops.
This fosters analytical thinking and data-driven decision-making through gamified examples, making abstract concepts tangible and fun with real-time updates, multiplayer elements, and randomization for replayability.
- Creation: global/local variables, set/change, show/hide monitors
- Operations: use in motion, looks, sounds
- Initialization: set at start, reset on events
- Debugging: watch values, fix uninitialized/scope errors
Activity:
Value tracking hunts; math drills.
Project:
"Dynamic Counter App" incrementing on clicks, displaying/resetting.
- Timers: built-in timer, custom countdowns with loops
- Scores: add/subtract on events, display highs
- Inputs: ask/wait, store/use in responses
- Multiplayer: global variables for competition
Activity:
Timer races; quiz brainstorming.
Project:
"Interactive Quiz Game" with scores, timers, answer inputs.
- Operators: arithmetic +, -, *, /, mod in calculations
- Random generation: pick a random for content
- Persistence: cloud preview or local simulations
- Uses: difficulty levels, threshold adjustments
Activity:
Generator challenges; logic puzzles.
Project:
"Multiplayer Score Tracker" with broadcasts and random power-ups.
Students will master nested loops for creating intricate patterns and repetitions, as well as advanced conditionals with else-if chains and logical operators to handle multi-path decisions and complex logic flows. Objectives include building robust algorithmic thinking, error handling, and adaptive behaviors, kept enjoyable through endless game scenarios, customizable power-ups, random events, and collaborative debugging for enhanced replayability and teamwork.
- Nested: inner/outer for grids, spirals, animations
- Conditional: repeat until, forever with breaks
- Optimization: counters, waits for pacing
- Patterns: shapes like stars, fractal intros
Activity:
Loop diagramming; image replications.
Project:
"Spiral Pattern Drawer" with variable steps.
- Branches: if-else-if, nested ifs for outcomes
- Operators: and/or/not for compounds
- Comparisons: =, >, < with math
- Errors: checks for invalid states
Activity:
Logic simulations; tree mapping.
Project:
"Obstacle Course Runner" with jumps, changes, and paths.
- Dynamics: forever if for monitoring
- Power-ups: temporary modifications
- Randomness: pick random in conditions
- Debugging: step-through nested errors
Activity:
Playtesting; random additions.
Project:
"Endless Runner Game" with movement loops, obstacle conditionals, scores/power-ups.
The objective is to teach coordinating multiple sprites and elements using broadcast messages to trigger synchronized actions, events, and state changes across projects such as interactive stories or simulations. This promotes understanding of modular programming, event-driven architectures, and teamwork in code, mirroring real-world interactions through narrative planning, collaborative scripting, and timed sequences for immersive experiences.
- Blocks: broadcast, broadcast/wait, when receive
- Chaining: sequences/reactions across sprites
- Synchronization: timed coordination
- Debugging: trace flows, fix misses/duplicates
Activity:
Relay games; light sequence challenges.
Project:
"Character Dialogue Exchange" with timed responses.
- Sync: movements/looks/sounds in groups
- Conditionals: broadcasts in if-then
- Data: globals with signals
- Planning: flowcharts for scenes
Activity:
Group scene building; timing debugs.
Project:
"Branching Story Adventure" with choice paths.
- Chained/loops: cycles/feedback
- Integration: with loops/conditionals
- Narratives: user choices affecting broadcasts
- Collaboration: remix additions
Activity:
Planning workshops; peer challenges.
Project:
"Synchronized Storytelling Adventure" with paths, syncs, variable endings.
This module focuses on cloning sprites to generate and manage multiple dynamic instances efficiently, alongside lists for handling ordered collections of data like inventories, high scores, or paths, enhancing project scalability and complexity. Objectives include mastering instance-based programming, data structures, and algorithmic manipulation, delivered through engaging games with randomness, sorting, and multiplayer features for fun and practical application.
- Blocks: create clone, start as clone, delete clone
- Management: unique/inherited behaviors
- Efficiency: variable controls, avoid overload
- Debugging: isolate clone issues
Activity:
Multiplication games; pattern creations.
Project:
"Falling Objects Simulator" with varied falls, catch deletions.
- Creation: add/delete/insert/replace items
- Access: item #, length, random item
- Manipulations: loop through, data storage
- Integration: indices as variables
Activity:
Inventory simulations; puzzle solving.
Project:
"Dynamic Inventory Manager" with add/delete, displays.
- Driven: clones from list contents
- Advanced: random selections, basic sorting
- Applications: scores/paths, multiple entities
- Optimization: efficient operations
Activity:
Generator challenges; combined debugs.
Project:
"Fruit Catcher Game" with list-cloned fruits, inventory tracking, and randomness.
The objective is to synthesize all intermediate concepts, including variables, loops, conditionals, broadcasts, cloning, and lists with advanced debugging strategies (e.g., variable watchers, script pausing) and optimization techniques such as code modularization, while encouraging collaborative improvements, remixing, and iterative design.
This capstone builds essential portfolio skills through innovative project integration, group feedback, and real-world problem-solving, fostering lasting confidence and creativity.
- Review: variables in loops, conditionals with broadcasts, cloning/lists
- Debugging: monitors, pauses, comments
- Optimization: reduce redundancy, efficient clones/lists
- Pitfalls: scopes, infinites, overloads
Activity:
Quizzes; buggy project fixes.
Project:
"Mini Simulation Prototype," like a particle system with clones/variables.
- Planning: storyboards, pseudocode, modulars
- Implementation: all tools in builds
- Iteration: testing, randomness/inputs
- Scalability: expansions via lists
Activity:
Pair sessions; building sprints.
Project:
Core "Interactive Simulation" (e.g., traffic with clones, variables, broadcasts).
- Remixing: studio edits, suggestions
- Presentations: logic demos, showcases
- Iterations: feedback refinements
- Reflection: real-world ties, portfolios
Activity:
Remix jams; pitch practice.
Project:
Finalize/present "Interactive Simulation" with collaborative enhancements.
Related Courses Kids May Love
Where curiosity meets excellence dive into courses that turn young learners into tomorrow's innovators.
