ThinkFusion
LevelsFor schoolsPricingSign in
Start free
ThinkFusionFor schoolsPricingContactTermsPrivacyRefunds
© 2026 ThinkFusion

A robotics lab that needs no lab.

Level after level, from one blinking LED to a robot that follows a line. Real Arduino C++, compiled by the real toolchain, run on a simulated AVR chip.
Start freeFor schools
Levels 1–4 are free. No card, no download, no kit.
void setup() {
  pinMode(13, OUTPUT);
}

void loop() {
  digitalWrite(13, HIGH);
  delay(500);
  digitalWrite(13, LOW);
  delay(500);
}
Loading board...
...
drag the parts
D13LOW0.000 s simulated16 MHz AVR

This is the actual emulator, running the actual Blink program. Nothing here is a recording.

40
gradeable challenges, with harder tiers
27
distinct components, all simulated
2→24
wires, level one to level sixteen

Don’t take our word for it. Build one.

Level 1 is two wires and an LED, and it is open to anyone. A short guide shows you where each wire goes; then you press run, and your code is compiled by the real Arduino toolchain and executed on a simulated chip. Nothing is marked until you want it to be.
Build the first circuit now. No account.
This opens the real editor on the real Level 1 — the same one students use. A short guide walks you through the two wires, then you press run and watch your own code blink an LED on a simulated chip.
loads the full editor — a few MB, so it waits until you ask

A robot that follows a line, driving itself.

Two infrared eyes, two motors and a motor driver. The code below is compiled by the real Arduino toolchain and run on a simulated AVR chip; the wheels it turns move a robot whose position decides what its sensors can see. That loop is the whole lesson, and it is running on this page.
left eye offright eye off0 mm off centre
Nothing here is animated. The sketch on the right is steering — the eyes read the line, the code sets each wheel's speed, and the robot goes where that takes it.
const int IN1 = 2, IN2 = 3, IN3 = 4, IN4 = 5, ENA = 9, ENB = 10;
const int EYE_L = 7, EYE_R = 8;
const int FAST = 200, SLOW = 70;

// Which eye saw the line last. A robot that has lost the line entirely knows nothing about
// where it went EXCEPT this, and it is enough: the line left on the side that saw it last.
int lastSeen = 0;

void wheels(int left, int right) {
  digitalWrite(IN1, left > 0 ? HIGH : LOW);
  digitalWrite(IN2, LOW);
  digitalWrite(IN3, right > 0 ? HIGH : LOW);
  digitalWrite(IN4, LOW);
  analogWrite(ENA, left);
  analogWrite(ENB, right);
}

void setup() {
  int outs[] = {IN1, IN2, IN3, IN4, ENA, ENB};
  for (int i = 0; i < 6; i++) pinMode(outs[i], OUTPUT);
  pinMode(EYE_L, INPUT);
  pinMode(EYE_R, INPUT);
}

void loop() {
  bool leftOnLine = digitalRead(EYE_L) == LOW;
  bool rightOnLine = digitalRead(EYE_R) == LOW;

  if (leftOnLine && !rightOnLine) {
    lastSeen = -1;
    wheels(SLOW, FAST);
  } else if (rightOnLine && !leftOnLine) {
    lastSeen = 1;
    wheels(FAST, SLOW);
  } else if (leftOnLine && rightOnLine) {
    wheels(FAST, FAST);
  } else {
    // Both eyes off the line. Driving straight on here is what loses a robot for good on a
    // sharp corner: it carries on into open floor and never sees the line again. Turn back
    // towards whichever eye saw it last and it sweeps until the line comes round again.
    if (lastSeen < 0) wheels(0, FAST);
    else if (lastSeen > 0) wheels(FAST, 0);
    else wheels(FAST, FAST);
  }
  delay(5);
}
Forty lines, compiled by the real Arduino toolchain. A student writes this by level 10.

And one that gets out of a maze it has never seen.

Three ultrasonic sensors and a rule older than robots: keep your left hand on the wall and never lift it. There is no map and nothing is remembered. Watch it walk into the dead end, turn all the way round, and carry on.
left —ahead —right —0.0 m from start
No map, no memory. It has never seen this maze.
void loop() {
  int l = ping(TRIG_L, ECHO_L);
  int f = ping(TRIG_F, ECHO_F);
  int r = ping(TRIG_R, ECHO_R);

  // The rule. Four questions, and THE ORDER IS THE ALGORITHM - swap any two lines and you have
  // built a different robot.
  if (l > SIDE_OPEN_CM) {
    spinLeft(QUARTER_MS);            // a gap on the left is always taken. Always.
  } else if (f > FRONT_OPEN_CM) {
    // straight on: nothing to do but drive
  } else if (r > SIDE_OPEN_CM) {
    spinRight(QUARTER_MS);           // left is wall, ahead is wall: the only way on is right
  } else {
    spinLeft(QUARTER_MS * 2);        // dead end. All the way round, and the hand goes back on
  }                                  // the same wall it was already holding.

  advanceCell();
}
Keep your left hand on the wall and never lift it. Every wall here joins every other, so the wall is one piece — and walking its edge cannot miss the way out.

Everything in the cupboard, and it cannot run out.

Each of these is a real level. The components below are the components that level asks you to wire — drawn here by the same code that draws them in the editor.
    See every level

    Graded on what the circuit actually did.

    Every submission is compiled by the real Arduino toolchain. If it would not build on a real board, it does not build here.
    Then the binary runs on an emulated AVR, cycle by cycle, and we watch the pins. A pass means the circuit did the thing — not that a box was ticked, not that the right function name appeared in the file.
    Which is also why the feedback can be specific about the wiring, and not only about the code.
    ✔Compiled
    ✔D13 toggled 6 times in 6.0 s
    ✘LED never lit — no current path
    The ULN2003 board has no power on VCC (+). Wire it to 5V.
    Not a screenshot a student uploaded. The chip ran; we watched the pins.

    One blinking LED to a robot that decides for itself.

      Running this for a class?

      One kit between three
      One bench each, thirty at once
      A loose jumper looks like a bug
      The wiring is checked, and named
      Handout and packaway eats 20 minutes
      The lesson starts on the bell
      How seats work for schools
      A robotics lab that needs no lab.
      Start freeSeats for a class
      Seats are priced per student per year. Email info@abilityfusion.com and a person replies — there is no form.

      Questions people ask

      Do I need an Arduino kit or any hardware?
      No. You wire the circuit on screen with realistic components, write real Arduino C++, and it runs on a simulated Arduino Uno in the browser. Nothing to buy, break or replace.
      Is it real Arduino code?
      Yes. Your sketch is compiled by the real Arduino toolchain and runs on a simulated AVR chip, cycle by cycle — the same code works on a physical Arduino Uno.
      What will I build?
      30 levels in 7 modules: from blinking an LED to buttons, buzzers, ultrasonic and PIR sensors, motors, a line-follower robot, obstacle avoidance, servos, Bluetooth control, LCD and 7-segment displays, a keypad, temperature sensing, a thermostat and a maze-solving robot.
      Is it free?
      Levels 1 to 4 are free, with no card. The full course is a one-time ₹2,999 with lifetime access.
      How does it work for schools?
      A school buys seats at ₹499 per student per year, hands out a join code, and teachers see every student's progress on a roster. Teachers do not use a seat. Pay by card for up to 50 seats or request a GST invoice for any number.
      Do I need to install anything?
      No. It runs in a modern web browser on the computers a school or home already has.