Getting Started with XIAO ESP32-S3 and Arduino IDE

The Seeed Studio XIAO ESP32-S3 is a small microcontroller board designed for embedded and IoT applications. It is part of the XIAO series, which focuses on very small form factor boards with strong processing capability. The board measures only about 21 × 17.8 mm, making it suitable for space-constrained designs.

It is based on the ESP32-S3 chip with a dual-core Xtensa LX7 processor running up to 240 MHz. The board includes integrated Wi-Fi and Bluetooth Low Energy, enabling wireless communication without additional hardware. It also provides built-in flash and PSRAM, which supports more advanced applications such as edge AI and data processing.

Power management is an important feature of this board. It supports battery charging and offers low-power modes for energy-efficient designs. This makes it suitable for portable and battery-powered projects.

In this tutorial you will learn how the program the XIAO ESP32-S3 using the Arduino IDE.

Where to Buy

You can get the XIAO ESP32-S3 at Seeed Studio or Amazon. You will also need a USB-C cable, if you haven’t one already. Also a small heatsink might be needed, should you run heavy compute on the board.

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Features of the XIAO ESP32-S3 board

The XIAO ESP32-S3 is built around the ESP32-S3R8 system-on-chip. It uses a dual-core Xtensa LX7 processor with a 32-bit architecture. The CPU can run at a clock frequency of up to 240 MHz. The photo below shows the front and back of the board:

The chip provides 8 MB of flash memory and 8 MB of PSRAM. This extended memory allows the execution of more complex firmware and supports buffering for data-intensive applications such as audio or image processing.

The ESP32-S3 also includes hardware support for vector instructions. This improves performance for signal processing and neural network inference.

Wireless Connectivity

The board integrates a full 2.4 GHz Wi-Fi subsystem. It supports IEEE 802.11 b/g/n standards for network communication. The Wi-Fi radio is built into the chip and does not require external components apart from an antenna for better reception. The picture below shows the XIAO ESP32-S3 with the external antenna attached.

Bluetooth Low Energy 5.0 is also supported. This enables low-power communication with sensors, smartphones, and other BLE devices. The chip can also operate in Bluetooth Mesh mode for distributed IoT networks.

GPIO and Peripheral Interfaces

The XIAO ESP32-S3 exposes multiple digital and analog interfaces. It provides up to 11 GPIO pins with PWM capability. It also includes up to 9 ADC channels for analog input. The following picture shows the pinout of the XIAO ESP32-S3:

The board supports common communication protocols. These include UART, I2C, and SPI. The ESP32-S3 uses a flexible GPIO matrix. This allows most peripheral functions to be mapped to different pins.

Dedicated pins are available for I2C communication using SDA and SCL signals. SPI signals include clock, MOSI, and MISO lines. UART is available for serial communication and debugging.

Additional features include a user LED and a charge status LED. There are also reset and boot buttons for firmware control and flashing.

USB and System Integration

The ESP32-S3 includes native USB support. The XIAO board uses a USB-C connector for power, programming, and data transfer. The USB interface is directly connected to the microcontroller. It does not require an external USB-to-serial converter.

The chip supports USB OTG functionality. This allows it to act as both a USB device and a USB host. This feature enables applications such as USB HID devices or data logging to external storage.

Power Management

The board supports both USB and battery power input. A built-in charging circuit allows charging of a 3.7 V lithium battery. This enables standalone operation without external power management hardware.

The operating voltage is typically 3.3 V. The onboard regulator provides stable power for the microcontroller and peripherals.

The ESP32-S3 supports multiple power-saving modes. These include modem sleep, light sleep, and deep sleep. The table below shows the current consumption of the ESP32-S3 for different modes:

Mode	Typical Current (Chip)	Unit	Description
Modem Sleep	~10.5 – 90	mA	CPU active, Wi-Fi disabled
Light Sleep	~240 – 750	µA	CPU paused, memory retained
Deep Sleep	~7 – 25	µA	RTC active, most of system powered down

These values represent the ESP32-S3 chip itself. The XIAO ESP32-S3 board will typically consume a bit more current due to onboard hardware.

