Adafruit QT Py & Trinket M0: Tiny Powerful Microcontrollers

When space is tight but you still need real processing power, Adafruit’s smallest boards deliver. I’ve used the QT Py and Trinket M0 in dozens of projects—from wearable LED controllers to compact sensor nodes—and they consistently punch above their weight class.

This guide covers the complete Adafruit QT Py family (including the QT Py RP2040 and QT Py ESP32 variants), the classic Adafruit Trinket M0, and how they compare to the larger ItsyBitsy line. Whether you’re prototyping a quick idea or building something permanent, these tiny boards make the job easier.

Understanding the Adafruit Tiny Board Lineup

Adafruit offers several small-form-factor development boards, each targeting different use cases. The naming can be confusing at first, but the hierarchy makes sense once you understand it.

QT Py: The Smallest with STEMMA QT

The Adafruit QT Py is the smallest development board in the lineup, measuring just 22mm x 17.9mm. What makes it special is the built-in STEMMA QT connector—a standardized I2C port that lets you connect sensors and displays without any soldering.

The form factor matches Seeed’s Xiao boards, featuring castellated pads that allow surface-mount soldering directly to custom PCBs. This is huge for production projects where you want a pre-built microcontroller module rather than designing around raw chips.

Trinket M0: The Classic Compact

The Trinket M0 predates the QT Py and uses the same SAMD21 chip but in a different form factor. It’s slightly larger and doesn’t include the STEMMA QT connector, but provides the same processing power with a simpler pinout that many find easier to work with.

The Adafruit Trinket line has existed for years—the M0 version upgraded the original ATtiny85-based Trinket to the much more capable ARM Cortex-M0+ architecture while keeping backward compatibility with existing code.

ItsyBitsy: More Pins, More Power

When you need more GPIO than the QT Py provides but still want something compact, the ItsyBitsy fills that gap. At 36mm x 18mm, it’s larger than both the QT Py and Trinket but offers 23 GPIO pins compared to the QT Py’s 11.

The ItsyBitsy also includes a level-shifted 5V output pin, making it perfect for driving NeoPixels and servos without external circuitry.

QT Py Variants Comparison

The QT Py form factor now hosts multiple processor options. Choosing the right one depends on your project requirements.

Model	Processor	Speed	Flash	RAM	WiFi	Bluetooth	Price Range
QT Py SAMD21	Cortex-M0+	48 MHz	256KB	32KB	No	No	~$7
QT Py RP2040	Dual Cortex-M0+	125 MHz	8MB	264KB	No	No	~$10
QT Py ESP32-S2	Tensilica	240 MHz	4MB	2MB PSRAM	Yes	No	~$13
QT Py ESP32-S3 (8MB)	Dual Tensilica	240 MHz	8MB	512KB	Yes	BLE	~$13
QT Py ESP32-S3 (4MB)	Dual Tensilica	240 MHz	4MB	2MB PSRAM	Yes	BLE	~$15

QT Py RP2040: The Performance Pick

The QT Py RP2040 packs the Raspberry Pi RP2040 chip into the tiny QT Py form factor. With dual 125 MHz cores and 264KB of RAM, it handles complex tasks that would choke the SAMD21 version.

The RP2040’s PIO (Programmable I/O) system is particularly valuable. Instead of bit-banging protocols like NeoPixel timing in software, PIO handles them in dedicated hardware. This frees the main cores for other work and ensures perfectly accurate timing regardless of what else the processor is doing.

Key QT Py RP2040 specifications:

• Dual-core ARM Cortex-M0+ at 125 MHz
• 264KB SRAM
• 8MB QSPI flash
• 4 analog inputs (12-bit ADC)
• 11 GPIO pins (all can be PWM)
• Native USB (HID, MIDI, CDC)
• STEMMA QT / Qwiic I2C connector

QT Py ESP32 Variants: WiFi in a Tiny Package

When your project needs wireless connectivity, the QT Py ESP32 variants deliver WiFi and (in the S3 models) Bluetooth in the same compact form factor.

