Three New Coding Courses — Python for Younger Learners, C#, and Python Quest

We’ve just launched three new coding courses, and they’re quite different from anything else we’ve built. Here’s what’s new, who each course is for, and why we built them the way we did.

Python with Byte! — for ages 8–14

The existing Python course on CompSciTutoring.com was designed with GCSE students in mind. But a lot of our younger students — and those who are just starting out — needed something more approachable. Something that didn’t assume they already understood what a variable was. Something with a bit more personality.

Python with Byte! is a ten-lesson graphical course built specifically for ages 8–14. Each lesson is guided by one of five original characters: Byte the blue robot, Bit the enthusiastic green robot, Pixel the creative purple artist, Loop the spinning orange robot, and Bug the friendly debugging helper. These characters explain each concept through dialogue, demonstrate examples, set challenges, and celebrate when students succeed.

Every lesson has five steps. The student reads what the character says, sees a worked example in the code editor, then has their own challenge to complete. The code editor runs real Python 3 — not a simulation, not a simplified environment. When you click Run, actual Python executes via Pyodide (a WebAssembly build of CPython that runs entirely in the browser). The editor now has full syntax highlighting for Python keywords, strings, comments, numbers and builtins.

The ten free lessons cover:

Say Hello! — print(), writing first programs
Number Magic — arithmetic operators, BODMAS
Memory Boxes — variables, data types
Talking to Python — input(), interactive programs
Making Decisions — if, elif, else
Do It Again! — for loops
Collections — lists, append(), remove(), len()
Teach Python New Tricks — def, parameters, return values
Debug with Bug! — error types, reading messages
Adventure Game! — mini project combining everything

Beyond the ten free lessons, twenty additional Pro lessons continue through while loops, nested loops, dictionaries, string methods, f-strings, scope, list comprehensions, classes and inheritance, file handling, error handling, modules, and a grand final project.

Students earn badge names for each completed lesson (stored in the browser) and the lesson map shows star ratings as they progress. The first four lessons are free for everyone.

Start Python with Byte! →

C# with Byte! — for ages 8–14

The same five characters now teach C#. The layout, the lesson structure, the badge system, and the character dialogues are all identical — because learning to code doesn’t change between languages. What changes is syntax, and C# has some important differences worth handling carefully.

C# requires a class Program and static void Main() wrapper that Python doesn’t. For a beginner course, asking 8-year-olds to write that boilerplate before every “Hello, World!” would immediately put them off. So the course uses a smart wrapper: the editor automatically detects whether the student’s code has a Main method, and if not, wraps it correctly before sending it to the compiler. Students only see the important parts — the Console.WriteLine() calls, the variables, the logic — until they’re ready for the full class structure in the later lessons.

Execution happens via Wandbox, a free cloud C# compiler, proxied through the site’s own API so students don’t need any account or configuration. The editor has C# syntax highlighting: keywords in blue, types in teal (including Console, Math, List, Random), strings in orange, comments in green, numbers in sage.

The ten free lessons cover:

Say Hello! — Console.WriteLine(), Console.Write()
Number Magic — integer and double arithmetic, %, //
Memory Boxes — int, string, double, bool, var
Talking to C# — Console.ReadLine(), int.Parse()
Making Decisions — if, else if, else
Do It Again! — for loops with i++
Keep Going While… — while loops, guessing game
Collections — string[], int[], foreach
Making Methods — void and return-type methods
C# Adventure! — mini text adventure combining everything

Eight Pro lessons then cover string methods, switch expressions, classes and properties, inheritance, List<T> and Dictionary<K,V>, try/catch exception handling, LINQ, and a final project quiz application.

Start C# with Byte! →

Python Quest: The Lost Crystals — for ages 14–16

This one is different. Very different.

Python Quest is a dungeon adventure game where students write Python code to control their hero — Byte in adventurer mode — through grid-based dungeon levels. Move through ruins, defeat goblins, collect gems, and recover the stolen Coding Crystals. Each level teaches a specific Python concept, and students are rated on the efficiency of their code, not just whether it works.

