Cómo instalar Arduino IDE 2 en Windows, Mac y Linux paso a paso

Instalar Arduino IDE es el primer paso de cualquier proyecto con Arduino y, si lo haces en el orden correcto, te llevará entre 10 y 15 minutos: descargas el programa desde la web oficial de Arduino (arduino.cc/en/software), lo instalas en tu sistema operativo, conectas la placa con un cable USB, eliges la placa y el puerto y cargas tu primer sketch de prueba, Blink. Cuando el pequeño LED de la placa empieza a parpadear una vez por segundo, la instalación está lista. Esta guía se basa en la versión actual, Arduino IDE 2 (la 2.3.10 en octubre de 2026); también encontrarás una tabla con sus diferencias respecto a la antigua 1.8.19.

Aquí tienes instrucciones paso a paso, por separado, para Windows, macOS y Linux. Después te presentamos uno a uno los drivers y el puerto COM, el selector de placa, los botones Verificar y Cargar, el Monitor Serie, el Gestor de Bibliotecas y el Gestor de placas. También verás cómo añadir los paquetes de placas de ESP32 y Raspberry Pi Pico, cómo ajustar el idioma y el tamaño de letra, cuándo conviene el Arduino Cloud Editor, que no necesita instalación, y cómo resolver los errores de instalación más frecuentes.

¿Qué es Arduino IDE y qué versión debes descargar?

Arduino IDE (Integrated Development Environment, entorno de desarrollo integrado) es el programa gratuito y de código abierto en el que escribes tu código, lo compilas, ves sus errores y lo cargas en la placa por USB. Por detrás ejecuta por ti el compilador de C++, los paquetes de placas y herramientas de carga como avrdude o esptool; tú solo pulsas dos botones. La versión que se desarrolla activamente hoy es Arduino IDE 2: ofrece autocompletado, tema oscuro, depurador integrado y un Plotter Serie renovado. La antigua 1.8.19 aún se puede descargar, pero solo recibe correcciones de seguridad críticas, así que si estás empezando instala directamente el IDE 2.

Requisitos del sistema y cómo elegir el archivo correcto

En la página de descarga verás varios archivos según el sistema operativo. Arduino IDE 2 solo funciona en sistemas de 64 bits; si usas Windows de 32 bits o un macOS muy antiguo, tu única opción es la 1.8.19. Puedes ver el procesador de tu Mac en menú Apple > Acerca de este Mac: si pone Chip: Apple M…, elige Apple Silicon; si pone Procesador: Intel, elige la versión para Intel.

Instalar Arduino IDE en Windows

1. Descarga el instalador .exe para Windows desde la página de descarga y haz doble clic. Si aparece una página que pide una donación, puedes seguir con la descarga sin donar.
2. Acepta la licencia con I Agree. Luego elige si instalarlo para todos los usuarios del equipo (Anyone who uses this computer) o solo para ti (Only for me); en un ordenador del instituto o compartido, la primera opción requiere permisos de administrador.
3. Deja la carpeta de instalación tal como está y pulsa Install. Al terminar, deja marcada la casilla Run Arduino IDE y pulsa Finish.
4. Si Windows pregunta "¿Desea instalar este software de dispositivo?" para los drivers USB de Arduino y placas compatibles, pulsa Instalar; estos drivers permiten reconocer placas como el Uno original, el Mega y el Leonardo. Si el firewall pide acceso a la red, permítelo también.
5. Cuando se abra el IDE, verás en la esquina inferior derecha avisos de que se están instalando el paquete Arduino AVR Boards y las bibliotecas integradas. Mantén la conexión a internet y espera a que terminen; el soporte para Uno, Nano y Mega llega con este paquete.