Technical Specification

The following table summarizes the technical features of the XIAO ESP32-S3:

Parameter	Specification
Microcontroller	ESP32-S3R8 (Xtensa LX7 dual-core)
CPU Frequency	Up to 240 MHz
Architecture	32-bit
Flash Memory	8 MB
PSRAM	8 MB
Wireless	Wi-Fi 802.11 b/g/n, Bluetooth LE 5.0
USB	USB-C, native USB OTG
GPIO Pins	Up to 11
ADC Channels	Up to 9
Communication Interfaces	UART, I2C, SPI
Operating Voltage	3.3 V
Power Input	USB-C or 3.7 V LiPo battery
Power Features	Battery charging, deep sleep support
Dimensions	~21 × 17.8 mm
Additional Features	User LED, charge LED, reset and boot buttons

Comparison of the XIAO ESP32-S3 with other popular ESP32 boards

The ESP32 ecosystem has grown significantly, and choosing the right board can be confusing. The table below compares the most popular options, including the compact XIAO series and classic ESP32 boards.

Feature	XIAO ESP32-S3	XIAO ESP32-S3 Plus	XIAO ESP32-S3 Sense	ESP32-C5	ESP32 DevKit	ESP32-CAM
MCU	ESP32-S3	ESP32-S3	ESP32-S3	ESP32-C5	ESP32	ESP32
CPU	Dual-core LX7	Dual-core LX7	Dual-core LX7	RISC-V	Dual-core LX6	Dual-core LX6
Clock Speed	240 MHz	240 MHz	240 MHz	240 MHz	240 MHz	240 MHz
AI Acceleration	✅	✅	✅	❌	❌	❌
PSRAM	8 MB	Up to 8MB+	8 MB	❌	Optional	4 MB
Flash	8–16 MB	Up to 16MB+	8–16 MB	External	4–16 MB	4 MB
Wi-Fi	2.4 GHz	2.4 GHz	2.4 GHz	Wi-Fi 6 (2.4 + 5 GHz)	2.4 GHz	2.4 GHz
Bluetooth	BLE 5	BLE 5	BLE 5	BLE 5.3	Classic + BLE	Classic + BLE
USB	Native USB	Native USB	Native USB	Depends on board	UART chip	No
Camera	❌	❌	✅	❌	❌	✅
Microphone	❌	❌	✅	❌	❌	❌
Form Factor	Ultra compact	Compact	Compact + add-on	Varies	Large	Module
GPIO	Limited	Moderate	Limited	Moderate	High	Very limited
Best Use Case	Compact IoT	Expansion projects	AI / Vision	Wi-Fi 6 IoT	General prototyping	Camera streaming

---

Which board should you choose?

• XIAO ESP32-S3: Best balance of size, performance, and features for most IoT projects.
• XIAO ESP32-S3 Plus: Good choice if you need more expansion options and flexibility.
• XIAO ESP32-S3 Sense: Ideal for AI, camera, and audio projects (face recognition, object detection).
• ESP32-C5: Best for modern wireless applications with Wi-Fi 6 and 5 GHz support.
• ESP32 DevKit: Perfect for beginners and breadboard prototyping with maximum GPIO access.
• ESP32-CAM: Low-cost option for simple camera streaming projects, but more limited.

One of the most overlooked advantages of the ESP32-S3 is its native USB capability. Unlike classic ESP32 boards, which rely on an external UART chip for communication, the S3 can interface directly over USB. This enables powerful features such as USB HID functionality (allowing the board to act as a keyboard or mouse) and native CDC serial communication without additional hardware.

Also note the importance of PSRAM for applications that handle large or continuous data streams, such as audio processing, video capture, and AI workloads. These use cases quickly exceed the limited internal SRAM of typical microcontrollers. In practice, PSRAM often makes the difference between a project that barely works and one that runs reliably.

If you’re starting a new project in 2026, the ESP32-S3 family is generally the best choice due to native USB support and AI acceleration. The classic ESP32 boards are still useful, but mainly for cost-sensitive or legacy projects that don’t require any of the new features of the ESP32-S3.

