Everything Mokxi does, written down

A breadboard, a parts bin and a code editor in one browser tab. Nothing to install, and no account needed.

The editor is a header, a canvas, a code pane and a serial monitor. This is what every control on it does.

An Arduino Uno, one LED, one resistor and eight lines of code, built from an empty canvas.

Keep a project in this browser, sync it to your account, and send someone a link they can open.

Bring a project over from Wokwi, GitHub, Fritzing, SimulIDE, Falstad CircuitJS, Tinkercad, PlatformIO or the Arduino IDE without placing every part again.

Answer a "why doesn't my code work" post on Reddit or the Arduino forum with the fixed sketch and a link that runs it, in under a minute.

Your Wokwi projects open in Mokxi as they are. Here is what each Wokwi idea is called here, and what changes.

The docked part panel: search, categories, thumbnails, and three ways to get a part onto the canvas.

Drag between pins and holes, recolour, bend, name a net, and hide a family in the layers panel.

A square of paper on the board: what a corner of the circuit is for, in your own words.

Pen strokes, arrows and boxes over the circuit, on a layer of their own that the simulator never sees.

Lay the wires out again so none of them lies on another, and line the parts up on the breadboard grid.

A numbered pin on the board with a conversation behind it: a question about one resistor, answered in place, without typing anything into the circuit.

A labeled box around a corner of the board. Drag its title bar and everything inside goes with it, so "the power supply" moves as one thing.

A bit of circuit you built once, kept by name and dropped in again whenever you need it: a voltage divider, a debounced button, the parts for your display.

Build a circuit once, package it into a named chip, and place it as often as you like, inside other chips too.

One project per board, a real clang running in the tab, and diagnostics you can click.

What Run actually does, what the readout means, and how to talk to a board.

Graph the numbers your sketch prints, in the Plot tab beside Serial.

Three readings one probe will not give you: every node's voltage at once, what a node does as you turn something, and what the circuit does at every frequency.

Stop a board on a line of your own code, look at what it was doing, and step through it while the circuit stays exactly where the halt found it.

Ask a model about the circuit on the canvas and the code that runs it, in the Ask tab beside Serial, on your own API key from the AI provider you pick.

The board can join a network, fetch a page and serve one. The radio is simulated: there is no 802.11, no real internet, and the WiFi runtime is ours.

Pro lets a WiFi board's sketch reach the real internet: real web services over HTTP and HTTPS, and public MQTT brokers. It is off until you turn it on.

What you can change about a selected part or wire, and where the values go.

How far back undo goes, what copy takes, and what paste does with it.

Every key the editor listens for, and the one rule about when it does not.

What the browser keeps, what the account keeps, and when each of them writes.

The share sheet, who has access, what the link does, forking, and embedding a running circuit in a page.

A picture of the circuit, at what size, and which plans it is on.

How to get a sketch from Mokxi onto your Arduino, ESP32 or Pico, on a computer, a Chromebook or an iPad.

Keep your projects in your own GitHub repository, edit the code in VS Code, and run it in Mokxi.

Run a SPICE deck and plot the results, export a circuit as a .cir file, or import a netlist as parts and wires.

The stacked layout, the bottom sheet, and two fingers on the canvas.

How to add Mokxi to your home screen or dock from your browser, and what it changes.

An ATmega328P at 16 MHz, what is modeled, and the sketches that ship with it.

The Uno's chip on a board 45 by 18 mm, so it pushes into the breadboard instead of standing beside it, and two analog inputs an Uno has no pad for.

The Arduino for a project that ran out of pins: fifty-four digital, sixteen analog, four serial ports, on an ATmega2560 at 16 MHz.

The Arduino whose USB socket goes to the chip itself: an ATmega32U4 at 16 MHz, with Serial on the USB and Serial1 a port of its own on pins 0 and 1.

A RISC-V core at 160 MHz on the real memory map, with no radio and a simulated network in place of one.

A second RISC-V board: the same core as the ESP32-C3 at 160 MHz, with thirty-one GPIOs, half a megabyte of SRAM and an addressable RGB LED on GPIO 8.

An RP2040 on our Cortex-M0+ core: one core, SIO GPIO, the TIMER, UART0, PWM and the ADC.

The Pico with a wireless chip on it. The chip is not modeled; the WiFi is simulated and says so, and the LED behind it works.

A board the size of a thumbnail: eleven pads, all of them analog inputs, with Serial on the chip's own USB.

A Cortex-M4 at 84 MHz with GPIO, four timers, USART1 and SysTick.

An nRF52833 on our Cortex-M4 core: GPIO, GPIOTE, three TIMERs, RTC0, UARTE0 and the 5x5 LED matrix.

An STM32F103C8T6 on our Cortex-M3 core at 72 MHz: GPIO through CRL and CRH, TIM1 to TIM4, USART1, a twelve-bit ADC and SysTick.

