Arduino exit status 1 Error: How to Fix Compilation Errors

The Arduino exit status 1 error is a generic message telling you that your code could not be compiled, meaning the compiler could not turn your program into machine code the processor understands; the actual cause is never on this line. The cause is in the first line containing the word error: a few lines above it in the output panel: you mistyped a name, forgot a semicolon, a library isn't installed, or the code was written for a different board. The Compilation error: exit status 1 notification at the bottom right of Arduino IDE 2 and the Error compiling for board Arduino Uno. line in the old 1.8 version mean exactly the same thing.

In this guide you'll first see how compiling works behind the scenes and how to read an error message by splitting it into file, line and column. Then we'll go through the most common compilation errors one by one: was not declared in this scope, expected ';' before, No such file or directory, does not name a type, redefinition of and Sketch too big. For each one you'll find the situation that causes it, the real message the compiler prints, and a corrected example that compiles without errors. We've also added errors caused by choosing the wrong board, issues specific to the ESP32 and Raspberry Pi Pico, and an error-and-fix table at the end that puts everything together. If your code compiles fine but won't go onto the board, the problem is at a different stage; for that, see the Arduino Not Uploading guide.

What is Arduino exit status 1? Compiling vs uploading

When you press Verify (the tick) or Upload, the Arduino IDE runs several programs in the background. First it merges the .ino files in the sketch folder and turns them into an ordinary C++ file by adding the Arduino.h header and prototypes for your functions at the top. Then a compiler such as avr-g++ for the Uno or xtensa-esp32-elf-g++ for the ESP32 compiles that file and the libraries you use, the linker joins all the pieces into one program, and finally the IDE checks whether the program fits on the board. Every program returns an exit code when it finishes: 0 means success and 1 means failure. "exit status 1" says exactly that: one of the programs in the chain failed. That's why the same phrase also appears when avrdude fails during an upload; the message in front of it tells you which one it is.

How to read an Arduino error message

Every error line from the compiler follows the same pattern: first the file name, then the line and column numbers separated by colons, followed by the type of error and its description. Just above it there's often a line such as In function 'void loop()': that tells you which function the error is in; below it there's a copy of the faulty line and a small ^ marker pointing at the problem. error is a real error that stops compilation, warning is only a warning and the code still compiles, and note adds information to the previous message. The compiler often adds a suggestion too: in the example below it shows the correct spelling itself with suggested alternative: 'digitalWrite'.

1. In File > Preferences, tick compile next to Show verbose output during. That way you'll also see which files and which library folders the compiler used.
2. The board doesn't need to be plugged in: press the Verify button (the tick). Verify only compiles; if the error is in the compile stage, pressing Upload just wastes time.
3. Scroll the output panel to the top and find the first line containing error:. Most of the errors after it are knock-on effects of that first one.
4. Go to the line number in the message. IDE 2 underlines the character with the error in red, while version 1.8 colours the whole line red. If you can't see a problem on that line, look at the line above.
5. Fix only that first error and press Verify again. If the number of errors suddenly drops, you're on the right track.
6. If you search online, strip your own variable names and file paths from the message: searching for was not declared in this scope instead of 'counter' was not declared in this scope brings far more results. When you ask for help on a forum, on the other hand, copy the whole output.

The 'was not declared in this scope' error and how to fix it

This message means the compiler doesn't recognise a name you used at that point. The most common cause is a typo: Arduino is case-sensitive, so digitalwrite, Digitalwrite and digitalWrite are three different names. The second big cause is scope: if you declare a variable inside setup(), it only lives while setup() runs and loop() can't see it. If you'll use a variable in more than one function, declare it outside all functions at the top of the file. Declaring a variable after the line where you use it gives the same error, because the compiler reads the file from top to bottom. Finally, this error also appears when you use an object whose library you haven't included (Wire, Servo) or a feature the selected board doesn't have (Serial1 on the Uno).

