Arduino vs ESP32: Key Differences and Which One to Choose

Arduino or ESP32? Here's the short answer: if your project needs Wi-Fi, Bluetooth, the internet or serious processing power, choose the ESP32; if you're learning the basics of electronics, want to use 5 V sensors and modules without hassle and follow every tutorial exactly, choose the Arduino Uno. Both boards are programmed in the Arduino IDE with the same digitalWrite, analogRead and Serial commands. The real difference is the hardware: speed, memory, operating voltage, pins and wireless connectivity.

In this guide we compare the Arduino Uno R3 with the most common ESP32 board, the ESP32 DevKit (with the ESP-WROOM-32 module), using real numbers: what do the CPU and memory differences mean in practice, which modules are affected by 5 V versus 3.3 V, how do analog input and PWM change, and how many hours does each one last on a battery? Then we'll run the same sketch on both boards, take a quick look at the Raspberry Pi Pico and sum up in a table which board to choose for each type of project.

Short answer: which one, and when?

What are the Arduino Uno and the ESP32?

The Arduino Uno R3 is the best-known board of the Arduino platform, which was developed in Italy. At its heart is the 8-bit ATmega328P microcontroller running at 16 MHz. The board runs on 5 V and its pin layout hasn't changed for years, so hundreds of shields (expansion boards that plug on top), books and courses are compatible with it. Its simple design lets you see exactly what's happening: when you write HIGH to a pin, there really are 5 V on it. The newer Uno R4 comes with a 48 MHz 32-bit Arm processor and 32 KB of RAM, and the R4 WiFi version adds an ESP32-S3 to the board for wireless connectivity; in this article, "Uno" means the R3, which is still the most common. To get to know the platform better, read What Is Arduino?.

The ESP32, on the other hand, is a 32-bit system-on-chip (SoC) released by Espressif in 2016 with Wi-Fi and Bluetooth on the same chip. The board you hold is a development board that carries this chip: it has a USB-to-serial converter, a 3.3 V regulator and EN and BOOT buttons. One important detail: the ESP32 isn't an Arduino, but thanks to the Arduino core made by Espressif it's programmed in the Arduino IDE just like one. For setup and first projects, What Is the ESP32? is a good place to start.

The big comparison table: Arduino Uno, ESP32 and Raspberry Pi Pico

CPU and memory: what do the numbers mean in practice?

The Uno's processor executes about 16 million instructions per second and works on 8-bit numbers at a time; a 32-bit long or float operation takes dozens of instructions, and there's no hardware floating-point unit (FPU). The ESP32 runs at 240 MHz on 32-bit numbers and has a single-precision FPU. That's why, in a float-heavy calculation, the ESP32 can be tens or even hundreds of times faster than the Uno. You won't notice the difference when blinking an LED or reading a sensor a few times per second, but it becomes decisive for filtering, audio processing, encryption or computing animations for hundreds of LEDs. A small tip: the ESP32's FPU only handles float; double operations run in software and are noticeably slower.

You'll run into the memory difference far more often. The Uno's 2 KB of RAM is shared between your variables, the Serial buffers and the space that libraries reserve. When RAM runs out, the compiler usually doesn't warn you; the program freezes at random or behaves strangely. Typical situations where the Uno quickly runs out of RAM:

• OLED display: the frame buffer of a 128×64 SSD1306 display alone takes 1 KB, half of the RAM (see Using an OLED Display).
• Addressable LEDs: every WS2812B LED takes 3 bytes, so a 300-LED strip needs 900 bytes (see WS2812B NeoPixel).
• Data from the internet: the JSON returned by a weather service can be several KB; it doesn't fit on the Uno but is easy to handle on the ESP32.
• String concatenation: String objects that keep growing inside a loop fragment the small RAM and can cause a crash hours later.
• SD card: the SD library reserves a 512-byte sector buffer; together with display and sensor libraries you hit the limit quickly.

The voltage difference: 5 V vs 3.3 V

This is the most overlooked difference. The Uno's pins use 5 V logic: a HIGH output is 5 V, and inputs above 3 V count as HIGH. The ESP32's pins use 3.3 V logic and aren't 5 V tolerant. Applying 5 V to a pin may not kill the ESP32 immediately, but it stresses the internal protection diodes and can destroy the chip over time or all at once. The other direction is less of a problem: the ESP32's 3.3 V HIGH signal only just clears the Uno's 3 V threshold, so it's usually read as HIGH, but that doesn't count as a safe design either. Here's how common modules behave with each board:

Pins, analog input and PWM

On the Uno, all 20 pins behave more or less the same: each one can be an input or an output, comfortably supplies up to 20 mA and doesn't affect booting. The ESP32 DevKit has more pins on paper, but they aren't all equal: GPIO 6–11 are wired to the internal flash and can't be used, GPIO 34–39 are input-only, and GPIO 0, 2, 5, 12 and 15 must be at certain levels during boot. In practice you can comfortably use around 20–25 pins. You can see your board's pin map in the Pinout tool.

