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.

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.

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.

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 and PWM.

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 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 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.

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 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.

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.

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 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.

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 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 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 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 8 ohm speaker, the 40 mm paper cone in every kit: a coil in a magnet's gap, glued to a cone.

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 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.

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 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.

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 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.

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.

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.

Four 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 up, 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.

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.

Six 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.

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.