1// Kapsam (scope) örneği / Scope example
2const int LED_PIN = 13;   // global: her fonksiyon görür / global: every function can see it
3int yanmaSayisi = 0;      // setup() içine taşırsan loop() göremez / move it into setup() and loop() can't see it
4
5void setup() {
6  pinMode(LED_PIN, OUTPUT);
7  Serial.begin(9600);
8}
9
10void loop() {
11  int sure = 500;                // yerel: yalnız loop() içinde / local: only inside loop()
12  digitalWrite(LED_PIN, HIGH);   // digitalwrite yazarsan: was not declared / typing digitalwrite: was not declared
13  delay(sure);
14  digitalWrite(LED_PIN, LOW);
15  delay(sure);
16  yanmaSayisi++;
17  Serial.println(yanmaSayisi);   // kaç kez yandı / how many times it blinked
18}

'expected ';' before' and other syntax errors

In C++ every statement ends with a semicolon. When you forget the semicolon at the end of a line, the compiler only notices when it reads the next word. That's why, with the Uno's compiler, the line number in expected ';' before 'delay' points to the line below the mistake: the missing semicolon is at the end of the line before delay. The newer compilers in the ESP32 and Pico cores point straight to the end of the line where the semicolon is missing. If you forget it on the last line of a function, the message becomes expected ';' before '}' token. Bracket errors behave in a similar way. If you forget to close the curly brace of an if block or a function, the compiler reads on to the end of the file and only then says expected '}' at end of input. If the unclosed brace is inside setup(), you also get a function-definition is not allowed here before '{' token, because to the compiler loop() is now a function you're trying to define inside setup(). Using commas instead of semicolons inside the brackets of a for loop is another classic in this family.

'No such file or directory': library not found

The lines fatal error: DHT.h: No such file or directory and the compilation terminated. that follows say that the file requested by an #include line in your code couldn't be found on your computer. The word "fatal" means compilation stopped completely at that point, so you won't see errors in the rest of your code until you fix this one. The cause is almost always a library that isn't installed. When you open a project from the internet, read the #include lines at the top one by one and install the library for each from Tools > Manage Libraries. If you don't choose Install All in the window that asks about dependencies, the main library gets installed but the second library it needs stays missing; in that case the file name in the message isn't one you wrote but a file called from inside the library (for example Adafruit_Sensor.h). Upper and lower case in the file name matter too: on Linux dht.h and DHT.h are different files. For the three ways to install a library and ZIP problems, see the How to Install an Arduino Library guide.

The 'does not name a type' error

does not name a type means the compiler expected a data type (such as int, float, Servo or LiquidCrystal_I2C) at the start of a line but didn't recognise the word you wrote. There are three common causes. The first is forgetting the library's #include line: if Servo lid; is compiled without Servo.h, you get 'Servo' does not name a type. The second is misspelling the type: String is correct, not string, and int, not Int, and the compiler often helps with did you mean 'String'?. The third, and the most surprising, is writing a command outside a function. Outside functions you can only declare things: int angle = 0; is valid, but if you write angle = 90; on its own on a later line, the compiler takes angle for a type name and reports 'angle' does not name a type. There's one more Arduino-specific trap: the IDE automatically adds prototypes of your functions just before the first function. If you wrote a function that returns your own struct type and declared the struct below setup(), the prototype ends up before the struct and you get the same error. The fix is to move struct definitions to the top of the file, before the first function.

1#include <Servo.h>   // bu satır yoksa: 'Servo' does not name a type / without it: 'Servo' does not name a type
2
3struct Olcum {       // struct'ı ilk fonksiyondan önce tanımla / define structs before the first function
4  int ham;
5  float volt;
6};
7
8Servo kapak;         // tür adı büyük harfle başlar / the type name starts with a capital letter
9int aci = 0;         // dışarıda tanım ve ilk değer serbest / declaring with a value outside is fine
10// aci = 90;         // dışarıda tek başına atama: 'aci' does not name a type / bare assignment outside: error
11
12Olcum potOku() {
13  Olcum o;
14  o.ham = analogRead(A0);           // potansiyometre A0'da / potentiometer on A0
15  o.volt = o.ham * 5.0 / 1023.0;    // 0-1023 değerini volta çevir / convert 0-1023 to volts
16  return o;
17}
18
19void setup() {
20  Serial.begin(9600);
21  kapak.attach(9);   // servo sinyali D9 / servo signal on D9
22}
23
24void loop() {
25  Olcum o = potOku();
26  aci = map(o.ham, 0, 1023, 0, 180);   // atama fonksiyonun içinde / assignment inside a function
27  kapak.write(aci);
28  Serial.println(o.volt);
29  delay(20);
30}

