Arduino IDE installieren: Windows, Mac, Linux und erster Sketch

Die Arduino IDE zu installieren ist der erste Schritt jedes Arduino-Projekts und dauert in der richtigen Reihenfolge nur 10–15 Minuten: Du lädst das Programm von der offiziellen Arduino-Website (arduino.cc/en/software) herunter, installierst es auf deinem Betriebssystem, schließt dein Board per USB-Kabel an, wählst Board und Port aus und lädst deinen ersten Test-Sketch Blink hoch. Sobald die kleine LED auf dem Board im Sekundentakt blinkt, ist die Einrichtung abgeschlossen. Diese Anleitung basiert auf der aktuellen Arduino IDE 2 (Stand Oktober 2026: Version 2.3.10); die Unterschiede zur alten 1.8.19 findest du in einer Tabelle.

Du bekommst hier getrennte Schritt-für-Schritt-Anleitungen für Windows, macOS und Linux. Danach stellen wir dir Treiber und COM-Port, die Board-Auswahl, die Schaltflächen Überprüfen und Hochladen, den seriellen Monitor, den Bibliotheksverwalter und die Board-Verwaltung einzeln vor. Außerdem zeigen wir, wie du die Board-Pakete für ESP32 und Raspberry Pi Pico hinzufügst, Sprache und Schriftgröße einstellst, wann sich der Arduino Cloud Editor ohne Installation lohnt und wie du die häufigsten Installationsfehler behebst.

Was ist die Arduino IDE und welche Version solltest du herunterladen?

Die Arduino IDE (Integrated Development Environment, integrierte Entwicklungsumgebung) ist das kostenlose Open-Source-Programm, in dem du deinen Code schreibst, kompilierst, Fehler siehst und ihn per USB auf das Board lädst. Im Hintergrund startet sie für dich den C++-Compiler, die Board-Pakete und Upload-Werkzeuge wie avrdude oder esptool; du drückst nur zwei Knöpfe. Aktiv weiterentwickelt wird heute die Arduino IDE 2: Sie bietet Autovervollständigung, ein dunkles Design, einen eingebauten Debugger und einen überarbeiteten seriellen Plotter. Die alte 1.8.19 lässt sich zwar noch herunterladen, erhält aber nur noch kritische Sicherheitsupdates. Wenn du neu anfängst, installiere direkt die IDE 2.

Systemvoraussetzungen und die richtige Datei

Auf der Download-Seite siehst du je nach Betriebssystem mehrere Dateien. Die Arduino IDE 2 läuft nur auf 64-Bit-Systemen; mit 32-Bit-Windows oder einem sehr alten macOS bleibt dir nur die 1.8.19. Welchen Prozessor dein Mac hat, siehst du unter Apple-Menü > Über diesen Mac: Steht dort Chip: Apple M…, nimm die Apple-Silicon-Version, steht dort Prozessor: Intel, die Intel-Version.

Arduino IDE unter Windows installieren

1. Lade auf der Download-Seite das Windows-Installationsprogramm (.exe) herunter und doppelklicke darauf. Falls eine Seite mit der Bitte um eine Spende erscheint, kannst du auch ohne Spende weiter zum Download gehen.
2. Akzeptiere die Lizenz mit I Agree. Wähle dann, ob die IDE für alle Benutzer des Computers (Anyone who uses this computer) oder nur für dich (Only for me) installiert wird; auf Schul- oder Gemeinschaftsrechnern braucht die erste Option Administratorrechte.
3. Lass den Installationsordner unverändert und klicke auf Install. Wenn die Installation fertig ist, lass Run Arduino IDE angehakt und klicke auf Finish.
4. Fragt Windows „Möchten Sie diese Gerätesoftware installieren?“ für die USB-Treiber von Arduino und kompatiblen Boards, klicke auf Installieren; diese Treiber sorgen dafür, dass Boards wie das originale Uno, Mega und Leonardo erkannt werden. Fragt die Firewall nach Netzwerkzugriff, erlaube auch diesen.
5. Nach dem Start der IDE siehst du unten rechts Meldungen, dass das Paket Arduino AVR Boards und die integrierten Bibliotheken installiert werden. Bleib online und warte, bis sie fertig sind; die Unterstützung für Uno, Nano und Mega kommt mit diesem Paket.