The driving principle is that programming concepts are most deeply understood when they’re immediately useful. When a student realises they can replace eight move("east") calls with for i in range(8): move("east"), they understand loops in a way that no explanation can match. When their code for a level takes 40 moves but they can see a peer solved it in 18, the motivation to refactor is intrinsic.

How the game works

The dungeon levels are rendered as SVG tile grids — grass floors, stone walls with brick texture, animated water, glowing golden exit doors, trees. The hero (Byte in a blue helmet) moves with a spring-style CSS animation. Goblins and orcs have angry eyebrows, fangs, and HP bars that deplete as you attack them. Gems are diamond shapes with shine dots. Every command the student writes causes a visible animation in the world.

Code runs via Pyodide — real Python in the browser. The game injects a set of functions into Python’s namespace:

move("north")        # move one tile
attack()             # attack an adjacent enemy
collect()            # pick up an item at current position
say("message")       # display dialogue
has_enemy()          # True if enemy is adjacent
enemy_hp()           # remaining HP of nearest enemy
has_gem()            # True if gem is at current position
find_gem()           # returns direction to nearest gem
find_enemy()         # returns direction to nearest enemy
find_door()          # returns direction to the exit
pos()                # returns {"x": x, "y": y}

The crucial detail: these aren’t just print-to-output functions. The game state — hero position, gem positions, enemy health — is simulated in Python during execution. So has_gem() returns an accurate value based on where the hero actually is and what they’ve already collected. This makes the sensing functions genuinely useful for conditional logic, not just illustrative placeholders.

After code runs, commands play back one by one with animations at 280ms per step. When the win condition is met, a star rating appears: three stars for solving in ≤ the par number of moves, two for reasonable code, one for any working solution.

The curriculum

Fifteen levels across four chapters:

Chapter 1: The Lost Ruins (free, Levels 1–4)

Level 1: Basic move() — sequencing
Level 2: Gem collection — planning sequences
Level 3: Labyrinth navigation — multi-step planning
Level 4: Long corridor — introduces for loops as an insight moment

Chapter 2: The Goblin Caves (Pro, Levels 5–8)

Level 5: Gem mine patterns — for loop mastery
Level 6: Goblin guard — attack(), has_enemy(), while loops
Level 7: Sensing gems — find_gem(), if/elif conditionals
Level 8: Function forge — def, parameters, code reuse

Chapter 3: The Crystal Palace (Pro, Levels 9–12)

Level 9: Orc gauntlet — variables, enemy_hp(), complex while
Level 10: Crystal maze — lists of directions, for item in list
Level 11: Stone algorithm — recursion
Level 12: Crystal throne — combining all concepts, boss fight

Chapter 4: The Dragon’s Keep (Pro, Levels 13–15)

Level 13: Dragon’s hoard — dictionaries
Level 14: Sorting the scales — bubble sort visualised with hero movement
Level 15: The Final Crystal — graduation challenge

The editor

The code editor in Python Quest has full Python syntax highlighting: keywords (for, if, def, class, return) in blue, game API functions (move, attack, find_gem) in teal to make them visually distinct from language keywords, builtins (print, len, range) in gold, strings in orange, comments in green, numbers in sage. The underlying technique is an overlay: a <pre> element renders highlighted HTML directly behind a transparent <textarea>, so students type in the textarea and see the highlighted version through it. The font metrics match exactly so the cursor sits perfectly over the highlighted text.

Who it’s for

Python Quest is aimed at 14–16 year olds who are beginning to study Computer Science — typically Year 9 upward. It assumes no prior coding experience. The first four levels are entirely free. The Pro levels unlock with a subscription.

Play Python Quest →

A note on the design

All three courses share the same underlying principle: students learn best when they’re doing something, when the feedback is immediate, and when the goal is intrinsic rather than imposed. A student who moves their hero east four times and then sees they can do it in one loop line with for i in range(4) has learned something that will stay with them. A student who types code and watches a robot move across a grid will remember that move("south") means south in a way that reading the definition never achieves.

These courses are also built with teachers in mind. The junior courses (Python and C#) are designed to work alongside KS3 computing. The Python Quest adventure levels map directly to GCSE content.

All courses run entirely in the browser — no installation, no accounts required to start, no setup for teachers or students.