The Short Answer: C++, C, and the Wiring Framework

When makers and engineers ask, what language is Arduino code in, the most accurate answer is C and C++. However, it is not standard, bare-metal C++. Arduino code—officially referred to as a 'sketch'—is written using a simplified abstraction layer known as the Wiring framework. This framework wraps complex microcontroller registers and hardware timers into accessible, human-readable functions like digitalWrite() and analogRead().

Under the hood, the Arduino IDE utilizes the GNU Compiler Collection (GCC) to translate your sketch into machine code. For classic AVR boards like the Uno R3, it uses the avr-g++ toolchain. For modern ARM-based boards like the Uno R4 Minima ($27.50), it relies on the arm-none-eabi-g++ toolchain.

Expert Insight: While the Arduino language reference looks like its own distinct syntax, it is fundamentally C++14 (or newer, depending on the core). You can use advanced C++ features like templates, classes, and the Standard Template Library (STL) directly inside your .ino files.

Under the Hood: Compilation Walkthrough

To truly understand what language Arduino code is in, you must understand how the Arduino IDE preprocesses your sketch before compilation. When you click 'Upload', the IDE performs a specific sequence of transformations.

Step-by-Step Compilation Process

  1. File Concatenation: If your project has multiple .ino tabs, the IDE concatenates them into a single file in alphabetical order.
  2. Header Injection: The IDE automatically injects #include <Arduino.h> at the very top of your file. This header pulls in the Wiring API and hardware-specific definitions.
  3. Prototype Generation: The IDE scans your code and automatically generates function prototypes for any custom functions you wrote, placing them at the top of the file. This saves you from manually declaring them, a common requirement in standard C++.
  4. Main Function Generation: Standard C++ requires a main() entry point. Arduino hides this. The IDE wraps your setup() and loop() functions inside a hidden main.cpp file.

The Hidden main.cpp Structure

Here is the exact C++ code the compiler generates behind the scenes to execute your sketch:

#include <Arduino.h>

int main(void) {
    init();       // Initializes hardware, timers, and ADC
    setup();      // Calls your user-defined setup()
    for (;;) {    // Infinite loop
        loop();   // Calls your user-defined loop()
        if (serialEventRun) serialEventRun();
    }
    return 0;
}

For a deeper look at how these hardware abstractions are maintained, you can explore the official Arduino Core API repository on GitHub, which dictates how C++ classes map to physical GPIO pins across different architectures.

Syntax Comparison: Standard C++ vs. Arduino Wiring

Because the Wiring framework abstracts hardware registers, the syntax differs significantly from bare-metal embedded C++. Below is a comparison matrix demonstrating how Arduino simplifies standard ARM/AVR C++ register manipulation.

Operation Standard Bare-Metal C++ (AVR) Arduino C++ (Wiring API)
Set Pin 13 as Output DDRB |= (1 << DDB5); pinMode(13, OUTPUT);
Set Pin 13 HIGH PORTB |= (1 << PORTB5); digitalWrite(13, HIGH);
Read Analog Pin A0 ADC mux config + interrupt handling analogRead(A0);
Delay 1 Second Timer1 OCR setup + ISR loop delay(1000);

The Cost of Abstraction

While digitalWrite(13, HIGH) is highly readable, it requires roughly 40-60 clock cycles to execute due to internal pin-mapping lookups and safety checks. In contrast, direct port manipulation (PORTB |= (1 << 5)) executes in a single clock cycle. For high-frequency signal generation (e.g., bit-banging WS2812B LEDs at 800kHz), advanced developers bypass the Wiring API and write raw C++ register commands.

Memory Management: Where C++ Knowledge is Mandatory

Understanding what language Arduino code is in becomes critical when you hit memory limits. Microcontrollers have strictly partitioned memory: Flash (for storing code) and SRAM (for runtime variables).

The SRAM Overflow Failure Mode

A classic failure mode for beginners is exhausting SRAM. The ATmega328P on the classic Uno has only 2KB of SRAM. If you use standard C++ string literals, they are copied from Flash into SRAM at runtime.

// BAD: Consumes precious SRAM
Serial.println("This is a very long debug message that wastes memory");

// GOOD: The F() macro forces the string to stay in Flash memory
Serial.println(F("This is a very long debug message that wastes memory"));

Using the F() macro is a direct application of the PROGMEM attribute in AVR C++, instructing the GCC linker to keep the string array in program space rather than loading it into the heap.

The Modern Shift: MicroPython on Arduino Hardware

While C++ remains the native language, the ecosystem has evolved. If you are using modern ARM-based boards, Python is now a first-class citizen. The Arduino Nano RP2040 Connect ($22.00) and the **Portenta H7** ($105.00) fully support MicroPython and CircuitPython.

When to Use Python vs. C++

  • Choose C++ (Wiring): When you need deterministic timing, ultra-low power consumption (deep sleep modes), or are writing hardware-level interrupt service routines (ISRs).
  • Choose MicroPython: When you are prototyping IoT dashboards, parsing complex JSON payloads from REST APIs, or utilizing machine learning libraries like TensorFlow Lite Micro where Python wrappers speed up development.

To explore the Python side of microcontroller development, review the official MicroPython documentation, which details how the Python interpreter is cross-compiled to run natively on ARM Cortex-M0+ and M7 architectures.

Common C++ Compilation Errors & Debugging

Because the IDE hides standard C++ structures, error messages can be cryptic. Here is a walkthrough of common GCC errors and how to fix them.

1. 'Expected Unqualified-ID Before Numeric Constant'

Cause: You defined a variable or function with the same name as an Arduino macro. For example, naming a variable abs or PI.

Fix: The Wiring framework uses #define for many constants. Rename your variable to avoid namespace collisions with Arduino.h.

2. 'Undefined Reference to `vtable for...'

Cause: You created a custom C++ class with virtual functions, but forgot to implement one of them, or you forgot to define the destructor.

Fix: Ensure every virtual method declared in your class header (.h) has a corresponding implementation in your source file (.cpp).

Summary: Mastering the Toolchain

So, what language is Arduino code in? It is a highly optimized, hardware-abstracted dialect of C++, compiled via GCC, and increasingly supplemented by Python on 32-bit architectures. By understanding the boundary between the Wiring API and raw C++, you transition from simply copying sketches to engineering robust, memory-efficient embedded systems. Whether you are manipulating ATmega registers directly or leveraging the STL on an Arduino Portenta, the underlying power of C++ is always at your fingertips.

For a complete syntax breakdown of the native functions, always keep the official Arduino Language Reference bookmarked as your primary development companion.