The Uno everyone buys now: the same board, the same 5 V pins, an Arm Cortex-M4 underneath instead of an 8-bit AVR.

The classic ESP32: an Xtensa LX6 at 240 MHz on the thirty-pin DOIT board, with the LEDC PWM controller, a twelve-bit ADC and the six pins that are input only.

The ESP32-S3 on an Xtensa LX7 at 240 MHz: Espressif's own DevKitC-1, with its RGB LED on the RMT, two USB sockets, LEDC PWM and a twelve-bit ADC.

An ESP8266 board with simulated WiFi, an Xtensa LX106 at 80 MHz, D0 to D8 pins that differ from GPIO numbers, and software PWM.

A whole microcontroller in an eight-pin DIP: six I/O, two timers, a four-channel ADC, the USI, and a serial port the runtime bit-bangs for itself.

The Uno's chip on the smallest Arduino there is, with no USB on it, in the two builds it was always sold in: 5 V at 16 MHz, and 3.3 V at 8 MHz.

The Leonardo's ATmega32U4, shrunk onto a board that pushes into a breadboard.

The Leonardo's chip in a Pro Mini's footprint, with a USB socket on the end, and without the one thing people look for first: an LED on pin 13.

The NodeMCU's ESP8266 on a board a third the size, with the same pin names and only the pins that do something.

An ESP8266 with its flash chip and an antenna on a module 24.8 by 14.3 mm, and eight pins.

The ESP32-C3 on a thumbnail: 21 by 17.5 mm, fourteen pads, a USB-C socket and no LED of its own to blink.

The smallest ESP32-C3 board in common use, and a blue LED wired the other way around from the DevKit's.

The Uno R4 with a 12 by 8 LED matrix on the board to draw on, and WiFi.

The ESP32-C6 on a thumbnail: 21 by 17.5 mm, fourteen pads, USB-C, and a yellow LED that lights on LOW.

Espressif's own ESP32 board: a WROOM-32 module on thirty-eight pins named by GPIO, with no user LED.

A classic ESP32 on a narrow board with a LiPo socket, and a blue LED on GPIO 22 that lights when the pin is LOW.

The ESP32-S3 on a thumbnail: 21 by 17.5 mm, fourteen pads, USB-C, and a yellow LED that lights on LOW.

An ESP32-S3 on the classic Nano outline, with the Nano's pin names, an orange LED on D13 and an RGB LED.

The Pico's RP2040 on the classic Nano outline, with the Nano's pin names and an LED on D13.

Some boards come in with a Wokwi project but do not run in Mokxi yet, so they are drawn with an amber ribbon.

The bench, a part page, and the search box in the editor panel.

The nine categories the parts bin is sorted into, and what lives in each of them.

Eight bench instruments you can wire into a circuit, with Scope, Plot and Measurements panels to read their results.

What "analog islands solved by nodal analysis, digital everywhere else" means when you are the one wiring it.

A screen, something to hold, and the four circuits in the gallery that put them together.

A light emitting diode: a real diode with a forward drop, not a resistor that glows.

A small incandescent bulb in a screw holder, like the flashlight bulbs in school circuit kits. Aliases: bulb, light bulb, incandescent lamp, MES bulb.

A true two-terminal resistor: Ohm's law, with no idea which way around it is wired.

The 12 mm tactile pushbutton in every kit: four pins, and real contact bounce.

A positive supply rail: pick a voltage, and everything wired to it sits there.

The 0 V reference every other part on the canvas measures against.

A free-running square wave source: pick a frequency, and it drives high and low forever.

A real capacitor, solved by the matrix rather than approximated part by part.

A real inductor, solved by the matrix: the one two-terminal passive whose state is a current rather than a voltage.

An op-amp with a gain-bandwidth product, a slew rate, an output that stops short of its rails, and a current limit. Pick a model, or set the numbers yourself.

A bench signal generator on the canvas: sine, square or triangle, at whatever frequency and amplitude you set.

The bench box: sine, square, triangle or sawtooth, with the knobs on the front and a real 50 ohm output.

A two-channel oscilloscope: clip it to any two nodes and watch the voltages over time while the circuit runs.

Every range a real handheld has, on a dial you turn on the face: DC and AC volts, DC and AC amps, ohms, continuity, diode, capacitance, frequency and duty.

Nought to thirty volts, a current limit, and the two lamps that are the whole point of the instrument.

Clip it on any net and read the frequency, the period, the duty, how long each cycle spends high, and how many pulses have gone by.

The pen with a needle on the end. Touch it on a pin and it tells you one of four things, and the fourth is one no other instrument here can tell you.

Three sockets. Push two or three legs of an unknown part into them in any order and it names the part, measures it, and tells you which leg is in which socket.

One ideal two-input logic gate: a teaching part, not a chip, with no supply pins to wire up first.

One ideal inverter: the companion to the ideal gate, with no supply pins and no chip behind it.

Switches, lamps, number parts, a constant bit and a step clock: ideal logic parts for building circuits out of gates, with no supply pins.