Sobald du dein Board ansteckst, sollte im Geräte-Manager unter Anschlüsse (COM & LPT) ein neuer COM-Port erscheinen. Ein originaler Uno meldet sich als Arduino Uno (COMx), günstige Klone mit CH340-Chip als USB-SERIAL CH340 (COMx). Steht ein Klon unter Andere Geräte als USB2.0-Serial mit gelbem Ausrufezeichen, fehlt der CH340-Treiber; Windows Update installiert ihn meist selbst, andernfalls installierst du das Paket CH341SER des Chipherstellers WCH. Der CP2102-Chip, den viele ESP32-Boards nutzen, braucht den CP210x VCP-Treiber von Silicon Labs. Eine ausführliche Fehlersuche bei Port- und Treiberproblemen findest du im Artikel Arduino lädt nicht hoch.

Arduino IDE unter macOS installieren

1. Lade die zu deinem Prozessor passende .dmg-Datei herunter und doppelklicke darauf. Ziehe im geöffneten Fenster das Symbol Arduino IDE in den Ordner Programme (Applications).
2. Öffne die App über das Launchpad oder Spotlight (Cmd + Leertaste). Auf die Frage, ob du eine aus dem Internet geladene App wirklich öffnen willst, antwortest du mit Öffnen.
3. Die IDE fragt eventuell nach Zugriff auf den Ordner Dokumente/Arduino, in dem sie deine Sketches speichert; erlaube ihn, sonst lassen sich deine Sketches nicht speichern.
4. Wenn du ein Board zum ersten Mal an ein MacBook mit Apple Silicon ansteckst, kann die Frage „Verbindung des Zubehörs erlauben?“ erscheinen. Klickst du nicht auf Erlauben, taucht das Board nie in der Portliste auf.
5. In der Portliste erscheint ein originaler Uno als /dev/cu.usbmodem…, CH340-Klone als /dev/cu.usbserial-… oder /dev/cu.wchusbserial…. Aktuelle macOS-Versionen bringen Treiber für CH340 und CP2102 bereits mit; alte Treiber zusätzlich zu installieren, macht die Sache meist schlimmer.

Auf Macs mit Apple Silicon sind die Werkzeuge mancher Board-Pakete noch für Intel-Prozessoren gebaut. Siehst du beim Kompilieren oder Hochladen den Fehler bad CPU type in executable, öffne das Terminal und installiere Rosetta 2 mit softwareupdate --install-rosetta; diese Übersetzungsschicht von Apple lässt Intel-Werkzeuge auf Chips der M-Serie laufen. Bleibt der Fehler, aktualisiere das betreffende Board-Paket in der Board-Verwaltung auf die neueste Version.

Arduino IDE unter Linux installieren (AppImage)

