I went looking for the best Arduino starter kit for Linux users, and the kit turned out to matter less than its USB chip. Which chip is it? Nobody selling the cheap kits will say, and that little part decides whether your board shows up as /dev/ttyACM0 or /dev/ttyUSB0, which kernel driver claims it, and which of the usual Linux upload errors you’ll hit on day one. Generic kit reviews count resistors. They do not tell you that.
So this guide does both. It compares the official Arduino kits (Uno R3 and the newer Uno R4), Elegoo’s best seller and a Freenove clone kit on parts, tutorials and price. Then it walks through the Linux setup they all share: the dialout group, udev rules, the CH340 driver, Arduino IDE 2, arduino-cli and PlatformIO. I ran the Linux steps that don’t need a board plugged in during October 2026 on an Ubuntu 26.04.1 LTS VM in my lab with all three toolchains installed, and every error message below comes from that box.
Picking a kit in thirty seconds
If you only read one section, read this one. Each pick links to its live Amazon listing, and prices are bands from October 2026, so check the listing before you buy.
- Best overall: Arduino Starter Kit R4, a genuine UNO R4 WiFi with native USB-C and a printed project book, about $90 to $100
- Best value: ELEGOO UNO R3 Super Starter Kit, the most reviewed kit on Amazon, about $40 to $50
- Most projects per dollar: Freenove Ultimate Starter Kit V5 WiFi, 220 items and 78 projects on an R4-style board, about $45 to $55
- Classic Uno R3 kit: Arduino Starter Kit K000007, the original kit and book, about $100 to $110
- No breadboard: Arduino Plug and Make Kit, snap-together Modulino nodes, about $80 to $90
- Board only: Arduino UNO R4 Minima, for people who already own a parts bin, about $15 to $25
My own pick for a Linux user starting from zero is the Starter Kit R4. The board talks USB natively, so there’s no third-party serial chip to identify, and Arduino’s own core ships the udev rule it needs. The Elegoo kit is the better buy if the budget is tight and you don’t mind running lsusb once to find out what you got.
Testing the Linux side on Ubuntu 26.04
I want to be upfront about what I tested, because buyer guides rarely are. I did not have six kits on my bench. What I did was build the Linux half of the story for real on a fresh Ubuntu 26.04.1 LTS VM. I installed arduino-cli, the AVR core for Uno R3 boards and the Renesas core for Uno R4 boards, PlatformIO Core and the Arduino IDE 2 AppImage, then compiled the same Blink sketch with each of them. Every error and every output block in this article is a capture from that VM.
So how do you test upload permissions with no Arduino plugged in? I used the VM’s built-in serial port, /dev/ttyS0, which belongs to the same dialout group as a USB Arduino. The “Permission denied” failure and the fix behave exactly as they would with a board attached. The kit specs (board, microcontroller, USB interface, parts and tutorials) come from Arduino, Elegoo and Freenove’s own product pages and from Arduino’s official board definitions, and prices and stock come from the live Amazon listings on the day I wrote this.
A few numbers from that VM are worth keeping in mind before you choose between an R3 and an R4 board.
- Installing the AVR core (Uno R3): 24.7 seconds
- Installing the Renesas core (Uno R4): 43.9 seconds
- Blink for the Uno R3: 1.4 seconds to compile, 924 bytes of flash
- Blink for the Uno R4 WiFi: 14.5 seconds to compile, 51,864 bytes of flash
None of that makes the R4 a bad board. It has 256 kB of flash instead of 32 kB, so a 19% Blink still leaves plenty of room. It does mean the R4’s first compile feels slow on an old laptop, and that the tiny-sketch habits people learned on the R3 don’t carry over byte for byte.
Comparing the six picks side by side
The column that matters most on Linux is the USB interface, because it decides the device name and the driver. “Undocumented” means the seller doesn’t say, and you’ll find out with lsusb when the box arrives.
| Kit | Board | USB interface on Linux | Projects and tutorial | Price band |
|---|---|---|---|---|
| Arduino Starter Kit R4 | UNO R4 WiFi (RA4M1 + ESP32-S3) | Native USB-C, cdc_acm, /dev/ttyACM0 | 13 projects (Arduino store page), printed book plus online course | $90-100 |
| ELEGOO UNO R3 Super Starter Kit | Elegoo UNO R3 (ATmega328P) | Undocumented: ATmega16U2 or CH340 | 22+ lessons, PDF download | $40-50 |
| Freenove Ultimate Starter Kit V5 WiFi | Freenove R4-compatible (Cortex-M4 + ESP32-S3) | Undocumented | 78 projects, 399-page PDF | $45-55 |
| Arduino Starter Kit K000007 | Uno Rev3 (ATmega328P) | ATmega16U2, cdc_acm, /dev/ttyACM0 | 15 projects, 170-page printed book | $100-110 |
| Arduino Plug and Make Kit | UNO R4 WiFi | Native USB-C, cdc_acm, /dev/ttyACM0 | 7 projects, online guide | $80-90 |
| Arduino UNO R4 Minima | RA4M1, 48 MHz | Native USB-C, cdc_acm, /dev/ttyACM0 | None, board only | $15-25 |
Notice the split. Every official board uses either the ATmega16U2 or native USB, and both register as a standard ACM device that the in-kernel cdc_acm driver handles. The cheaper boards are where CH340 chips turn up, and they appear as /dev/ttyUSB0 under the ch341 driver instead. Both work on a current kernel, so this is about knowing what to look for, not about avoiding clones.
1. Arduino Starter Kit R4: best overall for Linux
I would hand this kit to a Linux user who has never touched a microcontroller, and the reason is mostly the board. It’s the revised version of the classic starter kit, built around a genuine UNO R4 WiFi:
The UNO R4 WiFi pairs a Renesas RA4M1 (Arm Cortex-M4 at 48 MHz) with an ESP32-S3 for Wi-Fi and Bluetooth, and it plugs in over USB-C. There’s no separate USB-to-serial chip at all: the board enumerates with Arduino’s own vendor ID (2341:1002 in Arduino’s board definitions), Linux binds cdc_acm, and you get /dev/ttyACM0. The box has the printed book with 13 guided projects according to Arduino’s store page, an online course, a USB-C cable and the familiar parts: breadboard, 16×2 LCD, servo, DC motor with H-bridge, phototransistors, potentiometers and pushbuttons.
The Linux catch is small and it’s documented in the core itself. When I installed the Renesas core with arduino-cli, it dropped a post_install.sh that writes a udev rule for the board’s bootloader mode. Run it once with sudo and you’re done (the exact command is in the arduino-cli section further down). Skip it and normal uploads still go through the dialout group, but the board can drop out of reach when it’s in bootloader mode.
- For beginners who want the official book, a modern board and the fewest Linux surprises
- Skip it if you want to follow the thousands of older Uno R3 tutorials byte for byte, or you’re on a tight budget
- About $90 to $100, check the live price on Amazon
Should a 97-rating listing worry you? It is new, so you’re trusting Arduino’s name more than a long review history. I’m comfortable with that for an official kit, but it’s worth knowing.
2. ELEGOO UNO R3 Super Starter Kit: best value
Elegoo’s Super Starter Kit is the one most people end up with, and on value it’s hard to argue with. The listing carried 16,626 ratings at 4.7 stars when I checked it:
For roughly half the price of the official kit, you get an Elegoo UNO R3 (ATmega328P at 16 MHz) and a much bigger parts list. It includes an LCD1602, a breadboard power module, joystick, IR receiver and remote, SG90 servo, a stepper with its ULN2003 driver, an ultrasonic sensor, DHT11, a relay, 74HC595 shift registers, 120 resistors and a 9 V battery with a DC plug. The tutorial is a PDF you download from Elegoo now, not the CD older photos show.
Elegoo’s kit page leaves out one thing a Linux user needs, which is the USB chip on the board. Elegoo sells two standalone UNO boards, one listed as “ATmega328P+ATmega16U2” and one with a CH340C, and the kit listing names neither. Both work on Linux, but they show up differently, so the first thing to do when the box arrives is the lsusb check further down. Elegoo’s own wiki has a CH340 driver page, and it says what my VM’s kernel confirmed: modern Linux already has the driver.
- For beginners and classrooms who want the most parts per dollar on the classic R3 platform
- Skip it if you want a printed book, or you’d rather not guess which USB chip arrives in the box
- About $40 to $50, check the live price on Amazon
One more oddity: Elegoo’s own US store showed this kit as sold out on the day Amazon had it in stock. If you’re buying close to a holiday, Amazon was the more reliable source when I looked.
3. Freenove Ultimate Starter Kit V5 WiFi: most projects per dollar
Freenove packs 220 items and 78 projects into a kit that costs about the same as Elegoo’s, and it does it on an R4-class board rather than an R3 clone:
Freenove designed its control board V5 WiFi to be compatible with the UNO R4 WiFi. It runs an Arm Cortex-M4 at 48 MHz with 256 kB of flash and 32 kB of RAM, and adds an onboard ESP32-S3 and a 12×8 LED matrix. Freenove’s product photo shows a USB-C cable, but its spec list doesn’t name the connector or the USB interface. The kit adds an RFID reader, a keypad, an LCD, a stepper and servo, and a lot more than the Elegoo box. The 399-page tutorial is a download only, which suits me fine because I’d rather search a PDF than flip through a book.
The trade-off is documentation of the Linux kind. Freenove doesn’t state which USB interface the V5 board uses, and the listing is new, with 36 ratings when I checked. Because the board copies the R4 WiFi design, I’d expect it to behave like one, but I haven’t had one on a Linux machine, so treat that as my guess and run lsusb when it arrives. If it reports a vendor ID that isn’t Arduino’s 2341, the Renesas core’s udev rule won’t match it, and you’ll want a rule of your own or PlatformIO’s rules file.
- For self-learners who want the most projects and a Wi-Fi capable board for the money
- Skip it if you need a long review history or a board whose USB IDs are documented before you buy
- About $45 to $55, check the live price on Amazon
Freenove also sells an older V4 kit on an R3-style board for a little less. I’d skip it: its board’s USB chip is undocumented too, and you give up the R4-class board for very little saving.
4. Arduino Starter Kit K000007: the classic Uno R3 kit
The original Arduino Starter Kit is still on sale, and it’s still the kit most of the internet’s beginner tutorials were written against:
Inside is a genuine Uno Rev3 (ATmega328P) whose USB side is an ATmega16U2. On Linux that’s the easy case: it enumerates as 2341:0043 or 2341:0001 per Arduino’s AVR board definitions, cdc_acm binds it, and it appears as /dev/ttyACM0 with nothing to install. You get the 170-page printed Projects Book (Arduino’s store lists 15 projects; the Amazon title says 12), a 400-point breadboard, 70 jumpers, a 16×2 LCD, a servo, a DC motor, a TMP36 temperature sensor and a tilt sensor. The example code is already in the IDE under File, Examples, 10.StarterKit.
So why is it not my top pick? It costs more than the R4 kit and gives you an older board. The R3 is a fine way to learn, and it has the biggest pile of tutorials, but at this price I would rather have the R4’s flash, Wi-Fi and USB-C. Buy it if you’re following a course or a book that names the R3 specifically.
- For anyone following Uno R3 course material, and teachers who want every student on the same proven board
- Skip it if you have no R3-specific reason, because the R4 kit costs less
- About $100 to $110, check the live price on Amazon
With 3,708 ratings, it also has the longest track record of any official kit here, which counts for something when it’s a gift.
5. Arduino Plug and Make Kit: no breadboard, no soldering
The Plug and Make Kit takes a different route: no breadboard, no jumper wires, just small modules that snap together with Qwiic cables:
It ships the same UNO R4 WiFi as the Starter Kit R4, so the Linux side is identical: native USB-C, /dev/ttyACM0, and the Renesas udev rule. The difference is the seven Modulino nodes (Knob, Pixels, Distance, Movement, Buzzer, Thermo and Buttons), which talk I2C over Qwiic cables, plus a Modulino base to mount them on. There are seven documented projects in an online guide, and no printed book or PDF.
I like it for one specific person: the one who wants to build something that works this weekend and doesn’t care about learning Ohm’s law first. It’s a poor fit if the goal is electronics itself, because you never place a resistor. A kid who’ll later want a breadboard kit anyway is better served by the Starter Kit R4 now.
- For programmers who want sensors working fast, and makers with shaky hands
- Skip it if you want to learn circuits, or you want an offline tutorial
- About $80 to $90, check the live price on Amazon
It had 144 ratings when I checked, which is a smaller history than the K000007 has, but plenty for an official Arduino product that only shares its board with the R4 kit.
6. Arduino UNO R4 Minima: board only
If you already own a breadboard and a drawer of LEDs, a kit is mostly paying for parts you have. The UNO R4 Minima is the cheapest genuine Arduino on this list:
Under the USB-C port sits the same Renesas RA4M1 as the R4 WiFi (48 MHz, 256 kB flash, 32 kB SRAM, 8 kB EEPROM) without the ESP32-S3 and LED matrix, and it was the first Uno with USB-C. Arduino’s board definitions list it as 2341:0069, so it lands on /dev/ttyACM0 like the other R4 boards and uses the same core and udev rule. If you want Wi-Fi, the UNO R4 WiFi board on its own runs about $25 to $30.
- For people with parts already, and anyone replacing a fried clone with a genuine board
- Skip it if this is your first Arduino, because a bare board with nothing to wire up teaches very little
- About $15 to $25, check the live price on Amazon
No USB cable is listed on the board’s product page, so plan on a USB-C cable of your own.
Finding out which USB chip your board has
Before installing anything, plug the board in and ask the kernel what it found. This takes ten seconds and answers the question that the Elegoo and Freenove listings leave open:
lsusb
sudo dmesg | tail -n 20Match the vendor and product ID in the lsusb line against this table. The Arduino IDs come from Arduino’s own board definition files, and the CH340 driver aliases come from modinfo ch341 on my Ubuntu 26.04 VM:
| lsusb ID | What it is | Kernel driver | Device |
|---|---|---|---|
| 2341:0043 or 2341:0001 | Genuine Uno R3 (ATmega16U2) | cdc_acm | /dev/ttyACM0 |
| 2341:0069 | UNO R4 Minima | cdc_acm | /dev/ttyACM0 |
| 2341:1002 | UNO R4 WiFi | cdc_acm | /dev/ttyACM0 |
| 1a86:7523 | WCH CH340 USB-serial (common on clones) | ch341 | /dev/ttyUSB0 |
The CH340 needs no driver download on a current distro. On my VM the in-kernel module already claims it:
modinfo ch341 | grep -E "^(filename|alias|description)"The v1A86p7523 alias is the CH340’s USB ID, which is why Linux binds the right driver the moment the board is plugged in:
filename: /lib/modules/7.0.0-15-generic/kernel/drivers/usb/serial/ch341.ko.zst
description: Winchiphead CH341 USB Serial driver
alias: usb:v9986p7523d*dc*dsc*dp*ic*isc*ip*in*
alias: usb:v4348p5523d*dc*dsc*dp*ic*isc*ip*in*
alias: usb:v2184p0057d*dc*dsc*dp*ic*isc*ip*in*
alias: usb:v1A86p7523d*dc*dsc*dp*ic*isc*ip*in*
alias: usb:v1A86p7522d*dc*dsc*dp*ic*isc*ip*in*
alias: usb:v1A86p5523d*dc*dsc*dp*ic*isc*ip*in*So when a forum post tells you to download a CH340 driver from the chip maker for Linux, ignore it. The driver has been in mainline for years. The real CH340 problem on Ubuntu was something else entirely, and it’s covered next.
CH340 shows in lsusb but /dev/ttyUSB0 never appears
On Ubuntu 22.04 this was a common trap: the braille display daemon brltty shipped a udev rule that claimed 1a86:7523, because a braille display happens to use the same chip, so it grabbed the port before you could. It’s tracked as Launchpad bug 1990357, which was still marked Confirmed when I checked. I wanted to know whether that’s still a risk, so I pulled the brltty package from the Ubuntu 26.04 archive and read its rules file:
cd /tmp && apt-get download brltty
mkdir -p /tmp/b && dpkg-deb -x brltty*.deb /tmp/b
grep -n -i -B2 -A2 "1a86" /tmp/b/usr/lib/udev/rules.d/85-brltty.rulesOn 26.04 both QinHeng entries are commented out, and the 55D3 one carries Ubuntu’s note pointing at an earlier bug, so brltty no longer takes a CH340’s port:
81-#ENV{PRODUCT}=="10c4/ea80/*", ATTR{manufacturer}=="Silicon Laboratories", ENV{BRLTTY_BRAILLE_DRIVER}="sk", GOTO="brltty_usb_run"
82-
83:# Device: 1A86:55D3
84-# Generic Identifier
85-# Vendor: QinHeng Electronics
--
87-# HIMS [eMotion (legacy)]
88-# Ubuntu disable those to avoid conflicts, https://launchpad.net/bugs/1958224
89:#ENV{PRODUCT}=="1a86/55d3/*", ENV{BRLTTY_BRAILLE_DRIVER}="hm", GOTO="brltty_usb_run"
90-
91:# Device: 1A86:7523
92-# Generic Identifier
93-# Vendor: Jiangsu QinHeng, Ltd.
94-# Product: CH341 USB Bridge Controller
95-# Baum [NLS eReader Zoomax (20 cells)]
96:#ENV{PRODUCT}=="1a86/7523/*", ATTRS{idVendor}=="1a40", ATTRS{idProduct}=="0101", ENV{BRLTTY_BRAILLE_DRIVER}="bm", GOTO="brltty_usb_run"If you’re on an older release and sudo dmesg shows the ttyUSB0 device being disconnected right after it attaches, brltty is the first suspect. Remove it with sudo apt remove brltty if you don’t use a braille display, then replug the board.
Fixing “Permission denied” on the serial port
Every new Linux Arduino user hits this error, whatever kit they bought. Serial devices on Ubuntu belong to root and the dialout group with mode 660, and a fresh user isn’t in that group. My VM’s port shows the same ownership a USB Arduino gets:
ls -l /dev/ttyS0The dialout group in the listing is the one your user needs:
crw-rw---- 1 root dialout 4, 64 Oct 29 07:54 /dev/ttyS0A USB board gets the same treatment from udev when it appears as /dev/ttyACM0 or /dev/ttyUSB0, so anything that can’t open ttyS0 here can’t open your Arduino either.
Error: “cannot open port /dev/ttyS0: Permission denied”
My VM shows the upload failing, then working. The fix is one usermod, but watch what happened when I checked my groups straight after running it:
The first id -nG after usermod still showed no dialout. Group membership is read at login, so the same shell keeps the old list. Only after I logged out and back in did dialout appear, and the upload got past the port. The “not in sync” lines that follow are avrdude talking to a plain serial port with no Arduino on the other end, which is the expected failure on a VM and proof the permission problem is gone. After ten attempts arduino-cli still ends with its generic “unable to open port” wrapper message, so read the avrdude lines above it, not the last line. With a real board attached, that’s where the upload completes.
Run the fix yourself, then log out of your desktop session completely (or reboot, which is what Arduino’s own port-access article suggests):
sudo usermod -aG dialout $USERArch handles this differently: the Arch Wiki’s Arduino page now recommends a udev rule that tags serial devices with uaccess, which grants access to whoever is logged in at the seat. I only tested the Ubuntu path, so on Arch follow the wiki rather than me.
Getting Arduino IDE 2 to start on Ubuntu 26.04
Arduino ships IDE 2 for Linux as an AppImage and a zip. I expected the AppImage to be the boring part of this test, and it was the part that broke twice. Download it and make it executable (the version in the file name is the one current when I tested):
# https://github.com/arduino/arduino-ide/releases
curl -fsSL -o arduino-ide.AppImage https://downloads.arduino.cc/arduino-ide/arduino-ide_2.3.10_Linux_64bit.AppImage
chmod +x arduino-ide.AppImageRunning it on a stock Ubuntu 26.04 install failed first on FUSE and then, after I installed libfuse2t64, on Electron’s sandbox:
Two different failures, two different fixes, and neither has anything to do with the board you bought.
Error: “dlopen(): error loading libfuse.so.2”
A stock Ubuntu 26.04 install has only FUSE 3 (fuse3 and libfuse3-4 on my VM), and AppImages built the classic way still need the FUSE 2 library. Arduino’s install docs say libfuse2, but on 26.04 the package that actually provides it is libfuse2t64:
sudo apt install libfuse2t64That gets the AppImage mounted, and straight into the next error.
Error: “The SUID sandbox helper binary was found, but is not configured correctly”
Arduino is not to blame for this one. Ubuntu restricts unprivileged user namespaces through AppArmor (kernel.apparmor_restrict_unprivileged_userns = 1 on my VM), and Electron apps use them for their sandbox. Packaged apps get an AppArmor profile that allows it; an AppImage you downloaded doesn’t. The common advice is --no-sandbox, which works by switching the browser sandbox off for an app that loads web content. I’d rather give the IDE its own profile, which is the same approach Ubuntu takes for Chrome and VS Code:
printf '%s\n' 'abi <abi/4.0>,' 'include <tunables/global>' '' 'profile arduino-ide /tmp/.mount_arduin*/arduino-ide flags=(unconfined) {' ' userns,' '' ' include if exists <local/arduino-ide>' '}' | sudo tee /etc/apparmor.d/arduino-ide
sudo apparmor_parser -r /etc/apparmor.d/arduino-ideThe profile matches the path the AppImage mounts itself under, so it keeps working wherever you store the file. After loading it, the same AppImage started and its log showed it discovering /dev/ttyS0. My VM has no desktop, so I ran the IDE on a virtual X display (Xvfb) with the Blink sketch as its argument and captured the screen:
The Output pane shows “Already installed” for the built-in libraries because the IDE shares ~/.arduino15 with arduino-cli, so cores I’d installed from the terminal were already there. If you’d rather not deal with AppImages at all, our older guide on installing the Arduino IDE on Linux covers other routes, and the next section skips the GUI entirely.
Using arduino-cli and PlatformIO instead
Every kit in this guide works without the IDE. If you live in a terminal and an editor, arduino-cli is Arduino’s own build and upload tool, and PlatformIO is the alternative many people already use for ESP32 work. I’d start with arduino-cli because it uses exactly the same cores and board names as the IDE and the kit tutorials.
Installing arduino-cli
My first attempt failed with “folder not found” because the official install script won’t create its target directory. Create it first, then run the script:
mkdir -p ~/.local/bin
curl -fsSL https://raw.githubusercontent.com/arduino/arduino-cli/master/install.sh | BINDIR=$HOME/.local/bin shThe script prints the installed version, and warns if ~/.local/bin isn’t on your PATH yet (Ubuntu adds it at your next login once the folder exists):
arduino-cli Version: 1.5.1 Commit: 01f3d4f2b Date: 2026-06-05T10:22:17Z installed successfully in /home/philip/.local/binInstall the core for your board. Uno R3 boards, the Elegoo kit included, use arduino:avr, and all the R4 boards use arduino:renesas_uno:
arduino-cli config init
arduino-cli core update-index
arduino-cli core install arduino:avr
arduino-cli core install arduino:renesas_unoCreate a sketch, then open its .ino file:
arduino-cli sketch new ~/Arduino/blink
vim ~/Arduino/blink/blink.inoReplace the empty template with Blink, which toggles the built-in LED every half second:
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
digitalWrite(LED_BUILTIN, HIGH);
delay(500);
digitalWrite(LED_BUILTIN, LOW);
delay(500);
}Compile it for the board you have. These are the FQBNs I used for the Uno R3 and the UNO R4 WiFi:
arduino-cli compile -b arduino:avr:uno ~/Arduino/blink
arduino-cli compile -b arduino:renesas_uno:unor4wifi ~/Arduino/blinkThe R3 build fits in 924 bytes and the R4 build in 51,864 bytes, each well inside its board’s flash:
Sketch uses 924 bytes (2%) of program storage space. Maximum is 32256 bytes.
Global variables use 9 bytes (0%) of dynamic memory, leaving 2039 bytes for local variables. Maximum is 2048 bytes.
Sketch uses 51864 bytes (19%) of program storage space. Maximum is 262144 bytes.
Global variables use 6740 bytes (20%) of dynamic memory, leaving 26028 bytes for local variables. Maximum is 32768 bytes.Upload with arduino-cli upload -p /dev/ttyACM0 -b arduino:avr:uno ~/Arduino/blink, swapping in /dev/ttyUSB0 for a CH340 board and the R4 FQBN for an R4. arduino-cli board list shows the port and, for genuine boards, the board name.
Running the Uno R4 udev script
R4 owners have one more step. The Renesas core ships post_install.sh, and running it without sudo only prints instructions. Run it as root from the core’s folder:
cd ~/.arduino15/packages/arduino/hardware/renesas_uno/*/
sudo ./post_install.sh
cat /etc/udev/rules.d/60-arduino-renesas.rulesIt writes a single rule and reloads udev:
Reload rules...
# Renesas based Arduino Santiago/Portenta H33 bootloader mode UDEV rules
SUBSYSTEMS=="usb", ATTRS{idVendor}=="2341", MODE:="0666"Read that rule before you shrug at it. It makes every USB device with Arduino’s vendor ID readable and writable by every user on the machine. On a personal laptop that’s fine. On a shared lab PC I’d change MODE:="0666" to GROUP="dialout", MODE="0660" so it follows the same group as everything else.
Building with PlatformIO
PlatformIO is worth it once you outgrow single-file sketches, because the project, its board and its library versions live in one platformio.ini you can commit. On Ubuntu 26.04 I installed it with pipx, which keeps it out of the system Python:
sudo apt install pipx
pipx install platformio
pio --versionThat gave me PlatformIO Core 6.2.0. A project for an Uno takes one command, and the Blink code goes into src/main.cpp with #include <Arduino.h> added at the top:
mkdir -p ~/pio-blink && cd ~/pio-blink
pio project init -b uno
pio runThe build produces the same 924-byte image arduino-cli did, which is a nice sanity check that both tools use the same Arduino core underneath:
RAM: [ ] 0.4% (used 9 bytes from 2048 bytes)
Flash: [ ] 2.9% (used 924 bytes from 32256 bytes)
Building .pio/build/uno/firmware.hex
========================= [SUCCESS] Took 1.32 seconds =========================PlatformIO also publishes its own udev rules file, with 58 lines that match on USB IDs, the CH340 and Arduino’s vendor ID among them. Its rules set MODE:="0666" as well and tell ModemManager to leave the ports alone, which helps on desktops where ModemManager probes new serial devices. The PlatformIO udev docs pipe the file into sudo tee; I downloaded it, copied it into place and checked both rule files before reloading:
curl -fsSL https://raw.githubusercontent.com/platformio/platformio-core/develop/platformio/assets/system/99-platformio-udev.rules -o /tmp/99-platformio-udev.rules
sudo cp /tmp/99-platformio-udev.rules /etc/udev/rules.d/
udevadm verify /etc/udev/rules.d/60-arduino-renesas.rules /etc/udev/rules.d/99-platformio-udev.rules
sudo udevadm control --reload-rulesOn my VM udevadm verify passed both the PlatformIO file and the Arduino Renesas file:
2 udev rules files have been checked.
Success: 2
Fail: 0You don’t need both rule sets plus dialout. If you’re the only user, dialout alone covers R3 boards and CH340 clones, and the Renesas script covers the R4’s bootloader mode.
Choosing between official, Elegoo and clone boards
Once the Linux setup is done, a clone and a genuine Uno compile the same code from the same core, so the choice comes down to a handful of things that actually differ:
- USB interface: native USB or ATmega16U2 gives
/dev/ttyACM0, a CH340 gives/dev/ttyUSB0; both work on current kernels - Documentation of that interface: Arduino publishes USB IDs, while Elegoo and Freenove kit pages don’t
- R3 or R4: R3 matches older tutorials exactly, R4 has 8 times the flash, USB-C and (on WiFi models) wireless
- Tutorial format: printed book (Arduino), PDF (Elegoo, Freenove) or online only (Plug and Make)
- Parts count: the Elegoo and Freenove kits cost about half as much and add modules the official kits skip, such as an IR remote, ultrasonic sensor and stepper
Buying a genuine board also funds the people who maintain the cores, the IDE and arduino-cli, and every one of these kits depends on that work. It is not a reason to overpay for a gift, but it’s why I lean official when the price gap is small, as it is between the R4 kit and the K000007. If the gift is for a kid who’ll also want an ESP32 next year, our guide to ESP32 boards for ESPHome picks up where these kits stop, and the Arduino and Raspberry Pi books list has the reading to go with them.
Whatever you pick, set the laptop up before the box is opened: install the tools, join dialout, log out and back in. If it’s a fresh install, our Ubuntu 26.04 desktop setup checklist is a good first pass, and the same USB-serial ideas apply to the adapters in our USB console cable guide.
What I still don’t know
A few questions I could not settle from a VM, and I would rather list them than pretend.
- Which USB chip the current Elegoo Super Starter Kit board carries; Elegoo sells both a 16U2 and a CH340C UNO and the kit page names neither
- What vendor ID the Freenove V5 WiFi board reports, and whether the Renesas core’s rule matches it
- Whether the brltty CH340 rule is still active on Ubuntu 24.04; I only read the 26.04 package
- How the AppArmor profile behaves on Fedora and Arch, which don’t restrict user namespaces the way Ubuntu does
If you own one of these boards, the lsusb line from the moment you plug it in answers the first two in a second. The rest of the setup, dialout, the Renesas script and the IDE profile, I’ve run end to end and would do again in the same order.