A program ROM that holds Kestrel assembly and a text terminal that shows what it prints: the parts around the computer you build from gates.

A single-digit 0.56 inch seven-segment LED display: eight plain LEDs in one package, nothing more.

A three-pin SPDT slide switch: the pole in the middle moves between the two ends as you click it.

A 5 V active piezo buzzer: apply DC the right way around and it makes its one note.

74HC00, 74HC04, 74HC08, 74HC32, 74HC86, 74HC74 and 74HC595. These are real chips, not teaching gates, each with its own page below.

Four two-input NOR gates in a 14-pin package: the output is high only when both inputs are low.

Six inverters, with the 74HC04's pinout, and one difference that is the whole point of the part: each input has two switching thresholds instead of one.

Three address inputs choose one of eight outputs, and that output goes low while the other seven stay high.

A 4-bit binary counter in which every output changes on the same clock edge.

The 74HC595 turned around. The 595 gives you eight outputs from three pins; the 165 gives you eight inputs on three pins.

A 4-bit binary counter that counts both ways, with a separate clock for each direction.

The LED chaser chip: ten outputs, exactly one of them high at a time, and every clock edge moves the high one along to the next.

Four wires in, one lit digit out: a BCD to seven-segment decoder for a common-cathode display.

A row of tiny slide switches in the body of a chip.

Four or eight equal resistors in one single in-line package, every one of them between its own pin and a shared common pin.

The bipolar 555 timer: the chip in every beginner's kit, modeled down to its own internal comparators and flip-flop.

The MAX7219, wired to 8x8 LED matrix modules the cheap boards use: three wires in, and a chainable output.

Eight red seven-segment digits on a MAX7219 module, three wires in and a cascade out. Aliases: 8-digit MAX7219 module, LedControl display.

Addressable RGB LEDs on one wire, with no clock: aliases WS2812B, NeoPixel. A strip, a ring, or a 16-wide matrix, all the same part.

The 128x64 OLED module every hobby kit has, over I2C. Aliases: 0.96 inch OLED, I2C OLED display.

The 2.4 inch 240x320 color TFT panel, over 4-wire SPI. DC says whether a byte is a command or data; everything else follows from that one line.

The two-axis thumb stick module, KY-023 style: two potentiometers and a push switch under one cap.

The KY-040 rotary encoder module, with its own push switch: a shaft that counts clicks either way around.

A passive piezo disc: the other half of the buzzer pair, with no oscillator built in. It sings whatever frequency you drive it at.

The three-pin rotary potentiometer every kit has a handful of. A carbon track from pin 1 to pin 3, with a wiper on pin 2 that runs along it as the shaft turns.

The 45 mm slide potentiometer off a mixing desk: the same carbon track as the rotary potentiometer, laid out straight with a knob you push along it.

A light-dependent resistor, the GL5528 style: a two-legged resistor whose value depends on how much light is falling on it. Aliases: photoresistor, photocell.

A two-lead NPN phototransistor in a clear 5 mm package, the light sensor in the Arduino Starter Kit.

The TO-92 analog temperature sensor, TMP36 style: three legs, no protocol, and a voltage that is the temperature.

The LM35 precision centigrade sensor in a TO-92 case: 10 mV a degree from 0 V at 0 °C. Aliases: LM35DZ, analog temperature sensor.

The MLX90614 on its GY-906 breakout reads the temperature of whatever it points at, without touching it. Aliases: GY-906, non-contact thermometer.

The AMG8833 Grid-EYE: an 8x8 thermal camera, sixty-four temperatures ten times a second over I2C. Aliases: Grid-EYE, AMG88xx, 8x8 thermal sensor.

The four-pin ultrasonic ranger, HC-SR04 style: two transducer cans, a 5 V supply, and two logic pins. Aliases: ultrasonic sensor, ping sensor.

The nine-gram hobby servo, SG90 style: three wires, and a horn that walks to the angle a pulse width tells it.

The TowerPro MG996R: a standard-size servo with metal gears, for when an SG90 is not strong enough. Aliases: MG996R, metal gear servo, standard servo.

A small brushed DC motor, the yellow gearbox kind: two terminals, and nothing driving it.

A six-button console-style pad: a four-way D-pad plus A and B, each switch to ground on its own pin.

The 30 mm cabinet button with a microswitch under it: the switch you can hold for an hour with no fatigue.

A 30 mm arcade button with an LED lamp inside: a microswitch on two tabs and a lamp with its resistor on the other two.

The lever in a fight stick or an arcade cabinet, Sanwa JLF style: a ball top on a shaft with four microswitches around its foot.

The rolling-ball tilt sensor, SW-520D and its twins: a little metal can with two legs and a conductive ball rolling between two contacts inside.

The small-signal and rectifier diode, 1N4148 and 1N400x style: current goes from anode to cathode and not the other way, and that is the whole part.