1. Lade das AppImage herunter. Ein AppImage ist ein Programmpaket aus einer einzigen Datei, das keine Installation braucht; verschiebe es bei Bedarf an einen festen Ort in deinem Home-Verzeichnis.
2. Mache die Datei ausführbar: Rechtsklick, unter Eigenschaften > Zugriffsrechte das Häkchen bei Datei als Programm ausführen setzen. Im Terminal erledigt chmod +x arduino-ide_*_Linux_64bit.AppImage dasselbe.
3. Starte die IDE per Doppelklick. Bekommst du dlopen(): error loading libfuse.so.2 oder AppImages require FUSE to run, fehlt die FUSE-2-Bibliothek: Unter Ubuntu 22.04 hilft sudo apt install libfuse2, ab Ubuntu 24.04 sudo apt install libfuse2t64.
4. Füge deinen Benutzer der Gruppe dialout hinzu, damit er auf serielle Ports zugreifen darf: sudo usermod -a -G dialout $USER. Starte den Rechner danach neu, sonst scheitert das Hochladen mit Permission denied.
5. Erscheint der Port eines Boards mit CH340- oder CP2102-Chip nur kurz und verschwindet dann wieder, schnappt ihn sich der vorinstallierte Dienst brltty für Braillezeilen. Nutzt du keine Braillezeile, entferne ihn mit sudo apt remove brltty und stecke das Board neu an.
6. Öffnet sich die IDE unter Ubuntu 24.04 gar nicht und das Terminal meldet The SUID sandbox helper binary was found, but is not configured correctly, blockiert AppArmor die Sandbox der App. Als vorläufige Lösung startest du die IDE im Terminal mit der Option --no-sandbox.

Rundgang durch die Oberfläche der Arduino IDE 2

Beim ersten Start siehst du einen leeren Sketch: Dieses Gerüst aus den Funktionen setup() und loop() ist die Grundlage jedes Arduino-Programms. In der Arduino-Welt heißen Programme Sketches, und jeder Sketch liegt als .ino-Datei in einem gleichnamigen Ordner. Das Fenster ist in vier Bereiche geteilt: oben die Symbolleiste mit der Board-Auswahl, links die Seitenleiste, in der Mitte der Code-Editor und unten das Panel Ausgabe, in dem die Compiler-Meldungen durchlaufen, sowie der serielle Monitor. Die Statusleiste ganz unten zeigt die Zeilennummer des Cursors sowie das gewählte Board und den Port.

Board und Port auswählen

Die Board-Auswahl sagt der IDE, für welchen Prozessor sie kompilieren und mit welchem Werkzeug sie hochladen soll; die Port-Auswahl zeigt auf das physische Board an deinem Computer. Ohne beides geht kein Upload. Öffne nach dem Anschließen oben die Board-Auswahl: Ein originaler Uno steht dort mit Namen und lässt sich mit einem Klick wählen. Bei CH340-Klonen erkennt die IDE das Board dagegen nicht, und der Port erscheint als Unbekannt (Unknown). Öffne dann Wähle ein anderes Board und einen anderen Port, tippe „uno“ ins Suchfeld, wähle links Arduino Uno und rechts den Port und klicke auf OK. Weißt du nicht, welcher Port zu deinem Board gehört, ziehe es ab, sieh dir die Liste an und stecke es wieder ein: Der neu auftauchende Port ist deiner.

Den ersten Sketch hochladen: Blink Schritt für Schritt

1. Öffne Datei > Beispiele > 01.Basics > Blink. Das Beispiel öffnet sich in einem neuen Fenster; es ist ein mitgelieferter Sketch, der die eingebaute LED blinken lässt.
2. Wähle in der Board-Auswahl dein Board und den Port; in der Statusleiste unten sollten jetzt Board-Name und Port stehen.
3. Klicke zuerst auf Überprüfen (Strg+R). Zeigt die Ausgabe (bei englischer Oberfläche) Sketch uses 924 bytes (2%) of program storage space. Maximum is 32256 bytes., war das Kompilieren erfolgreich.
4. Klicke dann auf Hochladen (Strg+U). Die TX- und RX-LEDs auf dem Board flackern kurz, und unten rechts erscheint die Meldung Hochladen erfolgreich (Done uploading).
5. Die mit L beschriftete LED sollte jetzt eine Sekunde an und eine Sekunde aus sein. Um sicherzugehen, dass wirklich dein neuer Code auf dem Board ist, ändere beide Zeilen delay(1000) in delay(200) und lade erneut hoch; blinkt es schneller, passt alles.
6. Willst du das geänderte Beispiel speichern, fragt die IDE nach einem neuen Namen und Ort, weil Beispiele im Programmordner liegen. Deine eigenen Sketches landen standardmäßig im Ordner Dokumente/Arduino, deinem Sketchbook.