Al conectar la placa, debería aparecer un nuevo puerto COM en el Administrador de dispositivos, bajo Puertos (COM y LPT). Un Uno original aparece como Arduino Uno (COMx), y los clones económicos con chip CH340, como USB-SERIAL CH340 (COMx). Si un clon aparece en Otros dispositivos como USB2.0-Serial con un signo de exclamación amarillo, falta el driver CH340; Windows Update suele instalarlo solo y, si no lo hace, instala el paquete CH341SER del fabricante del chip, WCH. El chip CP2102, habitual en muchas placas ESP32, necesita el driver CP210x VCP de Silicon Labs. Explicamos el diagnóstico detallado de los problemas de puerto y drivers en Arduino no carga el código.

Instalar Arduino IDE en macOS

1. Descarga el .dmg que corresponda a tu procesador y haz doble clic. En la ventana que se abre, arrastra el icono de Arduino IDE a la carpeta Aplicaciones.
2. Abre la app desde Launchpad o con Spotlight (Cmd + Espacio). Cuando te pregunte si seguro que quieres abrir una app descargada de internet, pulsa Abrir.
3. El IDE puede pedir acceso a la carpeta Documentos/Arduino, donde guarda tus sketches; concédelo, o no podrá guardarlos.
4. La primera vez que conectes una placa a un MacBook con Apple Silicon puede aparecer el aviso "¿Permitir que se conecte el accesorio?". Si no pulsas Permitir, la placa nunca aparecerá en la lista de puertos.
5. En la lista de puertos, un Uno original aparece como /dev/cu.usbmodem…, y los clones con CH340, como /dev/cu.usbserial-… o /dev/cu.wchusbserial…. Las versiones recientes de macOS ya incluyen drivers para CH340 y CP2102; instalar encima drivers antiguos suele empeorar las cosas.

En los Mac con Apple Silicon, las herramientas de algunos paquetes de placas siguen compiladas para procesadores Intel. Si al compilar o cargar ves el error bad CPU type in executable, abre Terminal e instala Rosetta 2 con softwareupdate --install-rosetta; esta capa de traducción de Apple permite que esas herramientas de Intel funcionen en los chips de la serie M. Si el error continúa, actualiza ese paquete de placas a su última versión desde el Gestor de placas.

Instalar Arduino IDE en Linux (AppImage)

1. Descarga el AppImage. Un AppImage es una aplicación empaquetada en un solo archivo que no necesita instalación; si quieres, muévelo a un lugar fijo de tu carpeta personal.
2. Haz el archivo ejecutable: clic derecho y, en Propiedades > Permisos, marca Permitir ejecutar el archivo como un programa. En la terminal, chmod +x arduino-ide_*_Linux_64bit.AppImage hace lo mismo.
3. Haz doble clic en el archivo para abrir el IDE. Si aparece dlopen(): error loading libfuse.so.2 o AppImages require FUSE to run, falta la biblioteca FUSE 2: ejecuta sudo apt install libfuse2 en Ubuntu 22.04, o sudo apt install libfuse2t64 en Ubuntu 24.04 y posteriores.
4. Añade tu usuario al grupo dialout para poder usar los puertos serie: sudo usermod -a -G dialout $USER. Reinicia el ordenador para que el cambio surta efecto; si no, la carga fallará con Permission denied.
5. Si el puerto de una placa con chip CH340 o CP2102 aparece un instante y desaparece, el servicio brltty para líneas braille, instalado de serie, se lo está quedando. Si no usas una línea braille, elimínalo con sudo apt remove brltty y vuelve a conectar la placa.
6. Si en Ubuntu 24.04 el IDE no llega a abrirse y la terminal muestra The SUID sandbox helper binary was found, but is not configured correctly, AppArmor está bloqueando el sandbox de la aplicación. Como solución temporal, puedes abrir el IDE desde la terminal con la opción --no-sandbox.

Recorrido por la interfaz de Arduino IDE 2

Al abrir el IDE por primera vez te recibe un sketch vacío: este esqueleto formado por las funciones setup() y loop() es la base de cualquier programa de Arduino. En el mundo Arduino los programas se llaman sketches, y cada sketch se guarda como un archivo .ino dentro de una carpeta con el mismo nombre. La ventana se divide en cuatro zonas: arriba, la barra de herramientas con el selector de placa; a la izquierda, la barra lateral; en el centro, el editor de código; y abajo, el panel Salida, por donde pasan los mensajes del compilador, junto con el Monitor Serie. La barra de estado, al final de todo, muestra el número de línea del cursor y la placa y el puerto seleccionados.