The 1 W 1N4728A to 1N4742A family. Reverse biased it blocks like any other diode until it reaches its own voltage, and then it holds it there.

A small-signal bipolar transistor, NPN and PNP, 2N2222 and BC547 style: a little current into the base lets a much larger one through from collector to emitter.

An infrared LED and a phototransistor sealed in one black DIP-6, facing each other across a gap of clear plastic.

An enhancement-mode MOSFET, N and P channel, 2N7000 and IRF540N style: a voltage on the gate switches the channel between drain and source.

A common-cathode RGB LED in one 5 mm package: four legs, three separate LED dice under one lens.

A red and a yellow-green LED under one 5 mm lens, sharing a leg. Aliases: bicolor LED, dual color LED, KY-011 (5 mm), KY-029 (3 mm).

A red, a yellow and a green LED in a row on a small board, each with its own resistor, and four pins. Aliases: traffic light LED module.

A 650 nm red laser diode in a brass barrel on a three-pin board. Aliases: KY-008, laser transmitter module, laser pointer module.

The single-channel relay module every kit ships: a coil, a spring, and a metal arm with a contact on the end.

The green boards with a row of blue relays, one screw terminal per relay and a control header at the end.

A bare 5 V double-pole double-throw signal relay, the small sealed kind: two changeover contacts on one arm, and a coil with nothing in front of it.

The red board with the black heat sink that drives the two wheels of nearly every robot car.

A small dual H-bridge breakout for two DC motors, from 2.7 V to 10.8 V, and the driver in many small robot kits.

The body of nearly every robot car kit: two TT gear motors on 65 mm wheels, a caster and encoder discs, driving across the canvas.

A two-wheel robot that falls over unless your code balances it, with its own MPU6050, TB6612 driver and encoders.

A lever microswitch with COM, NO and NC tags: the limit switch on robots, printers, turntables and conveyors.

A four-servo desktop robot arm: base, shoulder, elbow and claw, each an SG90 on its own signal pin.

A claw machine cabinet with the mechanism inside: gantry, winch, servo claw, prizes and a prize chute. Wire up its motors and the claw moves.

A vending machine cabinet: four spiral slots on continuous servos, a snack in every coil, and an infrared beam across the bin.

A pinball table you wire up: servo flippers, pop bumpers on a kicker coil, standup targets, a drain beam, a plunger and one steel ball.

A parking barrier: an MG996R arm, a traffic light and an HC-SR04 on one post, and cars that drive up the lane and wait at the line.

A candy color sorter: a feed disc carries each candy under a TCS34725, then drops it on a servo chute that sends it to one of six bins.

A touchless soap dispenser: an FC-51 infrared sensor beside the spout and a gear pump under the bottle, with a hand you slide under it.

A 16-channel, 12-bit PWM board that runs sixteen servos from two I2C wires, with the Adafruit PWM Servo Driver library built in.

The Toshiba TB6612FNG dual motor driver on its breakout board: two H bridges for two DC motors. Aliases: TB6612, SparkFun motor driver, dual H-bridge.

The HG7881 dual motor driver module: two L9110S chips, one per motor, on a small blue board. Aliases: L9110, HG7881, L9110S fan driver.

A gearbox motor with a two-channel Hall encoder, the JGA25-370, N20 or TT kind. Aliases: encoder motor, quadrature encoder motor.

A 9 V battery, a pack of AA cells or one or two 18650 cells, as a power source. Aliases: 9V battery, AA pack, 18650, Li-ion, 2S pack.

A small solar panel, the 6 V 1 W epoxy kind in STEM kits and solar builds. Aliases: solar cell, photovoltaic panel, PV panel, 6V 1W solar panel.

The TP4056 lithium-ion charger module, the small board with a USB socket that charges one 18650 cell. Aliases: Li-ion charger, 18650 charger.

A linear voltage regulator: the 7805, the AMS1117-3.3 module or the MCP1700-3.3 low dropout part. Aliases: LM7805, LDO, 3.3 V regulator.

The little green board that comes in the Elegoo starter kits and sits on the end of an MB-102 breadboard.

The two small carrier boards that turn a bipolar stepper in every 3D printer and CNC kit.

The square black motor on every 3D printer's axes: a bipolar hybrid stepper, 17HS4401 style, with two coils, four wires and 200 steps to a turn.

A 10 mm coin vibration motor, the disc inside every phone and game pad.

A small DC motor with a soft propeller on an L9110S driver board, run straight off two board pins. Aliases: L9110 fan module, mini fan module.

A thumb-sized submersible pump with an outlet spout and two leads, the pump of every plant-watering build. Aliases: submersible pump, mini pump.

A push-pull solenoid: a coil around a steel plunger that pulls in when current flows and springs back out when it stops.

A small 8 ohm speaker, the 40 mm paper cone in every kit: a coil in a magnet's gap, glued to a cone.