The QT Py ESP32-S2 provides WiFi with native USB but no Bluetooth. The newer S3 variants add dual cores and Bluetooth Low Energy support. If you need to buffer large amounts of data (like images or JSON responses), the 4MB flash / 2MB PSRAM version handles that well.

For IoT projects, these boards eliminate the need for separate WiFi modules. The ESP32-S3 variant with 8MB flash is my go-to for CircuitPython IoT work—plenty of room for code, libraries, and cached data.

Trinket M0 Specifications and Features

The Adafruit Trinket M0 shares the SAMD21 chip with the original QT Py but targets a slightly different use case.

Feature	Trinket M0
Processor	ATSAMD21E18 ARM Cortex-M0+
Clock Speed	48 MHz
Flash Memory	256KB
RAM	32KB
GPIO Pins	5 (all usable)
Analog Inputs	3 (12-bit)
True Analog Output	1 (10-bit DAC)
PWM Outputs	2
Native USB	Yes
Onboard LED	DotStar RGB + Red LED
Dimensions	27mm x 15mm

The Trinket M0 excels at simple, dedicated tasks. Five GPIO pins might sound limiting, but for driving a NeoPixel strip, reading a sensor, or acting as a USB HID device, it’s plenty. The true analog output (DAC) is particularly useful—you can generate actual waveforms, not just PWM approximations.

Trinket M0 vs Original Trinket

The original Adafruit Trinket used an ATtiny85—an 8-bit AVR running at 8 or 16 MHz with just 8KB of flash and 512 bytes of RAM. The M0 upgrade brought:

• 32-bit ARM architecture vs 8-bit AVR
• 256KB flash vs 8KB (32x more)
• 32KB RAM vs 512 bytes (64x more)
• Native USB vs bit-banged USB
• CircuitPython support (impossible on ATtiny85)

Despite these massive improvements, pin compatibility was maintained where possible, allowing many existing Trinket projects to migrate with minimal changes.

ItsyBitsy: When You Need More GPIO

The ItsyBitsy family sits between the tiny QT Py/Trinket boards and the larger Feather format. When 5-11 GPIO pins aren’t enough, ItsyBitsy’s 23 pins provide room to grow.

Feature	ItsyBitsy M0	ItsyBitsy M4	ItsyBitsy RP2040
Processor	SAMD21	SAMD51	RP2040
Cores	1	1	2
Speed	48 MHz	120 MHz	125 MHz
Flash	256KB	512KB	8MB
RAM	32KB	192KB	264KB
GPIO	23	23	23
Analog In	11	12	4
PWM	10	16	16
Level-shifted Pin	Yes (D5)	Yes (D5)	Yes (D5)

The ItsyBitsy RP2040 is particularly compelling. Same RP2040 chip as the QT Py version, but with more than double the accessible GPIO pins. The level-shifted D5 output simplifies driving 5V peripherals from the 3.3V logic board.

Getting Started with CircuitPython

All these boards support CircuitPython, which makes them incredibly beginner-friendly while still being powerful enough for serious projects.

Installing CircuitPython on QT Py

1. Download the appropriate UF2 file from circuitpython.org for your specific board variant
2. Connect the board via USB-C (QT Py) or Micro-B (Trinket M0)
3. Double-click the reset button—the NeoPixel will turn green
4. A drive called QTPY_BOOT (or TRINKETBOOT) appears
5. Drag the UF2 file to the boot drive
6. The board reboots and appears as CIRCUITPY

Basic CircuitPython Example

python

import boardimport neopixelimport time# Initialize the onboard NeoPixelpixel = neopixel.NeoPixel(board.NEOPIXEL, 1, brightness=0.3)# Color cyclecolors = [(255, 0, 0), (0, 255, 0), (0, 0, 255)]while True:    for color in colors:        pixel.fill(color)        time.sleep(0.5)

This code works on any QT Py, Trinket M0, or ItsyBitsy with minimal modification—CircuitPython abstracts the hardware differences.

Arduino IDE Setup for Adafruit Boards

While CircuitPython is great for rapid prototyping, Arduino provides more control and better performance for demanding applications.

Adding Adafruit Board Support