For analog input, the Uno's 10-bit ADC splits the 0–5 V range into 1024 steps; each step is about 4.9 mV and readings are fairly linear. The ESP32's 12-bit ADC gives 4096 steps, but with the default setting it can't distinguish values below about 0.15 V or above 3.1 V, it's noisy, and the ADC2 pins don't work at all while Wi-Fi is on. If you need an accurate voltage on the ESP32, use analogReadMilliVolts() and connect the sensor to the ADC1 pins (GPIO 32–39). The ESP32 is ahead on PWM: while the Uno offers 8-bit PWM on only 6 pins at 490 or 980 Hz, the ESP32 can route 16 channels with adjustable frequency and resolution to almost any output pin. It also has 2 DACs (GPIO 25 and 26) that produce a true analog voltage. For the basics of PWM, see What Is PWM?.

The same sketch on both boards: what changes?

Here's the good news: everything you've learned on Arduino also applies to the ESP32. The sketch below reads a potentiometer, prints the voltage to the Serial Monitor and turns on the onboard LED when the value passes the halfway point. The #if defined(ESP32) line detects which board the code is being compiled for and changes only the pin number, the reference voltage and the ADC resolution. Connect the potentiometer's outer legs to 5V and GND on the Uno, or to 3V3 and GND on the ESP32; connect the middle leg to A0 on the Uno or to GPIO 34 on the ESP32, then open the Serial Monitor at 115200 baud. The main differences outside the code are in the table.

1// Aynı kod Uno ve ESP32'de çalışır / The same sketch runs on Uno and ESP32
2#if defined(ESP32)
3const int LED_PIN = 2;        // DevKit dahili LED / DevKit onboard LED
4const int POT_PIN = 34;       // ADC1 pini, Wi-Fi ile de çalışır / ADC1 pin, works with Wi-Fi too
5const float VREF = 3.3;       // ESP32 pinleri 3,3 V / ESP32 pins are 3.3 V
6const int ADC_MAX = 4095;     // 12 bit
7#else
8const int LED_PIN = 13;       // Uno dahili LED / Uno onboard LED
9const int POT_PIN = A0;
10const float VREF = 5.0;       // Uno referansı 5 V / Uno reference is 5 V
11const int ADC_MAX = 1023;     // 10 bit
12#endif
13
14void setup() {
15  Serial.begin(115200);
16  pinMode(LED_PIN, OUTPUT);
17}
18
19void loop() {
20  int raw = analogRead(POT_PIN);
21  float volts = raw * VREF / ADC_MAX;
22  Serial.print("Ham / raw: ");
23  Serial.print(raw);
24  Serial.print("  Gerilim / voltage: ");
25  Serial.println(volts, 2);
26  digitalWrite(LED_PIN, raw > ADC_MAX / 2 ? HIGH : LOW);   // yarıdan fazlaysa LED yanar / LED on above half
27  delay(250);
28}

Wi-Fi, Bluetooth and the internet

What really sets the ESP32 apart is wireless connectivity. The board joins 2.4 GHz Wi-Fi networks, can create its own access point, runs a web server, sends data to a smart home system over MQTT, gets the time from the internet via NTP and can update its firmware wirelessly (OTA). On the Bluetooth side, both Classic Bluetooth (Serial Port Profile) and low-energy BLE are supported, and with ESP-NOW several ESP32s can talk to each other without a router. None of this is built into the Uno: for Bluetooth you need a module such as the HC-05, and for Wi-Fi a separate chip such as the ESP-01 plus AT commands. The sketch below reads the same potentiometer, this time over Wi-Fi: open the address shown in the Serial Monitor in the browser of a phone on the same network and you'll see the voltage in millivolts, with the page refreshing itself every two seconds.

1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* ssid = "AgAdi";          // Wi-Fi adın / your Wi-Fi name
5const char* password = "Sifre123";   // Wi-Fi şifren / your Wi-Fi password
6const int POT_PIN = 34;              // ADC1 pini / ADC1 pin
7
8WebServer server(80);
9
10void handleRoot() {
11  uint32_t mv = analogReadMilliVolts(POT_PIN);   // kalibre edilmiş mV / calibrated mV
12  String html = "<meta name='viewport' content='width=device-width'>"
13                "<meta http-equiv='refresh' content='2'>"
14                "<h1>ESP32</h1><p>Pot: ";
15  html += mv;
16  html += " mV</p>";
17  server.send(200, "text/html", html);
18}
19
20void setup() {
21  Serial.begin(115200);
22  WiFi.begin(ssid, password);
23  while (WiFi.status() != WL_CONNECTED) delay(500);
24  Serial.print("Telefonda aç / open on your phone: http://");
25  Serial.println(WiFi.localIP());
26  server.on("/", handleRoot);
27  server.begin();
28}
29
30void loop() {
31  server.handleClient();
32}

Power consumption and running on batteries