The 'redefinition of' error: defining the same thing twice

The redefinition of 'void setup()' error says there are two definitions with the same name; the note: 'void setup()' previously defined here line right below it shows where the first one is. For beginners the most common cause is pasting two example sketches one after the other into a single file: you end up with two setup() and two loop() functions. The second cause is tabs. Before compiling, the Arduino IDE merges all .ino files in the sketch folder into one. An old backup you copied into the folder (for example project_old.ino) or a second tab with its own setup() and loop() causes this error even if you never open that tab; the fix is to move that file out of the folder. Declaring the same variable twice produces a similar message: redefinition of 'int led'. This error's sibling in the linker is multiple definition of; it appears when a variable given a value in a header (.h) file is included in two separate .cpp files. Its opposite, undefined reference to, points to a function whose prototype you wrote but whose body you never wrote, or whose name you spelt differently.

1// İki örneği birleştirmek: tek setup(), tek loop() / Merging two sketches: one setup(), one loop()
2const int LED_PIN = 13;          // 1. örnek: Blink / sketch 1: Blink
3const int POT_PIN = A0;          // 2. örnek: potansiyometre / sketch 2: potentiometer
4unsigned long oncekiZaman = 0;   // millis() zamanlayıcısı / millis() timer
5bool ledDurum = false;
6
7void setup() {
8  pinMode(LED_PIN, OUTPUT);      // 1. örneğin setup içeriği / setup body of sketch 1
9  Serial.begin(9600);            // 2. örneğin setup içeriği / setup body of sketch 2
10}
11
12void loop() {
13  // 1. örnek: delay yerine millis ile yanıp sönme / sketch 1: blink with millis instead of delay
14  if (millis() - oncekiZaman >= 500) {
15    oncekiZaman = millis();
16    ledDurum = !ledDurum;
17    digitalWrite(LED_PIN, ledDurum);
18  }
19  // 2. örnek: potansiyometreyi oku ve yaz / sketch 2: read and print the potentiometer
20  int deger = analogRead(POT_PIN);   // 0-1023 arası / between 0 and 1023
21  Serial.println(deger);
22  delay(50);
23}

Follow this order when merging: first gather the #include lines from both sketches at the top without duplicates, then add the global variables and constants; if the same name exists in both, rename one of them. Next, put the contents of both setup() functions into a single setup() and the contents of both loop() functions into a single loop(). If one of the sketches uses a long delay(), it holds the other one up; you can solve that with the millis() instead of delay() timing technique. Finally, check whether the two sketches use the same pin: the compiler won't notice, but your circuit won't work as expected.

'Sketch too big' and not enough memory errors

At the end of every successful compile you'll see two lines. When you compile the scope example above for the Uno, the line Sketch uses 2212 bytes (6%) of program storage space. Maximum is 32256 bytes. tells you how much flash memory the program takes, and Global variables use 190 bytes (9%) of dynamic memory tells you how much of the RAM the global variables use. If the program doesn't fit in flash, it goes over 100 percent, followed by the Sketch too big warning and the text section exceeds available space in board error. If the global variables don't fit in RAM, you'll see Not enough memory and data section exceeds available space in board instead. When RAM usage goes over 75 percent, the IDE may print the warning Low memory available, stability problems may occur.: the code compiles, but because there's no room left for local variables while it runs, the board can freeze at random or restart by itself. On the Uno the bootloader uses 0.5 KB of the 32 KB flash, which is why the limit is 32256 bytes.