1. Open Arduino IDE preferences
2. Add this URL to Additional Board Manager URLs: https://adafruit.github.io/arduino-board-index/package_adafruit_index.json
3. Open Tools → Board → Boards Manager
4. Search “Adafruit SAMD” and install for M0 boards
5. Search “Adafruit RP2040” for RP2040-based boards
6. Select your specific board from Tools → Board

Arduino Blink Example

cpp

void setup() {  pinMode(LED_BUILTIN, OUTPUT);}void loop() {  digitalWrite(LED_BUILTIN, HIGH);  delay(500);  digitalWrite(LED_BUILTIN, LOW);  delay(500);}

Note: The QT Py doesn’t have a traditional LED_BUILTIN—it has an addressable NeoPixel instead. Use the Adafruit NeoPixel library for LED control on QT Py boards.

Practical Applications

Wearable Projects

The Trinket M0 and QT Py excel in wearables. Their tiny size, low power consumption, and ability to drive NeoPixels directly make them perfect for:

• LED jewelry and accessories
• Costume lighting effects
• Fitness trackers (with external sensors)
• Interactive fashion

IoT Sensor Nodes

The QT Py ESP32 variants enable wireless sensor projects without bulky hardware:

• Temperature/humidity monitoring
• Air quality sensors
• Plant moisture monitors
• Home automation triggers

The STEMMA QT connector lets you add sensors without soldering—perfect for rapid prototyping or when you need to swap sensors between projects.

USB HID Devices

All these boards support native USB, enabling custom input devices:

• Macro keyboards
• Game controllers
• MIDI instruments
• Accessibility devices

The QT Py RP2040 handles USB HID particularly well, with enough processing power to handle complex input logic while maintaining responsive USB communication.

Essential Resources and Downloads

Resource	URL	Description
QT Py SAMD21 Guide	learn.adafruit.com/adafruit-qt-py	Official documentation
QT Py RP2040 Guide	learn.adafruit.com/adafruit-qt-py-2040	RP2040 variant guide
QT Py ESP32-S3 Guide	learn.adafruit.com/adafruit-qt-py-esp32-s3	WiFi/BLE variant guide
Trinket M0 Guide	learn.adafruit.com/adafruit-trinket-m0-circuitpython-arduino	Trinket documentation
CircuitPython Downloads	circuitpython.org/downloads	Firmware for all boards
Arduino Board Package	github.com/adafruit/Adafruit_Arduino_Boards	Arduino support files
Adafruit NeoPixel Library	github.com/adafruit/Adafruit_NeoPixel	LED control library
CircuitPython Libraries	circuitpython.org/libraries	Driver library bundle

Troubleshooting Common Issues

Board Not Recognized by Computer

• Verify you’re using a data-capable USB cable (not charge-only)
• Try a different USB port
• Double-click reset to enter bootloader mode (NeoPixel turns green)
• On Windows, check Device Manager for driver issues

CircuitPython Drive Doesn’t Appear

• The board might be in Arduino mode—double-click reset to access bootloader
• Reinstall CircuitPython by dragging the UF2 file to the boot drive
• Check if the drive is mounting but hidden (common on macOS)

Code Changes Not Taking Effect

• CircuitPython auto-reloads when you save code.py
• Make sure you’re saving to the CIRCUITPY drive, not your computer
• Don’t unplug or reset while saving—this can corrupt the filesystem

Running Out of Memory

• QT Py SAMD21 has limited RAM (32KB)—avoid large data structures
• Use the QT Py RP2040 (264KB) or ESP32 variants (2MB PSRAM) for memory-intensive projects
• Minimize imported libraries—only import what you need

Frequently Asked Questions

Which QT Py should I buy for my first project?

Start with the QT Py RP2040. It offers the best balance of price, performance, and ease of use. The dual-core processor handles most projects effortlessly, and 8MB of flash provides plenty of room for CircuitPython code and libraries. Only consider the ESP32 variants if you specifically need WiFi or Bluetooth.

Can I use QT Py boards with Arduino instead of CircuitPython?