Install ESP32 Core

If you want to use the Arduino IDE to program the board, you first need to install the ESP32 Core to enable support for ESP32 boards within the Arduino IDE. Open your Arduino IDE and follow the steps outlined below. If you have issues, you can find more detailed instructions in our tutorial Install ESP32 core in Arduino IDE .

Additional boards manager URLs

First open the Preferences dialog by selecting “Preferences…” from the “File” menu:

This will open the Preferences dialog shown below. Under the Settings tab you will find an edit box at the bottom of the dialog that is labelled “Additional boards manager URLs”:

In this input field copy the following URL: “https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json“

This will let the Arduino IDE know, where to find the ESP32 core libraries. Next we will actually install the ESP32 core libraries using the Boards Manager.

Boards Manager

Open the BOARDS MANAGER by clicking on the board icon in the sidebar of the Arduino IDE:

You will see the BOARDS MANAGER appearing right to the Sidebar. Enter “ESP32” in the search field at the top and you should see two types of ESP32 boards; the “Arduino ESP32 Boards” and the “esp32 by Espressif” boards. We want the esp32 libraries by Espressif. Click on the INSTALL button and wait until the download and install is complete.

Once installed, your Boards Manager should look like this, though the actual version (here 3.3.7) might be different.

In the next step, I show you how to select the ESP32 board for the XIAO ESP32-S3.

Select XIAO_ESP32S3 board

You can select a board from the drop-down selector under the menu bar: In the example below it shows an Arduino Uno as selected board, for instance:

Clicking on the name of the currently selected board (Arduino Uno), will open the board selection dialog. In the search box type “xiao s3” and select the “XIAO_ESP32S3” as shown below:

If the board is connected to your PC via USB, you should also be able to select the COM port. In the screenshot above this is COM13 but in your case it might be another COM port.

Code Examples

In this section, I will provide you with some code examples to try out the main features of the XIAO ESP32-S3.

Find I2C and SPI pins

This first code examples prints out the I2C and SPI interfaces, which you will need to connect many sensors and displays:

void print(const char* name, int pin) {
  Serial.print(name);
  Serial.println(pin);
}

void setup() {
  Serial.begin(115200);
  delay(2000);

  print("LED:  ", LED_BUILTIN);

  print("SDA:  ", SDA);
  print("SCL:  ", SCL);

  print("SS:   ", SS);
  print("MOSI: ", MOSI);
  print("MISO: ", MISO);
  print("SCK:  ", SCK);  
}

void loop() { }

You can use this code for other boards that are supported in the Arduino IDE as well. For more information see the Find I2C and SPI default pins tutorial. For the XIAO ESP32-S3 this code prints:

LED:  21
SDA:  5
SCL:  6
SS:   44
MOSI: 9
MISO: 8
SCK:  7

Blink on-board LED

This is the common Blink example. It switches the on-board LED on and off for one second. The on-board LED of the XIAO ESP32-S3 is connected to GPIO21 but is inverted. LOW means the LED is on and HIGH means the LED is off. You can see this in the code example below:

void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  Serial.println("Off");
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);     
  Serial.println("On");                 
  digitalWrite(LED_BUILTIN, LOW);   
  delay(1000);                      
}

Read & Write GPIO

In the following very short examples, we read and write GPIO. For specifying pins in code you can use the GPIO x number or the Dx number. For instance, according to the pinout, D3 or GPIO4 identify the same pin and in your code you can use either. The following two code example are identical in function and set GPIO4 to HIGH:

digitalWrite(D3, HIGH);  // D3 == GPIO4

digitalWrite(4, HIGH);  // D3 == GPIO4

If you want to read analog signals you can use the predefined Ax constants. For instance, the following code reads an analog input from A3, which is the same as the GPIO4 pin:

int val = analogRead(A3);  // A3 == GPIO4

int val = analogRead(4);  // A3 == GPIO4

Analog values range from 0 to 4095, which is equivalent to a voltage at the input between 0 and 3.3V.

Touch Input