The mini thermal printer (CSN-A2): 58 mm paper, a 384-dot head and a TTL serial port for text and commands. Aliases: receipt printer, CSN-A2.

The 4x4 membrane keypad, the sticky-backed one on a ribbon: sixteen keys, eight pins, and no chip at all.

The membrane keypad in three sizes: a twelve-key telephone pad, a twenty-key calculator pad, and the 4x4 you already know.

A real PS/2 keyboard on the two wires it has, with eleven-bit frames and scan code set 2. Click it while the simulation runs and type on it for real.

A games cabinet in one body: a 128x64 OLED above a D-pad, A, B, Start and Select, with a twelve-pin header along the bottom.

The 16 by 2 character LCD, HD44780 style: sixteen pins, and a green or blue window with two rows of sixteen characters behind it.

The black "Capacitive Soil Moisture Sensor v1.2" stake: three pins at the head, no bare metal in the soil. Aliases: soil sensor, moisture sensor, plant sensor.

The Grove GSR module: two finger straps on a lead and a small board that turns your skin's conductance into a voltage. Aliases: GSR, skin response, EDA sensor.

The MQ-2 on its FC-22 comparator board: a steel mesh can on six legs, two lamps, a trimmer and four pins. Aliases: gas sensor, smoke sensor, LPG sensor.

An electret microphone on an LM393 comparator board with a blue trimmer, pins printed A0 G + D0. Aliases: sound sensor, microphone module, clap sensor.

The flame sensor module, KY-026 style: a black infrared receiver standing off the end of an LM393 comparator board. Aliases: fire sensor, IR flame sensor.

The rain sensor, FC-37 and YL-83 style: a plate of interleaved traces wired to an LM393 comparator board. Aliases: raindrop sensor, water sensor plate.

The red water level sensor from starter kits: ten bare traces up a long board and three pins printed S + -. Aliases: water sensor, liquid level sensor.

A pipe section with a magnet on a pinwheel and a Hall sensor outside it, and three wires. Aliases: YF-S201, Hall flow meter, water flow meter.

The TCRT5000 reflective sensor on its LM393 board: a line follower's eye and a short-range object sensor. Aliases: line sensor, IR reflective sensor.

A five-channel line tracking board: five TCRT5000 sensors in a row, each with a comparator and lamp. Aliases: line follower sensor.

The FC-51 infrared obstacle sensor: an IR LED and receiver on an LM393 board, one digital output. Aliases: KY-032, IR proximity sensor.

The SW-420 vibration sensor: a sealed vibration switch on an LM393 board, one digital output. Aliases: vibration switch, shake sensor.

The 49E linear Hall sensor (Honeywell SS49E), a TO-92 whose output follows the magnetic field. Aliases: SS49E, KY-035, analog Hall sensor.

A force-sensing resistor, Interlink FSR 402 style: a round half-inch pad on a flat tail, with two legs at the end. Aliases: FSR, pressure sensor, force sensor.

A flex sensor, the 2.2 inch Spectra Symbol strip: thin plastic with carbon ink along one side, two legs at one end. Aliases: bend sensor, flex strip.

The HX711 load cell amplifier on its green board, wired to a bar load cell: the kitchen scale every kit builds. Aliases: load cell, scale, weight sensor.

The Allegro A3144 Hall effect switch in a flat TO-92, and the magnet you hold up to it. Aliases: Hall sensor, KY-003, magnetic switch.

A slotted optical switch on its small board (the KY-010), with an encoder wheel to spin through the slot.

The TTP223 capacitive touch module: a small red board with a round pad printed on it. Aliases: touch button, capacitive touch sensor, touch pad.

The NXP MPR121: twelve capacitive touch electrodes on one I2C chip, here wired to twelve foil keys. Aliases: MPR121, 12-key touch sensor.

The R30x and AS608 optical fingerprint sensor: templates in its own flash and a serial protocol. Aliases: R307, AS608, ZFM-20, fingerprint reader.

A piece of aluminum foil on a wire: the touch sensor of the CapacitiveSensor library and the Starter Kit's touchy-feely lamp.

The programmable coin acceptor: a chrome face with a coin slot and a return lever, and a four-wire harness. Aliases: CH-926, multi coin acceptor, coin slot.

The RCWL-0516 Doppler radar module: OUT goes high when something moves in range, even through plastic and thin walls.

The big brother of the 16x2: four rows of twenty characters on the same HD44780 controller. Aliases: LCD2004, 2004A, 20x4 LCD.

The 1.3 inch 128x64 OLED module. Aliases: 1.3 inch OLED, SH1106G.

The 0.91 inch OLED strip: 128 by 32 pixels on the same SSD1306 as the 128x64 module, on the same two wires at the same address, 0x3C.

The 1.8 inch 128x160 color TFT on the red board with the SD card slot on the back. Aliases: 1.8 inch TFT, ST7735S, 128x160 TFT.

The small IPS color TFTs: the square 1.3 inch 240x240 board, the 2 inch 240x320, and the 1.14 inch 135x240 on the TTGO T-Display.