Cómo elegir la placa y el puerto

La selección de placa le dice al IDE para qué procesador compilar y con qué herramienta cargar; la selección de puerto señala la placa física conectada a tu ordenador. Sin ambas correctas no hay carga posible. Después de conectar la placa, abre el selector de arriba: un Uno original aparece con su nombre y se elige con un clic. Con los clones CH340, en cambio, el IDE no reconoce la placa y el puerto aparece como Desconocido (Unknown). En ese caso abre Seleccione otra placa y puerto, escribe "uno" en el buscador, elige Arduino Uno a la izquierda y el puerto a la derecha, y pulsa OK. Si no sabes qué puerto es el de tu placa, desconéctala, mira la lista y vuelve a conectarla: el puerto que aparece es el tuyo.

Cargar tu primer sketch: Blink paso a paso

1. Ve a Archivo > Ejemplos > 01.Basics > Blink. El ejemplo se abre en una ventana nueva; es un sketch incluido con el IDE que hace parpadear el LED integrado.
2. Elige tu placa y tu puerto en el selector; en la barra de estado de abajo deberías ver ahora el nombre de la placa y el puerto.
3. Pulsa primero Verificar (Ctrl+R). Si en la salida (con la interfaz en inglés) aparece Sketch uses 924 bytes (2%) of program storage space. Maximum is 32256 bytes., la compilación ha ido bien.
4. Después pulsa Cargar (Ctrl+U). Los LED TX y RX de la placa parpadean rápido un momento y abajo a la derecha aparece el aviso Carga completada (Done uploading).
5. El LED marcado con L debería quedarse un segundo encendido y un segundo apagado. Para asegurarte de que de verdad se ha cargado tu código nuevo, cambia las dos líneas delay(1000) por delay(200) y vuelve a cargar; si parpadea más rápido, todo funciona.
6. Cuando intentes guardar el ejemplo modificado, el IDE te pedirá un nombre y una ubicación nuevos, porque los ejemplos están en la carpeta del propio programa. Tus sketches se guardan por defecto en la carpeta Documentos/Arduino, tu Sketchbook.

Esas líneas de la salida te informan sobre la memoria de tu placa. El bootloader ocupa 512 bytes de los 32 KB de memoria flash del ATmega328P del Uno, por eso quedan 32256 bytes para tu código, y Blink usa solo el 2 %. La línea Global variables use 9 bytes, justo debajo, indica cuánto de los 2048 bytes de RAM se reserva para variables globales. Cuando tus proyectos crezcan, vigilar estos porcentajes suele responder a la pregunta "¿por qué se cuelga mi placa?" antes de que llegue a plantearse. Ahora escribe tu primer sketch propio: el código de abajo añade a Blink unas líneas que envían mensajes al Monitor Serie, así compruebas a la vez la carga y el intercambio de datos por USB.

1// İlk test: dahili LED yanıp söner, Seri Port Ekranı'na yazı gelir
2// First test: blinks the onboard LED and prints to the Serial Monitor
3int sayac = 0;                        // kaç kez yanıp söndü / blink counter
4
5void setup() {
6  pinMode(LED_BUILTIN, OUTPUT);       // Uno'da pin 13 (L LED'i) / pin 13 (L LED) on the Uno
7  Serial.begin(9600);                 // Seri Port Ekranı hızı / Serial Monitor baud rate
8  Serial.println("Merhaba BlueGrays! / Hello BlueGrays!");
9}
10
11void loop() {
12  digitalWrite(LED_BUILTIN, HIGH);    // LED'i yak / turn the LED on
13  delay(1000);                        // 1 saniye bekle / wait 1 second
14  digitalWrite(LED_BUILTIN, LOW);     // LED'i söndür / turn the LED off
15  delay(1000);
16  sayac++;
17  Serial.print("Yanip sonme / Blink: ");
18  Serial.println(sayac);
19}