Diese Zeilen in der Ausgabe verraten dir etwas über den Speicher deines Boards. Der Bootloader belegt 512 Byte der 32 KB Flash-Speicher des ATmega328P im Uno, deshalb bleiben 32256 Byte für deinen Code, von denen Blink nur 2 % braucht. Die Zeile Global variables use 9 bytes direkt darunter zeigt, wie viel der 2048 Byte RAM für globale Variablen reserviert ist. Wenn deine Projekte wachsen, beantwortet ein Blick auf diese Prozentwerte oft die Frage „Warum hängt sich mein Board auf?“, bevor sie überhaupt aufkommt. Jetzt schreibst du deinen ersten eigenen Sketch: Der folgende Code ergänzt Blink um ein paar Zeilen, die Meldungen an den seriellen Monitor schicken, sodass du Hochladen und Datenaustausch über USB gleichzeitig testest.

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() läuft einmal, wenn das Board startet oder zurückgesetzt wird: Hier schalten wir Pin 13 auf Ausgang und starten die serielle Kommunikation mit 9600 Baud. loop() wiederholt sich danach endlos, solange das Board Strom hat. LED_BUILTIN ist der Name des Pins, an dem die eingebaute LED hängt; bei Uno, Nano und Mega entspricht er 13, deshalb läuft derselbe Code auf diesen Boards unverändert. Eine ausführliche Erklärung der Befehle findest du im Artikel Arduino-Befehle.

Serieller Monitor und serieller Plotter

Klicke nach dem Hochladen auf das Lupensymbol oben rechts oder drücke Strg+Umschalt+M. Der serielle Monitor öffnet sich im unteren Panel und schreibt bei jedem Blinken eine neue Zeile. Das Baudraten-Menü oben rechts im Panel muss zum Wert von Serial.begin() im Code passen, also 9600 Baud; sonst erscheinen nur wirre Zeichen. Tippst du oben ins Nachrichtenfeld und drückst Enter, geht der Text an das Board. Das Zeilenende-Menü daneben bietet Kein Zeilenende, Neue Zeile, Zeilenumbruch (CR) und Beides CR/LF; du wählst, was dein Code erwartet.

Der serielle Plotter zeigt Zahlen als Diagramm: Schickst du beschriftete Zeilen wie Serial.print("licht:"); Serial.println(wert);, wird jede Beschriftung zu einer eigenen farbigen Linie. Ideal, um Werte eines Potentiometers oder LDR live zu beobachten. Achte beim Hochladen darauf, dass kein anderes Programm (ein zweites IDE-Fenster, PuTTY, ein Python-Skript) den Port belegt, denn ein Port lässt sich immer nur von einem Programm öffnen. Alle Feinheiten dieser Werkzeuge haben wir im Artikel Arduino Serial Monitor zusammengestellt.

Bibliotheksverwalter und Board-Verwaltung

Ein großer Teil der Stärke von Arduino steckt in fertigen Bibliotheken. Öffne den Bibliotheksverwalter mit dem Bücher-Symbol in der linken Seitenleiste (Strg+Umschalt+I), gib den Namen der Bibliothek ins Suchfeld ein (zum Beispiel „DHT sensor library“) und klicke auf Installieren. Braucht die Bibliothek weitere Bibliotheken, fragt die IDE nach; mit Alle installieren vermeidest du von Anfang an Fehler wegen fehlender Dateien. Installierte Bibliotheken landen im Ordner libraries deines Sketchbooks, ihre Beispiele erscheinen unter Datei > Beispiele. Aus dem Internet geladene ZIP-Dateien installierst du über Sketch > Bibliothek einbinden > .ZIP-Bibliothek hinzufügen; Details findest du im Artikel Arduino-Bibliothek hinzufügen.