A 1.28 inch round IPS color display, 240x240 pixels, on a GalaxyCore GC9A01 driven over SPI. Aliases: round TFT, 1.28 inch round LCD, GC9A01A, watch display.

A 2.13 inch 250x122 black and white e-paper panel on an SSD1680 over SPI. Aliases: 2.13 inch e-ink, WeAct e-paper, DEPG0213BN.

The red 2.8 inch 240x320 TFT with a resistive touch panel: an ILI9341 display and an XPT2046 touch controller on one board.

The 84x48 screen out of the Nokia 5110 and 3310 phones, on a small board with eight pins. Aliases: Nokia 5110, PCD8544, 84x48 LCD.

Ten rectangular LEDs side by side in one 20-pin block. Aliases: 10 segment bar graph, DC-10, LED level meter.

Four 0.56 inch digits with their decimal points in one block, and no chip behind them.

Four red digits and a colon on an HT16K33 I2C backpack at 0x70 to 0x77. Aliases: Adafruit 7-segment backpack, I2C 4-digit display.

Two rows of sixteen characters, on sixteen pins or on four. The HD44780 command set, the busy flag that catches everybody, and the I2C backpack.

The LDR, the NTC thermistor, the reed switch, the tilt switch and the PIR: five cheap parts, four of which have no chip in them at all.

A board pin cannot run a motor. One transistor will switch one; an L293D will turn one round. What each costs you, and why.

The MPU6050, the DS3231 and the TM1637 all live on two wires. Two of them speak I2C and one of them does not.

The three-legged digital thermometer, also sold sealed in steel waterproof probes. Aliases: Dallas temperature sensor, 1-Wire probe, 18B20.

The MAX6675 board reads a K-type thermocouple up to 1023 degrees C and sends it over a read-only SPI line, a quarter degree a count.

The InvenSense MPU-9250 on the GY-9250 board: an accelerometer, a gyroscope and an AK8963 compass, all on one I2C bus.

The TM1638 "LED&KEY" board: eight seven-segment digits, eight LEDs and eight buttons on three wires, STB, CLK and DIO.

Bosch pressure sensors on a purple I2C breakout: the BMP280 reads pressure and temperature, and the BME280 adds humidity. Aliases: barometer, GY-BME280.

The Sensirion SHT31 on an I2C breakout: temperature and humidity at 0x44 or 0x45. Aliases: GY-SHT31-D, Adafruit SHT31-D, SHT30, SHT35.

The Lite-On LTR-390UV reads the UV index or the visible light over I2C at 0x53, one at a time, 13 to 20 bits at a gain of 1 to 18.

The TI OPT3001 measures light in lux the way the eye sees it, from 0.01 to 83865 lux, auto-ranging, over I2C at 0x44.

The ST LSM303AGR puts an accelerometer at 0x19 and a magnetometer at 0x1E in one package, the two halves of a tilt-compensated compass.

The ST LIS3MDL reads the magnetic field on three axes over I2C at 0x1C, up to 6842 counts a gauss: the sensor of a digital compass.

The ST LSM6DSOX six-axis IMU reads acceleration and turn rate, sixteen bits each, over I2C at 0x6A, from 12.5 Hz to 6.66 kHz.

The TI INA3221 measures three shunts and three bus voltages at one I2C address, for a project with several supply rails.

The TI INA228 measures current, bus voltage and power to 20 bits through a 15 milliohm shunt, and adds up energy and charge as it goes.

The TI INA226 measures current through a real 0.1 ohm shunt, the bus voltage and the power, to 2.5 microvolts, over I2C.

The MAX31865 reads a PT100 or PT1000 platinum RTD as a 15-bit resistance ratio over SPI, with fault thresholds and a data-ready pin.

The MAX31855K reads a K-type thermocouple from -270 to 1800 degrees C, with its own cold-junction temperature and fault bits, over read-only SPI.

The Infineon DPS310 reads air pressure to a fraction of a pascal, and temperature, over I2C at 0x77 or 0x76.

The Bosch BME680 reads temperature, humidity, pressure and the resistance of a heated gas plate, over I2C at 0x77 or 0x76.

The ST VL53L1X times a laser pulse to the target and back, and reports millimeters up to 4 m over I2C at 0x29.

The Sensirion SCD41 measures real CO2 in ppm, with temperature and humidity, over I2C at 0x62, one reading every five seconds.

The Sensirion SHT40 on an I2C breakout: temperature and humidity at 0x44, the SHT31's smaller and faster successor.

The Sensirion SGP30 air quality sensor on I2C at 0x58: CO2 equivalent in ppm and TVOC in ppb. Aliases: Adafruit SGP30, eCO2 sensor.

The TCS34725 color sensor on I2C at 0x29, with a white LED to light what it looks at. Aliases: Adafruit TCS34725, RGB color sensor, TCS3472.