setup() se ejecuta una vez al encender o reiniciar la placa: aquí ponemos el pin 13 como salida e iniciamos la comunicación serie a 9600 baudios. loop() se repite después sin fin mientras la placa tenga alimentación. LED_BUILTIN es el nombre del pin al que está conectado el LED integrado; en Uno, Nano y Mega equivale al 13, por eso el mismo código funciona sin cambios en esas placas. Para una explicación detallada de los comandos, echa un vistazo a Comandos de Arduino.

Monitor Serie y Plotter Serie

Después de cargar el código, haz clic en el icono de la lupa arriba a la derecha o pulsa Ctrl+Mayús+M. El Monitor Serie se abre en el panel inferior y escribe una línea nueva cada vez que la placa parpadea. El menú de velocidad, arriba a la derecha del panel, debe coincidir con el valor de Serial.begin() del código, es decir, 9600 baudios; si no, la pantalla se llena de caracteres sin sentido. Si escribes en la caja de mensajes de arriba y pulsas Enter, el texto se envía a la placa. El menú de fin de línea de al lado ofrece Sin ajuste de línea, Nueva línea, Retorno de carro y Ambos NL y RC; elige el que espere tu código.

El Plotter Serie muestra los números como una gráfica: si envías líneas con etiqueta como Serial.print("luz:"); Serial.println(valor);, cada etiqueta se convierte en una línea de su propio color. Es ideal para ver en directo los valores de un potenciómetro o de una LDR. Al cargar, asegúrate de que ningún otro programa (una segunda ventana del IDE, PuTTY, un script de Python) tenga ocupado el puerto, porque un puerto solo puede estar abierto en un programa a la vez. Hemos reunido todos los detalles de estas herramientas en Monitor Serie de Arduino.

Gestor de Bibliotecas y Gestor de placas

Buena parte de la potencia de Arduino viene de las bibliotecas ya hechas. Abre el Gestor de Bibliotecas con el icono de los libros de la barra lateral izquierda (Ctrl+Mayús+I), escribe el nombre de la biblioteca en el buscador (por ejemplo "DHT sensor library") y pulsa Instalar. Si la biblioteca necesita otras, el IDE te lo pregunta; elegir Instalar todo evita desde el principio los errores por archivos que faltan. Las bibliotecas instaladas van a la carpeta libraries de tu Sketchbook y sus ejemplos se añaden al menú Archivo > Ejemplos. Los archivos ZIP descargados de internet se instalan con Sketch > Incluir biblioteca > Añadir biblioteca .ZIP; tienes los detalles en Cómo añadir una biblioteca en Arduino.

El Gestor de placas (Ctrl+Mayús+B), en cambio, instala los compiladores y las herramientas de carga de cada familia de procesadores. El paquete de Uno, Nano y Mega llega solo en el primer arranque; para placas como Uno R4, ESP32 o Pico instalas el paquete correspondiente una sola vez. Las placas de Arduino aparecen directamente en la lista, mientras que para las de otros fabricantes primero añades la URL de su paquete en Preferencias. Los paquetes de placas no se instalan en el Sketchbook, sino en una carpeta aparte llamada Arduino15: C:\Users\usuario\AppData\Local\Arduino15 en Windows, ~/Library/Arduino15 en macOS y ~/.arduino15 en Linux.

Añadir el paquete de placas ESP32