1// RAM tasarrufu: F() ve PROGMEM / Saving RAM: F() and PROGMEM
2const char mesaj[] PROGMEM = "Bu uzun metin RAM yerine flasta durur";   // flaşta saklanır / stored in flash
3const byte notalar[] PROGMEM = {60, 62, 64, 65, 67, 69, 71, 72};      // byte: int'in yarısı / byte: half of an int
4
5void setup() {
6  Serial.begin(9600);
7  Serial.println(F("Merhaba! Bu metin de flastan okunur"));   // F(): RAM harcamaz / F(): uses no RAM
8  char tampon[48];                                            // geçici RAM tamponu / temporary RAM buffer
9  strcpy_P(tampon, mesaj);                                    // flaştan RAM'e kopyala / copy from flash to RAM
10  Serial.println(tampon);
11  for (byte i = 0; i < sizeof(notalar); i++) {
12    Serial.print(pgm_read_byte(&notalar[i]));                 // flaştan bir bayt oku / read one byte from flash
13    Serial.print(' ');
14  }
15  Serial.println();
16}
17
18void loop() {
19}

• Wrap fixed text in F(): Serial.println(F("System ready")); reads the text straight from flash without copying it into RAM. The same goes for fixed text you print on LCD and OLED displays.
• Move large arrays to PROGMEM: If note tables, display bitmaps and long texts never change, they don't need to sit in RAM. For more detailed techniques, see the Arduino out of memory article.
• Choose the right data type: For a value between 0 and 255, byte (1 byte) is enough; on the Uno an int takes 2 bytes, while long and float take 4.
• Cut down on the String class: String objects that are constantly joined together fragment the RAM; fixed-length char arrays are more predictable.
• Know the hidden needs of display libraries: Adafruit SSD1306 allocates a 1 KB buffer at run time for a 128×64 OLED display. This memory doesn't show up in the compile report, so the display may fail to start even when the report says 70 percent.
• Move to a bigger board: A project you can't squeeze onto the Uno runs comfortably on the Mega or the ESP32. On the ESP32 you can raise the program area from 1.25 MB to 3 MB by choosing Huge APP (3MB No OTA/1MB SPIFFS) under Tools > Partition Scheme; with this option over-the-air updates (OTA) aren't available.

Errors caused by choosing the wrong board

The compiler always compiles your code for the processor of the board selected under Tools > Board (in IDE 2, in the board selector at the top). The same code can compile cleanly for the Mega and fail with the Uno selected, because every board has different hardware, pin names and libraries that come with its board package. When you open a project you found online, first check which board it was written for: code written for the ESP32 won't compile with the Uno selected, and code written for the Uno that accesses the processor's registers directly won't compile with the ESP32 selected. If you can't see your board in the list at all, its board package isn't installed; you need to install the ESP32 and Raspberry Pi Pico packages from the Boards Manager. For the steps, see the How to Install the Arduino IDE guide.

Compilation errors on the ESP32

The ESP32 is also programmed in the Arduino language, but because its compiler and board package are different, code that compiles cleanly on the Uno can get stuck on the ESP32. The most common reason is the core version: in version 3.x of the ESP32 Arduino core the PWM functions changed; ledcSetup() and ledcAttachPin() were removed and replaced by ledcAttach() and ledcWrite(), which work with the pin number instead of a channel number. That's why older examples online give 'ledcSetup' was not declared in this scope; either convert the code to the new functions or install version 2.0.17 from the Boards Manager. The second difference is the compiler settings. The Uno's core compiles code with the -fpermissive option, which turns some errors into mere warnings; the ESP32 doesn't use it. For example, declaring a variable inside a switch without curly braces compiles on the Uno but gives a jump to case label error on the ESP32. Current ESP32 cores also compile with -Werror=return-type: if you forget the return in a function that must return a value, you get no return statement in function returning non-void whenever Compiler warnings is set to anything other than None. In version 2.x, setting Compiler warnings to More or All turns most warnings into errors. For the board's basic setup, take a look at the What is the ESP32 article.