This example demonstrates how to use the capacitive touch pins of the XIAO ESP32-S3 to detect touch inputs. If you touch the first pin (D0) of the board the built-in LED will switch on. You may have to adjust the detection threshold.

void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  int value = touchRead(T1);
  Serial.println(value);

  if (value > 30000) { 
    digitalWrite(LED_BUILTIN, LOW);
  } else {
    digitalWrite(LED_BUILTIN, HIGH);
  }

  delay(200);
}

HID for Volume Control

The ESP32-S3 supports USB HID (Human Interface Device), which means you can control computer devices such as keyboard or volume with the connected ESP32. In the following examples we use the touch inputs T1 and T2 to increase or decrease the computer’s volume:

#include "USB.h"
#include "USBHIDConsumerControl.h"

USBHIDConsumerControl UCC;

#define TOUCH_THRESHOLD 30000

bool upPressed() {
  return touchRead(T1) > TOUCH_THRESHOLD;
}

bool downPressed() {
  return touchRead(T2) > TOUCH_THRESHOLD;
}

void setup() {
  USB.begin();
  UCC.begin();
}

void loop() {
  if (upPressed()) {
    UCC.press(CONSUMER_CONTROL_VOLUME_INCREMENT);
    UCC.release();
  }
  if (downPressed()) {
    UCC.press(CONSUMER_CONTROL_VOLUME_DECREMENT);
    UCC.release();
  }
  delay(100);
}

Instead of the touch inputs, you obviously could also connect buttons. But with the touch inputs you just need to insert cables at the first (D0) and second (D1) pin to try out the volume controller code.

See the arduino-esp32 library for more HID examples. Watch out when using the ESP32 for HID, since you can easily disable your mouse or flood your computer with keystrokes – making unusable while the ESP32 is connected.

Also note that the board cannot be flashed while HID is running. It will disappear as a USB device in the Arduino IDE. To bring the board back into flash mode you need to:

1. Press and hold the BOOT (B) button
2. While holding BOOT (B), press and release RESET (R)
3. Release the BOOT (B) button

Since the BOOT (B) and RESET (R) buttons on the ESP32-S3 are tiny, this can be quite tricky.

Wi-Fi

The following example shows you how to connect the XIAO ESP32 to a Wi-Fi network. This will work without the external antenna, if you are close to the Wi-Fi router. But for better range you should install the antenna.

#include <WiFi.h>

const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);

  Serial.print("Connecting");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("\nConnected");
  Serial.println(WiFi.localIP());
}

void loop() {
}

Webserver

You can extend the WiFi example before and easily build a simple Webserver. The following code creates a webserver, prints the IP address the webserver is serving and prints the text “”Hello from XIAO ESP32-S3!” on root page:

#include <WiFi.h>
#include <WebServer.h>

const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";

WebServer server(80);

void handleRoot() {
  server.send(200, "text/plain", "Hello from XIAO ESP32-S3!");
}

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println(WiFi.localIP());

  server.on("/", handleRoot);
  server.begin();
}

void loop() {
  server.handleClient();
}

Download the code to your ESP32-S3, open the Serial Monitor and copy the IP address that is printed there (e.g. “192.168.1.160”) into the address bar of your browsers. You should see the message appear:

Webscanner

If you want to scan your local Wi-Fi network to detect available Wi-Fi networks, here is a code example:

#include "WiFi.h"

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  WiFi.disconnect();
  delay(100);
}

void loop() {
  Serial.println("scan start");
  int n = WiFi.scanNetworks();
  Serial.println("scan done");
  if (n == 0) {
    Serial.println("no networks found");
  } else {
    Serial.print(n);
    Serial.println(" networks found");
    for (int i = 0; i < n; ++i) {
      Serial.print(i + 1);
      Serial.print(": ");
      Serial.print(WiFi.SSID(i));
      Serial.print(" (");
      Serial.print(WiFi.RSSI(i));
      Serial.print(")");
      Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN) ? " " : "*");
    }
    delay(10);
  }
  Serial.println("");
  delay(5000);
}

