ArduinoMania

By Marcello Majonchi, Chief Product Officer at Arduino

Sitting on my desk I have two boards. They carry the same logo, have a somewhat similar name. Their technology could not be more different, and yet the philosophy behind them is exactly the same.

On the left I have an early Arduino^® UNO Rev3, featuring a Microchip ATmega328P, a fingernail-sized piece of silicon dating back the 2000s, that powered the original Arduino revolution. On the right sits the Arduino^® VENTUNO Q, running a Qualcomm Dragonwing IQ-8 chipset with eight-core CPU and an NPU able to go up to 40 dense TOPS, making it the most capable AI-focused Arduino boards to date.

Both are Arduino. Both share the same pin headers. In just a few steps, you can blink an LED on one, or on the other deploy an 8-billion parameter LLM, then ask it how to program the original board to blink an LED.

Crazy how technology has evolved in the last 20 years, but naturally the obvious question is by how much exactly?

Well, you already know the answer from the headline, but getting to the real figure reveals a common pitfall in how performance specifications are presented and offers a better way to evaluate any performance claim.

The problem with specs

The Dragonwing chipset (IQ-8275) on VENTUNO Q carries a headline specification of 40 dense TOPS, representing forty trillion dense operations per second.

The 2009 ATmega328P is, on the other hand, the workhorse of the embedded electronics world: a single 8-bit AVR RISC core clocked at 20Mhz, known for its long-standing use in embedded applications, straightforward architecture, and broad accessibility.

The ATmega has no performance metric on its datasheet because nobody was tracking this type of stuff back then. But, if you estimate its compute ceiling manually, you land at roughly 8 million operations per second.

Divide 40 trillion by 8 million and you get 5 million. Case closed?

Not quite. That simple division hides a common trap in how performance numbers are interpreted: operations aren’t created equal.

Computers do math in different formats: think of them as different currencies. Small integer formats (often used for basic pixel brightness) require relatively few computational resources. High-precision floating-point decimals (often used for physics or navigation) typically require more computational resources. As a result, a chip optimized to blast through basic integers can look ordinary when forced to handle complex decimals.

Marketing materials for AI hardware usually quote the small-integer format, INT8 or INT16. Comparing those figures with an ATmega328P estimate derived from general-purpose clock cycles is similar to comparing different currencies without applying an exchange rate. The resulting number may appear dramatic, but it does not provide a meaningful like-for-like comparison.

So here’s Rule #1 of meaningful performance comparisons: both sides must be measured using the same “currency.”

Designing a fair race

To run a meaningful comparison, both chips should perform the same operation on the same data and produce equivalent results.

A representative workload for this operation is the mathematical backbone of modern machine learning: multiplying two numbers, adding the result to a running total. It’s called multiply-accumulate or, colloquially, MAC.

Repeat this loop millions (or trillions) of times, and you can get to things such as Image Classification (aka deciding whether a photo contains a dog, a car, or a birthday cake), Voice Recognition (aka continuously looking for a specific wake word while filtering out background noise) or even funkier stuff like Autonomous Navigation (aka evaluating sensor data in real time to distinguish a wall from a person).

These tasks are all the same underlying math, an aggregation of MAC operations, just at different scales, making them a useful ruler.

The actual benchmark

Let’s go for image classification to keep things simple.

We’ll need test images to be fed into both systems, originated as standard digital photos cropped and resized to a uniform resolution of 224 × 224 pixels across three RGB color channels. This preprocessing converts each photograph into an input data array (aka a tensor) containing 150,528 individual pixel values (224 times 224 times 3). The image data is formatted as 8-bit quantized integers (INT8), mapping every color value to a whole number between 0 and 255 to match the low-precision integer format required by modern hardware.

Evaluating one photo requires streaming this tensor through a vision model containing roughly 100 megabytes of stored parameters, generating a workload of 8 billion total operations (4 billion MAC steps). VENTUNO Q is designed to process roughly 5,000 photos every second; at that rate, the system could sort an entire photo archive (or just a fancy meal worth of pictures of a millennial) in a single heartbeat. Under the same benchmark assumptions, the original UNO Rev3 would take about 17 minutes to analyze the same photo, so think twice before taking a pic of that tiramisu.

To process the 5,000 photos that VENTUNO Q is built to handle in one second, UNO Rev3 would need approximately 58 days at the benchmarked throughput rate. If you started on January 1st, it wouldn’t finish until late February.

Within the context of this benchmark, the performance difference remains on the order of five million to one.

Why this is actually all meaningless

Here’s the catch: UNO Rev3 cannot practically execute this benchmark workload because the model exceeds the device’s available memory resources.

An AI vision model requires roughly 100 megabytes of memory to store its parameters. The ATmega328P has 32 kilobytes of flash memory and 2 kilobyte of RAM, which is insufficient to store the model.

The “58-day” metric just assumes the infinite external memory attached. It’s a mere thought exercise, but there is something even more relevant.

The gap between 2008 and today isn’t just that the old chip is slow. It’s that an entire category of work moved from impractical on earlier hardware to routinely achievable on modern AI platforms. No amount of patience can stretch 8 kilobytes of memory into 100 megabytes.

Real technological leaps rarely feel like “the same thing, faster.” They manifest as entirely new categories of capabilities opening up for the first time.

What does really matter

While this thought exercise suggests a five-million-fold difference in arithmetic capability, the significance of VENTUNO Q extends beyond raw compute performance.

One of the platform’s key contributions is helping make edge intelligence more accessible by lowering barriers to experimentation and development. The goal is to make it easier for developers to move from exploring AI software to building physical AI systems.

Whether toggling a GPIO pin on an 8-bit ATmega or deploying a computer vision model on a modern NPU, both boards are built around a similar development philosophy: connect the hardware, open an accessible development environment, and begin building.

That emphasis on developer accessibility is what matters most. Despite substantial differences in compute capability, both boards are designed to provide an approachable path into hardware development and experimentation.

Preserving accessibility while dramatically expanding compute capabilities represents a significant engineering achievement. For me, that is the real story. Making AI technologies more accessible helps more people move from using AI tools to building AI-enabled applications of their own.

Qualcomm branded products are products of Qualcomm Technologies, Inc. and/or its subsidiaries. Arduino, UNO, and VENTUNO, and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.

The post Five million to one: two Arduino boards, 20 years apart appeared first on Arduino Blog.