1// ESP32 Arduino paketi 3.x / ESP32 Arduino core 3.x
2const int LED_PIN = 2;        // birçok DevKit kartında dahili LED / onboard LED on many DevKit boards
3const int FREKANS = 5000;     // PWM frekansı 5 kHz / PWM frequency 5 kHz
4const int COZUNURLUK = 8;     // 8 bit: 0-255 arası / 8 bits: range 0-255
5
6int parlaklik(int adim) {
7  return (adim % 32) * 8;     // return unutulursa 3.x'te derleme hatası olabilir / a missing return can fail to compile on 3.x
8}
9
10void setup() {
11  Serial.begin(115200);
12  // eski 2.x kodu / old 2.x code: ledcSetup(0, FREKANS, COZUNURLUK); ledcAttachPin(LED_PIN, 0);
13  ledcAttach(LED_PIN, FREKANS, COZUNURLUK);   // 3.x: kanal otomatik seçilir / channel is picked automatically
14}
15
16void loop() {
17  for (int adim = 0; adim < 32; adim++) {
18    ledcWrite(LED_PIN, parlaklik(adim));      // 3.x: pin numarasıyla yaz / write using the pin number
19    delay(30);
20  }
21  if (Serial.available()) {
22    switch (Serial.read()) {
23      case 'h': {                             // case içinde değişken varsa süslü parantez şart / braces needed if a case declares a variable
24        int deger = ledcRead(LED_PIN);
25        Serial.println(deger);
26        break;
27      }
28      default:
29        break;
30    }
31  }
32}

Raspberry Pi Pico: Arduino IDE and MicroPython errors

If you program the Pico with the Arduino IDE, that is with Earle Philhower's arduino-pico core, the compiler is still GCC and every message in this article applies as is. MicroPython is different: there's no separate compile step beforehand; the Pico turns the file into bytecode when it starts and runs it line by line. That's why errors show up in the Shell pane at the bottom of Thonny, in a message that starts with Traceback (most recent call last):. Read this message from the bottom up: the last line tells you the type of error and its description, and the line 7 part above it tells you which line it's on. Syntax errors (SyntaxError, IndentationError) are reported before the program even starts; other errors only appear when the program reaches that line, so your code may run fine for a while and then stop. For installing MicroPython and the first steps, see the What is the Raspberry Pi Pico article.

1from machine import Pin
2import time
3
4led = Pin("LED", Pin.OUT)     # Pico ve Pico W dahili LED / onboard LED on Pico and Pico W
5sayac = 0
6
7while True:                   # iki nokta unutulursa SyntaxError / a missing colon gives SyntaxError
8    led.toggle()              # blok içinde 4 boşluk girinti / 4-space indent inside the block
9    sayac += 1
10    print("Sayac:", sayac)    # "Sayac: " + sayac yazmak TypeError verir / "Sayac: " + sayac raises TypeError
11    time.sleep(0.5)

Table of Arduino compilation errors and fixes

Next steps for writing error-free code

• Strengthen the basics: The Arduino programming basics article explains variables, scope, functions and loops; most of the errors in this article come from these topics.
• Learn the correct spelling of commands: The Arduino commands list shows the syntax and parameters of every command with examples.
• Install libraries properly: The How to install an Arduino library guide covers the No such file or directory and Multiple libraries were found messages in detail.
• See what your code does while it runs: For code that compiles but doesn't behave as you expect, printing variables with the Serial Monitor is the quickest way to diagnose it.
• Try it without a board: In the Wokwi or Tinkercad simulators you can compile your code and run it together with the circuit.
• Check code written by AI: Code produced by chatbots is often written for old library versions or for a different board; the Arduino code with AI article explains how to catch these problems.

Compilation errors may look scary at first, but the compiler actually tells you where the problem is and often how to fix it: file, line, column and a short description. Read the first error, fix only that one, compile again and repeat the loop; after a few projects you'll find yourself solving errors in seconds. Once your code compiles and uploads, you can carry on with the LED, button, sensor and display projects in the BlueGrays app: every project for Arduino, ESP32 and Raspberry Pi Pico comes with a circuit diagram and code that compiles cleanly, step by step.