Yes. All Adafruit QT Py variants work with Arduino IDE. Install the appropriate board support package (Adafruit SAMD for SAMD21, Arduino-Pico for RP2040, or Espressif ESP32 for ESP32 variants). Arduino offers better performance and lower-level control, while CircuitPython prioritizes ease of development.

What’s the difference between QT Py and Trinket M0?

The Trinket M0 and QT Py SAMD21 use the same processor, but differ in form factor and features. QT Py includes a STEMMA QT connector for solderless I2C connections and has a Seeed Xiao-compatible footprint with castellated pads. Trinket M0 is slightly larger with a different pinout but includes a traditional red LED alongside the RGB LED. Choose QT Py for I2C sensor projects; choose Trinket M0 for simpler projects where the classic form factor works better.

How do I add more storage to the QT Py SAMD21?

The QT Py SAMD21 has pads on the bottom for soldering a GD25Q16 SPI flash chip, adding 2MB of storage. After soldering the chip, install the “Haxpress” version of CircuitPython, which includes drivers for the external flash. This upgrade is essential if you need to store data files, images, or larger CircuitPython projects on the SAMD21 version.

Can I power these boards from a battery?

Yes, but with caveats. The QT Py ESP32-S3 includes battery input pads with protection circuitry for LiPo batteries up to 6V. For other boards, you can supply 3.3-5V to the appropriate power pins, but you’ll need external charging and protection circuitry. For battery projects, consider pairing the board with an Adafruit LiPo charger module or using a Feather-format board that includes built-in battery management.

Choosing the Right Board for Your Project

After working with all these boards extensively, here’s my decision framework:

Choose QT Py SAMD21 when:

• Budget is tight
• Project is simple (basic I/O, simple sensors)
• You need the smallest possible footprint
• STEMMA QT connectivity is important

Choose QT Py RP2040 when:

• You need more processing power or RAM
• Working with timing-critical protocols (NeoPixels, etc.)
• Dual-core processing would help
• You want the best price/performance ratio

Choose QT Py ESP32 when:

• WiFi connectivity is required
• Bluetooth LE is needed (S3 variants only)
• Project involves IoT or web connectivity
• You need to buffer large data sets (PSRAM versions)

Choose Trinket M0 when:

• You don’t need STEMMA QT
• The classic Trinket form factor fits your enclosure
• You want the true analog output (DAC)
• Migrating from an original Trinket project

Choose ItsyBitsy when:

• You need more than 11 GPIO pins
• The project requires level-shifted 5V output
• You want more analog inputs
• Size allows for a slightly larger board

The beauty of Adafruit’s ecosystem is that CircuitPython code transfers between boards with minimal changes. Start prototyping on whatever board you have, then optimize your board choice once you understand your project’s actual requirements.

Power Consumption Considerations

For battery-powered projects, understanding power draw matters. Here’s what I’ve measured in typical use cases:

Board	Idle (Sleep)	Active	WiFi Active
QT Py SAMD21	~0.5 mA	~15 mA	N/A
QT Py RP2040	~1.5 mA	~25 mA	N/A
QT Py ESP32-S2	~2 mA	~40 mA	~120 mA
QT Py ESP32-S3	~2.5 mA	~45 mA	~130 mA
Trinket M0	~0.5 mA	~15 mA	N/A

The ESP32 variants draw significantly more power, especially during WiFi transmission. For battery projects that need long runtime without connectivity, the SAMD21 or RP2040 versions provide better efficiency. The RP2040’s dormant mode can drop consumption dramatically when configured properly.

Final Thoughts

The Adafruit QT Py and Trinket M0 represent years of refinement in small-form-factor development boards. They’ve found the sweet spot between size, capability, and ease of use that makes prototyping genuinely enjoyable.

The STEMMA QT ecosystem particularly transforms how I approach projects. Being able to snap together sensors, displays, and controllers without soldering means I can iterate through ideas in minutes rather than hours. When the prototype works, the same code runs on the same board in the final project.

For newcomers to microcontrollers, these boards lower the barrier to entry substantially. For experienced developers, they provide capable platforms that don’t waste time on unnecessary complexity. Either way, having a few QT Py and Trinket M0 boards in your parts drawer means you’re always ready when inspiration strikes.