You can start without the Wi-Fi antenna attached and you will find only the strongest Wi-Fi networks. If you attach the antenna you probably will discover more networks. For instance, without the antenna I get a weak signal (-77 dB) and only one network:

scan start
scan done
1 networks found
1: maetasus (-77)*

As soon as I attach the antenna, more networks are detected and the signal strength of my local network (maetasus) goes up from -77 dB to -35dB:

scan start
scan done
5 networks found
1: maetasus (-35)*
2: FRITZ!Box 5590 DQ (-75)*
3: WLAN-762918 (-81)*
4: portthru (-83) 
5: WLAN-579476 (-91)*

Bluetooth

This example demonstrates how to create a simple Bluetooth Low Energy (BLE) server.

#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>

void setup() {
  Serial.begin(115200);

  BLEDevice::init("XIAO-ESP32-S3");
  BLEServer *pServer = BLEDevice::createServer();
  BLEDevice::getAdvertising()->start();

  Serial.println("BLE server started");
}

void loop() {
}

You can check whether the server is active by using a BLE scanner on your phone. Common options are nRF Connect or LightBlue. If you initiate a scan, you will see “XIAO-ESP32-S3” appearing.

Pressure and Temperature Sensor (BME280) via I2C

This code example show you how to connect a sensor via I2C to the XIAO ESP32-S3. We will use the BME280 in this example. For more information on this sensor see the How To Use BME280 Pressure Sensor With Arduino and the Weather Station on e-Paper Display tutorials.

The I2C interface of the XIAO ESP32-S3 is on pins 5 (SDA) and 6 (SCL). The wiring diagram below shows you how to connect the BME280 to the XIAO ESP32-S3.

The following code shows you how to read pressure, temperature, humidity and altitude data from the BME280 sensor and print the measurements to the Serial Monitor:

#include "Adafruit_BME280.h"

#define SEALEVELPRESSURE_HPA 1013.25
#define BME280_ADDRESS 0x76

Adafruit_BME280 bme;

void setup() {
  Serial.begin(11520);
  while(!Serial);

  if (!bme.begin(BME280_ADDRESS)) {
    Serial.println("Can't find BME280!");
    while(1) delay(10);
  }
}

void loop() {
  Serial.print("Temperature in degC = ");
  Serial.println(bme.readTemperature());

  Serial.print("Pressure in hPa     = ");
  Serial.println(bme.readPressure() / 100.0F);

  Serial.print("Altitude in m       = ");
  Serial.println(bme.readAltitude(SEALEVELPRESSURE_HPA));

  Serial.print("Humidity in %RH     = ");
  Serial.println(bme.readHumidity());

  Serial.println();
  delay(5000);
}

If everything is wired correctly, you should see data similar to the output below:

Temperature in degC = 22.93
Pressure in hPa     = 1000.40
Altitude in m       = 107.53
Humidity in %RH     = 34.61

OLED via I2C

In the code example we again use the I2C interface but connect an OLED display to the XIAO ESP32-S3. As before we are using the pins 5 (SDA) and 6 (SCL) for I2C. The picture below shows the connection you need to make with the OLED:

And here is the code. It simply writes the text “make” on the display. Note that you will need to install the Adafruit_SSD1306 library first.

#include "Adafruit_SSD1306.h"

Adafruit_SSD1306 oled(128, 64, &Wire, -1);

void setup() {
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  oled.setTextSize(4);
  oled.setTextColor(WHITE);
}

void loop() {
  oled.clearDisplay();
  oled.setCursor(20, 16);
  oled.print("make");
  oled.display();
  delay(1000);
}

E-Paper Display on SPI

In this next example, we are going to control a E-Paper Display via the SPI interface of the XIAO ESP32-S3. The hardware SPI pins for the XIAO ESP32-S3 are 8 (MISO), 9 (MOSI), 44 (CS/SS) and 7 (SCK). The other pins are free to choose.

The wiring diagram below shows how to connect a 4.2″ e-Paper Display to the SPI pins:

Below a table with all the connections for convenience. Note that you can power the display with 3.3V or 5V but the SPI data lines must be 3.3V! To be on the safe side, use 3.3V for power supply.