1. Abre Archivo > Preferencias (Ctrl+,) y pega esta dirección en el campo URLs adicionales de gestor de placas: https://espressif.github.io/arduino-esp32/package_esp32_index.json. Para añadir varias, pulsa el icono junto al campo y pon cada URL en su propia línea.
2. Pulsa OK, abre el Gestor de placas y escribe esp32 en el buscador.
3. Busca esp32 by Espressif Systems y pulsa Instalar. El paquete ocupa cientos de megabytes, así que con una conexión lenta la descarga puede tardar varios minutos. El paquete Arduino ESP32 Boards, que también aparece, es solo para el Arduino Nano ESP32; para las placas ESP32 genéricas instala el de Espressif.
4. Elige ESP32 Dev Module como placa y el puerto de tu placa. Como la mayoría de los ESP32 DevKit llevan un chip CP2102 o CH340, el IDE muestra la placa como desconocida; es normal.
5. Carga el sketch de prueba de abajo y pon el Monitor Serie a 115200 baudios. Si en la salida aparece Connecting.... y no termina, mantén pulsado el botón BOOT de la placa y suéltalo cuando empiecen a avanzar los porcentajes de carga.

1// ESP32 kurulum testi: yonga bilgisi + LED / ESP32 setup test: chip info + LED
2const int LED_PIN = 2;   // çoğu ESP32 DevKit'te dahili LED / onboard LED on most DevKits
3
4void setup() {
5  pinMode(LED_PIN, OUTPUT);
6  Serial.begin(115200);  // ESP32 için yaygın hız / common ESP32 baud rate
7  delay(1000);           // Seri Port Ekranı açılsın diye bekle / give the monitor time to open
8  Serial.print("Model: ");
9  Serial.println(ESP.getChipModel());                  // ör. ESP32-D0WD-V3 / e.g. ESP32-D0WD-V3
10  Serial.print("Cekirdek / Cores: ");
11  Serial.println(ESP.getChipCores());
12  Serial.print("CPU (MHz): ");
13  Serial.println(ESP.getCpuFreqMHz());
14  Serial.print("Flash (MB): ");
15  Serial.println(ESP.getFlashChipSize() / (1024 * 1024));
16  Serial.print("Bos RAM / Free heap (bayt / bytes): ");
17  Serial.println(ESP.getFreeHeap());
18}
19
20void loop() {
21  digitalWrite(LED_PIN, !digitalRead(LED_PIN));        // LED'i ters çevir / toggle the LED
22  delay(500);
23}

Si el Monitor Serie muestra el modelo del chip, el número de núcleos, la velocidad de 240 MHz y el tamaño de la flash, normalmente 4 MB, tu ESP32 está listo; si tu placa tiene un LED integrado en el GPIO 2, también parpadeará cada medio segundo. Los pines del ESP32, la conexión wifi y un primer proyecto controlado desde el móvil los vemos en ¿Qué es el ESP32?

Añadir el paquete de placas Raspberry Pi Pico

1. En Preferencias, añade en la lista URLs adicionales de gestor de placas, en una línea aparte debajo de la del ESP32, esta dirección: https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json.
2. Busca pico en el Gestor de placas e instala el paquete Raspberry Pi Pico/RP2040/RP2350 de Earle F. Philhower. Este paquete de la comunidad es compatible con Pico, Pico W, Pico 2 y Pico 2 W y funciona con la mayoría de las bibliotecas de Arduino.
3. Elige Raspberry Pi Pico como placa, o el modelo que tengas (Pico W, Pico 2).
4. Para la primera carga, mantén pulsado el botón BOOTSEL de la Pico mientras conectas el cable USB y luego suéltalo. La Pico aparece en el ordenador como una unidad llamada RPI-RP2 (RP2350 en la Pico 2) y en la lista de puertos surge UF2 Board; elige ese puerto y pulsa Cargar.
5. Cuando el código empieza a funcionar, la Pico abre un puerto serie normal. Elige ese puerto nuevo en la lista; en las cargas siguientes ya no necesitas BOOTSEL, porque el IDE reinicia la placa por sí solo.