On paper, the ESP32 is both the hungriest and the most frugal board. While sending data over Wi-Fi it draws peaks of up to 240 mA, which is why it reboots with the "Brownout detector was triggered" error on a weak USB port. In deep sleep, on the other hand, the chip uses only about 10 µA. The Uno board draws about 45 mA while doing nothing; even with the ATmega328P asleep, the USB-to-serial chip, the regulator and the power LED keep using around 30 mA. Let's work through an example: a 2000 mAh battery powers an Uno running continuously for about 2000 / 45 ≈ 44 hours. An ESP32 with Wi-Fi always on (100 mA on average) lasts about 20 hours. But if the ESP32 wakes up every 10 minutes for 3 seconds, sends a reading at 120 mA and sleeps at 10 µA for the remaining 597 seconds, the average current is (3 × 120 + 597 × 0.01) / 600 ≈ 0.61 mA, and the same battery theoretically lasts more than 3000 hours, or over four months. That result needs a low-power board or a bare module; the regulator and USB chip on standard DevKits draw a few mA even in sleep. You can calculate your own scenario with the battery life tool.

Where does the Raspberry Pi Pico fit in?

The third strong option is the Raspberry Pi Pico. Its RP2040 chip has two 133 MHz Cortex-M0+ cores, 264 KB of RAM and 2 MB of flash, and it costs about $4. Like the ESP32, it runs on 3.3 V and offers 26 GPIOs, but it has only 3 analog inputs. Its biggest strengths are very mature MicroPython support, easy firmware loading by showing up on your computer like a USB drive, and units called PIO that generate precisely timed protocols without loading the processor. If you want wireless, choose the Pico W (Wi-Fi and Bluetooth); for more power, the Pico 2 with the RP2350 chip. More details in What Is the Raspberry Pi Pico?. The same potentiometer reading looks like this on the Pico in MicroPython (middle leg to GP26, outer legs to 3V3 and GND):

1from machine import ADC, Pin
2import time
3
4pot = ADC(26)                  # GP26 = ADC0, potansiyometre orta ucu / pot wiper
5led = Pin("LED", Pin.OUT)      # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
6
7while True:
8    raw = pot.read_u16()                   # 0–65535 (12 bit ölçüm ölçeklenir / 12-bit reading, scaled)
9    volts = raw * 3.3 / 65535
10    print("Ham / raw:", raw, " Gerilim / voltage: {:.2f}".format(volts))
11    led.value(raw > 32767)                 # yarıdan fazlaysa yanar / on above half
12    time.sleep(0.25)

Price and ease of learning

Price alone rarely decides it. An original Uno R3 costs around $25–30, while clones with the CH340 USB chip sell for $5–10; clone ESP32 DevKits cost $4–8 and the Pico $4. So there's almost no price gap between an ESP32 and an Uno clone; the real cost shows up in the extras: using 5 V modules with the ESP32 takes a few resistors or a $1–2 level shifter, and adding Wi-Fi to the Uno takes a separate module. On the learning side, the Uno is ahead: you pick the board and click Upload, the error messages and examples have stayed the same for years, and there are no voltage mismatches with 5 V modules. On the ESP32 you first install the Espressif board package and, if needed, the driver for the USB chip (CP2102 or CH340), pick the right board model, and on some boards hold the BOOT button while uploading; also, some examples online were written for older core versions and may not compile (in core 3.x, for example, ledcAttach replaces ledcSetup). These hurdles take a few hours to clear, but if you're building circuits for the first time, it's easier on the Uno to tell whether a problem comes from the code or the wiring.

Which board for which project?

Common mistakes and misconceptions

• "The ESP32 is always better": it's more powerful, but its 3.3 V pins, boot-sensitive pins, BOOT button and power dips can wear a beginner out. For learning the basics, the Uno has fewer surprises.
• Connecting a 5 V sensor directly to the ESP32: connecting 5 V signals such as the HC-SR04's ECHO output without a divider can damage the pin.
• Reading an ADC2 pin with Wi-Fi on: GPIO 0, 2, 4, 12–15 and 25–27 don't read analog values while Wi-Fi is running; move the sensor to GPIO 32–39.
• Forgetting the Uno's RAM: if the code compiles but the board freezes at random, RAM may have run out; put fixed text inside F("...") and avoid concatenating Strings in a loop.
• Powering the ESP32 from weak USB: if the board reboots when Wi-Fi starts, use a good data cable and an adapter that supplies at least 1 A.
• Mixing up the Pico and the Pico W: the plain Pico has no Wi-Fi; for a wireless project, buy the model with a W in its name.

In short, the Arduino Uno is the board for learning, the ESP32 the board for connecting, and the Raspberry Pi Pico the board for experimenting with Python. If you're wondering which model in the Arduino family suits you, take a look at Which Arduino Should I Buy?. In the BlueGrays app you'll find dozens of projects for Arduino, ESP32 and Pico, from blinking an LED to a Wi-Fi web server and from an NTP clock to a weather display, each with a step-by-step circuit diagram and code.