Die Board-Verwaltung (Strg+Umschalt+B) installiert dagegen Compiler und Upload-Werkzeuge für verschiedene Prozessorfamilien. Das Paket für Uno, Nano und Mega kommt beim ersten Start automatisch; für Boards wie Uno R4, ESP32 oder Pico installierst du das passende Paket einmalig. Arduinos eigene Boards stehen direkt in der Liste, für Boards anderer Hersteller trägst du vorher eine Paket-URL in den Einstellungen ein. Board-Pakete landen nicht im Sketchbook, sondern in einem eigenen Ordner namens Arduino15: unter Windows C:\Users\Benutzername\AppData\Local\Arduino15, unter macOS ~/Library/Arduino15 und unter Linux ~/.arduino15.

Das ESP32-Board-Paket hinzufügen

1. Öffne Datei > Einstellungen (Strg+,) und füge im Feld Zusätzliche Boardverwalter-URLs diese Adresse ein: https://espressif.github.io/arduino-esp32/package_esp32_index.json. Für mehrere Adressen klickst du auf das Symbol neben dem Feld und schreibst jede URL in eine eigene Zeile.
2. Klicke auf OK, öffne die Board-Verwaltung und gib esp32 ins Suchfeld ein.
3. Suche esp32 by Espressif Systems und klicke auf Installieren. Das Paket ist mehrere hundert Megabyte groß, bei langsamer Verbindung kann der Download einige Minuten dauern. Das ebenfalls angezeigte Paket Arduino ESP32 Boards ist nur für den Arduino Nano ESP32 gedacht; für gewöhnliche ESP32-Boards installierst du das Paket von Espressif.
4. Wähle als Board ESP32 Dev Module und den Port deines Boards. Weil die meisten ESP32-DevKits einen CP2102- oder CH340-Chip haben, zeigt die IDE das Board als unbekannt an; das ist normal.
5. Lade den Test-Sketch unten hoch und stelle den seriellen Monitor auf 115200 Baud. Läuft in der Ausgabe Connecting.... immer weiter, halte die Taste BOOT auf dem Board gedrückt und lass sie los, sobald die Upload-Prozentwerte durchlaufen.

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}

Zeigt der serielle Monitor das Chipmodell, die Zahl der Kerne, die CPU-Frequenz von 240 MHz und die Flash-Größe von meist 4 MB, ist dein ESP32 einsatzbereit; hat dein Board eine eingebaute LED an GPIO 2, blinkt sie zusätzlich im Halbsekundentakt. Die Pins des ESP32, die WLAN-Verbindung und ein erstes Projekt mit Handysteuerung behandeln wir im Artikel Was ist der ESP32?

Das Raspberry-Pi-Pico-Board-Paket hinzufügen

1. Füge in den Einstellungen unter Zusätzliche Boardverwalter-URLs unterhalb der ESP32-Adresse eine eigene Zeile hinzu: https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json.
2. Suche in der Board-Verwaltung nach pico und installiere das Paket Raspberry Pi Pico/RP2040/RP2350 von Earle F. Philhower. Dieses Community-Paket unterstützt Pico, Pico W, Pico 2 und Pico 2 W und funktioniert mit den meisten Arduino-Bibliotheken.
3. Wähle als Board Raspberry Pi Pico oder das Modell, das du tatsächlich hast (Pico W, Pico 2).
4. Halte für den ersten Upload die Taste BOOTSEL auf dem Pico gedrückt, während du das USB-Kabel einsteckst, und lass sie dann los. Der Pico erscheint am Computer als Laufwerk RPI-RP2 (beim Pico 2 RP2350), und in der Portliste taucht UF2 Board auf; wähle diesen Port und klicke auf Hochladen.
5. Sobald der Code läuft, öffnet der Pico einen normalen seriellen Port. Wähle diesen neuen Port in der Liste; bei späteren Uploads brauchst du BOOTSEL nicht mehr, weil die IDE das Board selbst neu startet.

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}