1// Pico kurulum testi: dahili LED + yonga sıcaklığı
2// Pico setup test: onboard LED + chip temperature
3void setup() {
4  pinMode(LED_BUILTIN, OUTPUT);   // Pico'da GP25; Pico W'de kablosuz yonga üzerinden / GP25 on Pico, via the wireless chip on Pico W
5  Serial.begin(115200);           // USB seri port / USB serial port
6}
7
8void loop() {
9  digitalWrite(LED_BUILTIN, HIGH);
10  delay(500);
11  digitalWrite(LED_BUILTIN, LOW);
12  delay(500);
13  Serial.print("Yonga sicakligi / Chip temperature (C): ");
14  Serial.println(analogReadTemp());   // dahili sensör, yaklaşık değer / internal sensor, approximate
15}

Si quieres programar la Pico en MicroPython, se usa Thonny en lugar de Arduino IDE; encontrarás las diferencias entre ambos caminos y cómo instalar MicroPython en ¿Qué es la Raspberry Pi Pico? Ten en cuenta que al cargar desde Arduino IDE se borra MicroPython de la placa. Para volver, basta con grabar de nuevo el archivo UF2 de MicroPython con el método BOOTSEL.

Preferencias: idioma, tamaño de letra y otros ajustes

La ventana de Preferencias se abre desde Archivo > Preferencias (en macOS, desde el menú de la app Arduino IDE) o con Ctrl+,. Para poner la interfaz en español, elige Español en la lista Language (Idioma) y pulsa OK; tras una breve recarga, el IDE se abre con los menús traducidos. Los mensajes de error del compilador siguen en inglés. Estos son los ajustes más útiles para quien empieza:

Arduino Cloud Editor: programar en el navegador sin instalar nada

Si no puedes instalar programas en tu ordenador (un equipo del instituto, un Chromebook o un portátil sin permisos de administrador), el Arduino Cloud Editor es una buena alternativa. Inicias sesión en app.arduino.cc con una cuenta gratuita de Arduino y creas un sketch nuevo en la sección Sketches; tu código se guarda en la nube y se abre igual en cualquier ordenador. En Windows, macOS y Linux tienes que instalar una vez un pequeño programa en segundo plano, el Arduino Cloud Agent, para cargar en la placa por USB. En un Chromebook se usa el navegador o la app Arduino Cloud for Chromebook en lugar del agente, pero ahí solo se admiten el Uno R3, el Uno R4 y algunas otras placas oficiales de Arduino. También puedes combinar ambas herramientas: si inicias sesión con tu cuenta de Arduino en el IDE 2, el Sketchbook en la nube (Cloud Sketchbook) hace que el IDE de casa y el Cloud Editor del instituto vean los mismos sketches.

Problemas frecuentes al instalar y cómo solucionarlos

Instalación terminada: ¿y ahora qué?

• Afianza lo básico: aprende cómo encajan la placa, los pines y la programación en ¿Qué es Arduino? y consulta los comandos más usados en la guía Comandos de Arduino.
• Monta tu primer circuito: en vez del LED integrado, haz Blink con un LED y una resistencia en una protoboard; calcula la resistencia adecuada con la calculadora de resistencia para LED y mira dónde está cada pin en la herramienta Pinout.
• Pruébalo sin placa: si aún no tienes placa, simula en el navegador con Tinkercad o Wokwi.
• Aprende a resolver errores: cuando aparezcan mensajes en rojo, consulta las guías sobre errores de carga y errores de compilación.
• Pásate a lo inalámbrico: si instalaste el paquete ESP32, haz tu primer proyecto wifi con ¿Qué es el ESP32?
• Elige la placa adecuada: si aún no has comprado una placa, echa un vistazo a ¿Qué Arduino comprar? y Kit de inicio de Arduino.

Una vez bien instalado, Arduino IDE funciona sin problemas durante años; cuando consigas una placa nueva, solo tendrás que instalar su paquete en el Gestor de placas y elegir bien la placa y el puerto. Si Blink funciona, ya estás listo: en la app BlueGrays encontrarás decenas de proyectos para Arduino, ESP32 y Raspberry Pi Pico, desde LED que parpadean y semáforos hasta sensores de distancia y proyectos wifi, cada uno con su esquema de circuito, su lista de componentes y su código explicado paso a paso, para probarlos al momento en tu IDE recién instalado.