e-Paper display	XIAO ESP32-S3
CS/SS	GPIO44
CLK/SCL/SCK	GPIO7
SDA/DIN/MOSI	GPIO9
BUSY	GPIO1
RES/RST	GPIO2
DC	GPIO3
VCC	3.3V
GND	G

Before you can draw on the e-Paper display you will need to install the GxEPD2 library, which provides the graphics driver software for the E-Paper Display. The code examples below uses the library to print the text “Makerguides” on the display:

#include "GxEPD2_BW.h"

// hardware SPI
// #define MISO 8
// #define MOSI 9
// #define SCK 7

#define CS 44
#define DC 3
#define RST 2
#define BUSY 1
GxEPD2_BW<GxEPD2_420_GDEY042T81, GxEPD2_420_GDEY042T81::HEIGHT>
  epd(GxEPD2_420_GDEY042T81(CS, DC, RST, BUSY));

void setup() {
  epd.init(115200, true, 50, false);
  epd.setRotation(1);
  epd.setTextColor(GxEPD_BLACK);
  epd.setTextSize(2);
  epd.setFullWindow();

  epd.fillScreen(GxEPD_WHITE);
  epd.setCursor(90, 190);
  epd.print("Makerguides");
  epd.display();
  epd.hibernate();
}

void loop() {}

If you want to implement something more interesting have a look at the Monthly Calendar on E-Paper Display or the Analog Clock on e-Paper Display tutorials.

Deep Sleep

The following code demonstrates how to use the deep-sleep mode with the ESP32-S3. Every 10 seconds it puts the ESP32-S3 into deep-sleep for 5 seconds and then wakes it up again:

#define uS_TO_S_FACTOR 1000000ULL
#define TIME_TO_SLEEP 5

void setup() {
  Serial.begin(115200);  
  Serial.println("Awake...");
  delay(10000);
  Serial.println("Going to sleep...");
  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
  esp_deep_sleep_start();
}

void loop() {}

Watch out when you increase the deep-sleep period. During deep-sleep the board disconnects from USB and you cannot flash new software. To bring the board back into flash mode you need to:

1. Press and hold the BOOT (B) button
2. While holding BOOT, press and release RESET (R)
3. Release the BOOT button

OTA (Over The Air) Update

In this final code example, I show you how to perform an Over The Air (OTA) update of the code on the XIAO ESP32-S3. This has the advantage that you don’t need to plug in your ESP32 to flash new code.

#include <WiFi.h>
#include <ArduinoOTA.h>

const char* wifi_ssid = "YOUR_SSID";
const char* wifi_pwd = "YOUR_PASSWORD";

const char* ota_pwd = "1234";
const char* ota_name = "my-xiao-esp32-s3";


void setup() {
  WiFi.begin(wifi_ssid, wifi_pwd);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }

  ArduinoOTA.setHostname(ota_name);
  ArduinoOTA.setPassword(ota_pwd);
  ArduinoOTA.begin();

  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  ArduinoOTA.handle();

  // Main code
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
}

The ESP32 will appear under Tools -> Ports -> Network Ports with the given hostname “my-xiao-esp32-s3”. If you flash to that host, the Arduino IDE will ask for a password (“1234”) and then flashes the new code over Wi-Fi. Obviously, you should pick a better password than “1234” ; )

In the code example the main code is the simple Blink program. Change the delay, flash the new code and see if the blink rate has changed to test the OTA update.

Conclusions

This post showed you how to get started with the Seeed Studio XIAO ESP32-S3. Seeed Studio provides additional information in its Wiki.

Note that there is a XIAO ESP32-S3-Plus version that has more Flash (16MB) and GPIO pins. And there is also the XIAO-ESP32-S3-Sense, which comes with a camera and microphone. If want to record audio or stream video pick the XIAO-ESP32-S3-Sense. Should you need more memory or IO, go with the XIAO ESP32-S3-Plus.

If you have any questions feel free to leave them in the comment section.

Happy Tinkering 😉