The ASAIR AHT20 on its four-pin I2C breakout: temperature and relative humidity at address 0x38. Aliases: AHT20 module, AHT10 successor, DHT11 replacement.

The ROHM BH1750FVI on the GY-302 module: ambient light in lux over I2C, at address 0x23, or 0x5C with ADDR high. Aliases: GY-302, BH1750FVI, lux sensor.

The clock chip that every Arduino book used before the DS3231 got cheap, on a small breakout with a coin cell. Aliases: Tiny RTC, RTC module, DS1307 clock.

The DS1302 clock module with a coin cell and a watch crystal, on a three-wire interface of its own. Aliases: DS1302, RTC module, three-wire clock.

A current, voltage and power monitor on a purple breakout with a 0.1 Ω shunt resistor. Aliases: current sensor, power monitor, wattmeter module.

Four analog inputs and a sixteen-bit converter on a blue I2C breakout. Aliases: 16-bit ADC, analog to digital converter, ADS1015.

The NXP PCF8591 on the YL-40 module: four 8-bit analog inputs and one analog output on I2C.

The Analog Devices ADXL345 three-axis accelerometer on the GY-291 breakout.

The ADXL335 accelerometer on its GY-61 breakout: one analog voltage per axis, no bus and no library. Aliases: GY-61, analog accelerometer.

A light-dependent resistor on the four-pin LM393 comparator board.

A 10 k NTC thermistor and a 10 k resistor on a three-pin board. Aliases: KY-013, analog temperature module, thermistor module, Wokwi's NTC temperature sensor.

Sixteen analog switches with one common pin, on a breakout.

Eight analog switches with one common pin, in a 16-pin DIP: three address lines pick which channel reaches Z.

ON Semiconductor's NLSF595: a 595 shift register whose eight outputs are open drain, made to sink the cathodes of RGB LEDs.

The Bosch BMP180 barometric pressure and temperature sensor on the GY-68 breakout. Aliases: GY-68, BMP085 (its predecessor, same interface), barometer.

ST's VL53L0X laser distance sensor on its breakout board (GY-VL53L0XV2, Pololu, Adafruit).

The Sharp GP2Y0A21YK0F: two round lenses that measure 10 to 80 cm and give the distance as a voltage. Aliases: GP2Y0A21YK0F, Sharp IR sensor.

Maxim's MAX30102 heart-rate and blood-oxygen sensor on its breakout board.

The Pulse Sensor Amped: a green LED, a light sensor and an amplifier that put a fingertip's pulse on one analog wire. Aliases: PulseSensor, PPG sensor.

Broadcom's APDS-9960 on the GY-9960 breakout: ambient light, red, green and blue, proximity, and hand swipes, all from one chip.

The DFPlayer Mini MP3 module: a microSD card slot, a decoder and a small amplifier on a 16-pin board.

A telephone's rotary dial, with its pulse and off-normal contacts brought out to three wires. Aliases: phone dial, rotary dialer, pulse dial.

Two bipolar stepper motors on one axis, one shaft inside the other, so one body turns two hands like a clock.

A 2.9 inch black and white e-paper module on the Solomon Systech SSD1680, 296 by 128 pixels, over SPI: the Waveshare 2.9 inch V2 and the WeAct 2.9 inch boards.

A 2.8 inch 240 by 320 color TFT on an ILI9341, with an FT6206 capacitive touch controller on I2C.

A square 1.12 inch 128 by 128 monochrome OLED on the Sino Wealth SH1107, over I2C.

32 KB of memory that keeps its contents with the power off, in an eight-pin DIP. Aliases: external EEPROM, AT24C256, 24C256, I2C memory.

Eight more pins over two wires, on a small blue board. Aliases: I2C expander, port expander, PCF8574A, IO expansion board.

Sixteen more pins over I2C, in a 28-pin DIP. Aliases: 16-bit expander, port expander, MCP23S17.

The DHT sensor and the infrared remote share one thing, and it is the thing that matters: the information is in how long a pulse lasts.

The 28BYJ-48 and its ULN2003 board are the first motor most people meet that goes to a position rather than at a speed.

Mokxi does not model Bluetooth. What it models is the only half of an HC-05 a circuit can see, which is a UART.

Four probes, every edge with the time it happened, and a timing diagram on the face of the instrument.

The blue RC522 board with the antenna coil printed round its edge, and the cards that come in the bag with it. It reads 13.56 MHz cards and key fobs over SPI.

The small SPI breakout with a microSD socket, a 3.3 V regulator and a level shifter, and a 4 MB card in it. SD.h reads and writes files on it.

The GY-NEO6MV2 breakout: a u-blox NEO-6M, a square ceramic patch antenna and a green LED that blinks once a second when it knows where it is.

The little green 2.4 GHz transceiver with a zigzag antenna printed on the end. Aliases: nRF24, 2.4 GHz radio, RF module.

Several ways in, one account, and what happens on the first sign-in.