Willst du den Pico mit MicroPython programmieren, nimmst du statt der Arduino IDE das Programm Thonny; die Unterschiede beider Wege und die MicroPython-Installation findest du im Artikel Was ist der Raspberry Pi Pico? Denk daran: Ein Upload aus der Arduino IDE löscht MicroPython vom Board. Willst du zurück, spielst du einfach die MicroPython-UF2-Datei per BOOTSEL wieder auf.

Einstellungen: Sprache, Schriftgröße und weitere Optionen

Das Einstellungsfenster öffnest du über Datei > Einstellungen (unter macOS im App-Menü Arduino IDE) oder mit Strg+,. Um die Oberfläche auf Deutsch umzustellen, wählst du in der Liste Language (Sprache) Deutsch und klickst auf OK; nach einem kurzen Neuladen startet die IDE mit deutschen Menüs. Fehlermeldungen des Compilers bleiben englisch. Für Einsteiger sind diese Einstellungen am nützlichsten:

Arduino Cloud Editor: im Browser programmieren, ohne etwas zu installieren

Kannst du auf deinem Computer keine Programme installieren (Schulrechner, Chromebook oder Laptop ohne Administratorrechte), ist der Arduino Cloud Editor eine gute Alternative. Du meldest dich unter app.arduino.cc mit einem kostenlosen Arduino-Konto an und legst im Bereich Sketches einen neuen Sketch an; dein Code wird in der Cloud gespeichert und öffnet sich auf jedem Computer gleich. Unter Windows, macOS und Linux installierst du einmalig ein kleines Hintergrundprogramm, den Arduino Cloud Agent, um per USB auf ein Board hochzuladen. Auf einem Chromebook nutzt du statt des Agents den Browser oder die App Arduino Cloud for Chromebook, dort werden aber nur der Uno R3, der Uno R4 und einige weitere offizielle Arduino-Boards unterstützt. Du kannst beide Werkzeuge auch kombinieren: Meldest du dich in der IDE 2 mit deinem Arduino-Konto an, sehen die IDE zu Hause und der Cloud Editor in der Schule über das Cloud Sketchbook dieselben Sketches.

Häufige Probleme bei der Installation und ihre Lösungen

Installation fertig: Wie geht es weiter?

• Grundlagen festigen: Wie Board, Pins und Programmierung zusammenspielen, erfährst du in Was ist Arduino?; die wichtigsten Befehle zeigt der Leitfaden Arduino-Befehle.
• Erste Schaltung bauen: Lass statt der eingebauten LED eine LED mit Widerstand auf dem Breadboard blinken; den passenden Widerstand findest du mit dem LED-Vorwiderstandsrechner, die Lage der Pins im Werkzeug Pinout.
• Ohne Board ausprobieren: Hast du noch kein Board, simuliere im Browser mit Tinkercad oder Wokwi.
• Fehler beheben lernen: Bei roten Meldungen helfen die Anleitungen zu Upload-Fehlern und Kompilierfehlern.
• Drahtlos werden: Hast du das ESP32-Paket installiert, baue mit Was ist der ESP32? dein erstes WLAN-Projekt.
• Das richtige Board wählen: Hast du noch kein Board gekauft, wirf einen Blick auf Welchen Arduino soll ich kaufen? und Arduino-Starterkit.

Ist die Arduino IDE einmal richtig eingerichtet, läuft sie jahrelang problemlos; bekommst du ein neues Board, installierst du nur sein Paket in der Board-Verwaltung und wählst Board und Port richtig aus. Wenn Blink läuft, bist du startklar: In der BlueGrays-App findest du Dutzende Projekte für Arduino, ESP32 und Raspberry Pi Pico, von blinkenden LEDs und Ampeln bis zu Abstandssensoren und WLAN-Projekten, jeweils mit Schaltplan, Teileliste und Schritt für Schritt erklärtem Code, den du sofort in deiner frisch installierten IDE ausprobieren kannst.