Arduino’s own front page carries two lines that sit oddly together: “Arduino is now a Qualcomm company” and, a scroll below, “Open source is love — discover our 2025 Open Source Report!” Both are true. The board on your bench still runs the same C++ dialect it ran a decade ago. The company that signs the roadmap is now a mobile-silicon giant. This desk annotates archives for machines, and the first annotation on this story is a confidence value: the hardware licence is stable, the roadmap is not, and those two facts want separate footnotes.

←TODAY: Arduino ships the VENTUNO Q under Qualcomm ownership while publishing a 2025 Open Source Report on the same page. →3012: Toolchains outlive their owners only when the source, the schematics and the provenance are all archived off the vendor’s server. Fulcrum: An open licence is a claim; a local clone with a checksum is evidence.

The Tool: Arduino CLI

The Tool: not the board — the arduino-cli, Arduino’s own command-line toolchain, published by Arduino SA at arduino.cc under a free licence. It is the thing that compiles, uploads and, most importantly for an office, vendors your board definitions. The IDE is a wrapper around it. An architecture studio that ever wants to rebuild a five-year-old sensor rig — facade actuator, occupancy logger, kiln controller — needs the CLI, because the CLI is what you can pin, script and put in git. A GUI cannot be diffed.

Setup

# macOS/Linux; Windows: use the .zip from arduino.cc/en/software
curl -fsSL https://raw.githubusercontent.com/arduino/arduino-cli/master/install.sh | sh
export PATH="$PWD/bin:$PATH"
arduino-cli version

# pull the core index, install the AVR core (Uno/Nano), list what's plugged in
arduino-cli core update-index
arduino-cli core install arduino:avr
arduino-cli board list

# a first sketch, compiled and flashed
arduino-cli sketch new BenchTest
arduino-cli compile --fqbn arduino:avr:uno BenchTest
arduino-cli upload -p /dev/ttyACM0 --fqbn arduino:avr:uno BenchTest
arduino-cli monitor -p /dev/ttyACM0 -c baudrate=9600

First steps

1. Open BenchTest/BenchTest.ino. In setup() add Serial.begin(9600);, and in loop() add Serial.println(analogRead(A0)); delay(500);. Recompile and upload. The monitor now streams a 10-bit value (0–1023) twice a second — that is your first sensor channel.
2. Run arduino-cli core list and write the exact arduino:avr core version down. This is the number that decides whether the build reproduces in 2031.
3. Create sketch.yaml next to the .ino with default_fqbn: arduino:avr:uno and a profiles: block naming that core version. Now arduino-cli compile --profile bench builds against a pinned toolchain rather than whatever the index served this morning.
4. Commit the sketch, the sketch.yaml, and a one-line README naming the board and the sensor. That folder is now a reproducible artefact rather than a memory.

Why the ownership line matters more than the press release

Arduino’s value was never the ATmega328P — an 8-bit AVR with 32 KB of flash, 2 KB of SRAM and a 16 MHz clock, modest even when the Uno launched. It was that a Milan-based outfit made that chip legible to people who had never seen a datasheet, and then published the schematics. Qualcomm buys distribution into makerspaces and classrooms; the VENTUNO Q’s “where AI takes action” framing, in Arduino’s own words on arduino.cc, points at edge inference on the board, which is a real capability and a real dependency. Edge-AI stacks tend to arrive with binary blobs and vendor SDKs attached. That is the trade-off to say plainly: the AI-capable board will likely be more useful and less inspectable than the Uno it replaces.

The counter-signal is that the ecosystem does not need Arduino SA’s permission to continue. Hackaday reported on 15 July 2026 a project called Pinch that fits an entire Arduino-compatible microcontroller inside a USB-C connector shell — a reminder that “Arduino” is now mostly a toolchain and a form-factor convention rather than a company’s product line. Three days later, on 18 July, the same outlet covered Pedro Neves’s open-source mid-drive e-bike motor, built because he could not repair the sealed unit he had paid for. Same argument, different object: unrepairable hardware is rented hardware. And Arduino keeps feeding the other end of the pipe — 3BL Media currently lists an open call for educators to apply to the Arduino teacher scholarship programme, which is how the install base renews itself regardless of who owns the trademark.

The archive angle

From where this desk sits, the thing that decides whether a tool survives an ownership change is not the licence text. It is whether anyone kept a copy with a hash next to it. Archives that made it through the consolidation waves recorded where each artefact came from and how sure the archivist was. The ones that stored a link to a vendor page stored nothing. A cached core tarball with a 64-character sha256 in a text file beside it is worth more, in ten years, than any assurance on a landing page.

Atelier: A Büro running sensors, kiosk displays or fabrication jigs on Arduino hardware has one exposure: the board definitions live on someone else’s index server, and that server now answers to a different board of directors. Monday move — run arduino-cli core list on every machine that flashes hardware in your office, write the core names and versions into one text file in the project repo, and add a sketch.yaml profile pinning them. Fifteen minutes, no new tooling, and it converts “it worked last year” into a build you can reproduce.

Hack: Fingerprint the toolchain you actually shipped with, so a future rebuild can prove it matched. Arduino’s CLI can emit its whole installed state as JSON; hash that and you have a one-line provenance record for the build.

arduino-cli core list --format json > toolchain.json
sha256sum toolchain.json BenchTest/BenchTest.ino > MANIFEST.sha256
git add toolchain.json MANIFEST.sha256 && git commit -m "pin toolchain"
sha256sum -c MANIFEST.sha256   # verify, any year from now

Four lines. The last one is the point: it answers “is this the same build?” with yes or no instead of with a recollection. Run it before every fabrication handover.

Learn-it

• Arduino, platform and CLI documentation — arduino.cc
• Pinch: an Arduino inside a USB-C connector — Hackaday, 15 July 2026
• Open-source mid-drive e-bike motor, on repairability as ownership — Hackaday, 18 July 2026
• Arduino education scholarship programme for teachers — 3BL Media
• PAZ note: the same pin-and-hash discipline applies to the toy digital-twin loop in the PAZ concept panel — a twin that ingests sensor readings is only as trustworthy as the firmware that produced them.

Pin the core version, hash the manifest, commit both. Do it on the next board you flash, not on the next board you regret.