Projects, lessons, classes, progress, the plan, and the settings beside them.

What each Mokxi plan costs, from the free plan through Hobby, Pro and Pro for work, and exactly what each one changes.

Stripe Checkout, the customer portal, and what happens to a project when a plan ends.

Pro at half price, verified by a school email address, for twelve months at a time.

Invite a friend, you both get 7 days of Pro: your link, what counts, and what it gives.

Tokens for scripts, CI and editor plugins, and what they can do.

Keep a project in a folder of your own, sync it with Mokxi, and run it from a terminal.

Run your Arduino, ESP32 or Pico sketch in the simulator on every push, and fail the build when its output, a pin or an LED is wrong. Part of Pro for work.

What it is, how to get it, and how to stop getting it.

What a live room is, who can start one, and what everybody in it sees.

Two links per room, what each one allows, and how to revoke them.

The per-plan limit, what a refused joiner sees, and how a room stops.

Making a class, the dashboard, and the demo class to try it on.

How students get in, what the roster holds, and how many seats a plan has.

Giving a class something to build, and getting it back.

Write the checks once; every submission is measured against them.

The code, the assignment list, and the Submit button in the editor.

Eleven paths, a hundred-odd lessons, and how a lesson checks your circuit.

What earns XP, what the numbers are, and the levels they add up to.

How a streak is counted, the three daily quests, and the badges tied to real events.

One challenge a day, and a weekly leaderboard that lists only the people who choose to be on it.

A complete home-built pinball controller on a Mega, and a five-lesson course that builds it one stage at a time.

A three-reel slot machine on an Uno with a real arcade lever, and the honest math behind its odds.

Template a button box, a shifter with a handbrake or a flight panel on a Pro Micro, and test the code before you buy parts.

Build a key matrix with a diode on every key, watch it scanned, and try layers, an encoder and per-key RGB before you solder.

Five ESP32-C3 devices for Home Assistant, the Arduino code they run in Mokxi, and the ESPHome YAML you would flash at home.

Servo turnouts, a level crossing, block signals and a DC throttle on an Arduino Uno, and what each one models.

Stepper homing, a heated bed PID loop with thermal runaway protection, a mini G-code plotter and a runout sensor.

Reading the Build tab, and the four things that usually cause it.

No power, no ground, a floating net, or a part that was never wired.

Which pins carry a UART, and what the monitor is actually listening to.

What the readout is telling you, and what makes a circuit expensive.

What counts as a connection, and why a pin sometimes refuses one.

What to check, in order, when an instrument is not telling you what you expected.

The project cap, private browsing, and what the save label was telling you.

Where the mail comes from, how long the link lasts, and what to try.

The three things that go wrong on that round trip, and what each one means.

The digital kernel, the analog islands and the SPICE deck runner, and what each one does not model.

The peripherals, the memory map and the timing of the DevKitM-1.

The ATmega328P, with its timers, USART, ADC, interrupts, sleep and EEPROM.

The Uno's chip on a board that fits a breadboard, with two analog-only pins.

The ATmega2560: eleven ports, six timers, four USARTs and a sixteen-channel ADC.

The ATmega32U4, whose USB goes to the chip: Serial is a CDC endpoint and Serial1 is the UART.

The DevKitC-1: thirty-one GPIOs, one SRAM window, and a plain account of what is not modeled.

The classic ESP32 on an Xtensa LX6: the GPIO matrix, LEDC, ADC1, and one core where the chip has two.

The S3 on an Xtensa LX7: one SRAM seen through two buses, the GPIO matrix, the USB serial port, LEDC, the RMT behind the RGB LED, and one core where the chip has two.

The LX106 in the call0 ABI, GPIO16 that is not a GPIO, software PWM, and the one block whose registers are invented.

The Pico with a CYW43439 on it: the chip is not modeled, the WiFi is simulated, and the LED behind it works.

The ATSAMD21G18A: two PORT groups, SERCOMs as USARTs, TCC and TC PWM, the ADC on every pad, and the USB as a byte pipe.

The RP2040 on our Cortex-M0+ core, with SIO GPIO, the TIMER, UART0 and PWM.

The Black Pill on our Cortex-M4 core, with GPIO, TIM2 to TIM5, USART1 and SysTick.

The nRF52833 on our Cortex-M4 core, with GPIO, GPIOTE, the TIMERs, RTC0, UARTE0 and the LED matrix.

The F103 on our Cortex-M3 core, with CRL and CRH GPIO, TIM1 to TIM4, USART1 and a twelve-bit ADC.

The RA4M1 on our Cortex-M4 core: the PFS port block, GPT PWM, SCI2 as Serial1 and a fourteen-bit ADC.

A whole microcontroller in eight pins: the tinyAVR core, two timers, the ADC, the USI and a serial port it bit-bangs.

How a sketch becomes firmware with no build server anywhere.

The network a sketch joins: what is faithful, what is Mokxi’s own, and what is not there at all.