Arduino Nano R4 Review: The R4 Generation Finally Arrives in the Nano Form Factor
イチケン / ICHIKEN
The Arduino Nano R4 came out in July 2025 with little fanfare, and the reviewer admits they only found out about it recently. In this video they compare the Nano R4 with the original ATmega328P-based Nano, looking at hardware design, the microcontroller, price, and how to choose between them. They then run an FFT demo that shows how much more the new board can do. The reviewer concludes that the Nano R4 is generally the better board, but asks whether the Nano series is still the right choice now that other inexpensive, high-performance boards are available.
Why a Review Now: The Nano R4's Quiet Release
The reviewer starts with the timeline. The Arduino Uno R4 Minima was released in June 2023, and the Uno R4 WiFi followed shortly after. The R4 generation replaced the microcontroller with a Renesas part, and the large performance jump attracted a lot of attention at launch.
At that time the R4 generation came only in the Uno form factor. Users who wanted to plug an R4 board straight into a breadboard had no way to do so. The Nano R4 finally appeared two years later, in July 2025. The reviewer says they missed the release entirely, came across it by chance, and bought one right away. They point out that its performance and features are nearly identical to the Uno R4 Minima, so it should be good news for anyone who wanted the R4 generation in a smaller package.
Hardware Changes: USB-C and a Surface-Mountable Design
The Nano R4 keeps the basic Nano form factor. For comparison, the reviewer uses a Nano-compatible board that costs about 600 yen, noting that genuine boards are considerably more expensive.
The first change is the USB connector. Both boards connect to a computer over USB, but the old Nano uses Mini-B and the Nano R4 uses USB-C. The reviewer calls this a welcome change, since they often don't have a Mini-B cable on hand.
The pin headers and component layout have also changed. The original Nano uses standard through-hole headers and has components on both sides of the board. The Nano R4 has components on one side only, with nothing on the back, so it can be surface-mounted directly onto another PCB. The reviewer compares this to their DIY keyboard work, where they sometimes solder Raspberry Pi Pico-series boards straight onto the keyboard PCB. The Nano R4 now allows the same approach. They don't expect many people to mass-produce products around a Nano R4, but they think surface-mount support is useful for small production runs and for mounting on a motherboard.
The Microcontroller: ATmega328P vs. Renesas RA4M1
The original Nano uses the ATmega328P, an 8-bit microcontroller running at 16 MHz with 32 KB of flash and 2 KB of RAM. The reviewer expects that many Arduino users have struggled with that small amount of RAM. They describe their own experience with large libraries and array buffers, where they ran out of RAM and had to work hard to shrink their programs.
The Nano R4 uses the same chip as the Uno R4: Renesas's RA4M1, a 32-bit Arm Cortex microcontroller. The reviewer calls it a dramatic improvement over the original Nano. It has a built-in FPU and DSP, so it is fast at calculations, and it has 256 KB of flash and 32 KB of RAM. According to the reviewer, you no longer have to write code with computation time and RAM limits constantly in mind. They find it reassuring to have such a capable microcontroller inside a board this small when building embedded systems.
Price and the Lack of Compatible Clones
Since the Nano R4 is generally the better version of the Nano, the reviewer suggests anyone buying a Nano today should probably choose the R4. Price complicates the decision, though. The original Nano costs 4,200 yen at Akizuki Denshi, while the Nano R4 costs 2,860 yen, so the newer model is oddly the cheaper one. Nano-compatible boards sell on Amazon for about 600 yen each and are often discounted, so buyers have to weigh cost against performance.
The reviewer also notes that R4 clones are much less common than Uno R3 clones were. Some Minima clones exist, but there are almost no Nano R4 clones. They are clear that they don't know the reason and are only guessing: vendors unfamiliar with Renesas parts may not be able to source the microcontroller.
Choosing Between the Nano and Nano R4
The reviewer suggests the original Nano is still adequate when a project has no display, does little AD conversion, and needs little computation. The Nano R4 is the better choice for projects with RAM-hungry displays, frequent AD conversion, or heavy computation.
They briefly mention features they didn't cover in depth: the Nano R4 has a built-in op-amp, analog output through a DAC, and CAN communication support, none of which the older Nano offers.
The Nano R4 is not fully backward-compatible, however. The reviewer warns that I/O pin current is 8 mA on the Nano R4, down from 20 mA on the previous Nano. Relays or LEDs connected directly to the pins may not get enough current, and in some cases an external buffer circuit or driver will be needed.
FFT Demo: How RAM Limits the Sample Count
To show the performance gap, the reviewer runs an FFT on each board and displays the results on a screen, with the Nano on top and the Nano R4 below. The same signal is fed into both boards. Each board converts it with its internal ADC, computes an FFT, and draws the spectrum on an OLED display. When the input frequency changes, both displays respond, so the reviewer notes that both boards can run an FFT correctly. The difference is in how much work each one can handle.
Both boards run nearly the same program, but with different FFT sample counts: 32 on the Nano and 256 on the Nano R4. The reviewer says the Nano's small sample count is mainly due to insufficient RAM and a slow sampling rate, and that fitting more than 32 samples into 2 KB of RAM is difficult.
The compile output shows the problem in detail. With 32 samples, global variables use 639 bytes of the 2,048 available, leaving 1,409 bytes. That looks like enough, but the OLED frame buffer alone takes nearly 1 KB, so the remaining RAM is actually just barely sufficient. Increasing the sample count to 64 still compiles and uploads, but the microcontroller does not run when powered on.
The Nano R4 uses eight times as many samples and still has plenty of RAM left. The sample count directly affects the result. With 32 samples, the Nano's frequency resolution is coarse, and the display shows fewer bars. The Nano R4's 256 samples give much higher resolution, and changing the input frequency makes the difference obvious. The reviewer says the demo shows how much the available RAM limits what a program can do.
Sampling Speed: 8 kHz vs. 20 kHz, and Potentially 100 kHz
Processing speed and ADC speed matter as well. On the Nano, slow AD conversion and slow computation cap the maximum sampling frequency at 8 kHz, so the FFT can only analyze signals up to 4 kHz. The reviewer says the Nano R4's faster processing and sampling allow a sampling frequency of about 20 kHz, and that it can perform FFTs up to 20 kHz, covering the audible range. They describe this as roughly five times better.
The reviewer adds that these figures come from the Arduino IDE's analogRead function, which is quite slow. By writing code that manipulates the Renesas microcontroller's registers directly, they say the sampling frequency could reach about 100 kHz. In their view, this is where the performance gap between the two boards is most obvious.
Conclusion: Is the Nano Series Still the Right Choice?
The reviewer sums up the Nano R4 as a big performance upgrade over the R3-generation Nano. They expect it to be especially welcome for people who wanted the Nano form factor but had to switch to a different microcontroller because the old Nano was too limited.
They end with a caveat. Boards like the Raspberry Pi Pico 2 and Seeed Studio's XIAO series are now widely available and offer high performance at low prices. Given that, the reviewer asks whether you should stay with the Nano series or switch to another microcontroller, and whether you can really cut costs and improve performance at the same time. They suggest thinking it through carefully before deciding.
This video is brought to you by Avnet. Hello. Today, I’m reviewing the Arduino Nano R4. I'm sure you're all wondering why I'm reviewing the Nano R4 now of all times. You might think that, but actually, the Nano R4 was released rather quietly, and I didn't even know this was out until recently.
First, I’ll explain the history of the Nano R4 in chronological order. The Arduino Uno R4 Minima was released in June 2023, and shortly after that, the Uno R4 WiFi was released. As for the R4, the microcontroller has been replaced with a Renesas microcontroller. When it was released, it generated a lot of buzz because its performance had improved significantly. However, at the time, it was only available in this Uno form factor. The Nano was not released. Therefore, the R4 wasn't available in the Nano form factor, so I was unable to plug it directly into a breadboard.
Two years later, in July 2025, the Arduino Nano R4 became available. I, too, had completely missed the release of the Nano R4 until recently, and I just happened to find out that the R4 was out. That’s why I decided to buy it right away. What's more, when it comes to performance and functionality, it's almost identical to the R4 Minima. Isn't this good news for users who were hoping for a smaller design?
So today, I’ll be discussing the differences between the standard Arduino Nano and the Nano R4. I’ll be reviewing these products while highlighting their performance differences. But first, here’s a seminar announcement from today’s sponsor.
Those involved in embedded development: "We can't make the microcontrollers you used to use anymore." What would you do if someone said that to you? Microcontrollers that have been in use for many years, such as Renesas' SH and H8 series, are reaching end-of-life one after another. It's not practical to rebuild the circuit board from scratch, but there's no substitute. One option is to keep the software assets as they are and replace only the hardware with an FPGA. How exactly do you do that? Be sure to check out this seminar.
Also, on the same day at the same venue, we will be holding seminars and demonstration exhibits on what exactly can be achieved with edge AI using the x86 platform, and to what extent. We are running image recognition in real time on an actual industrial PC.
The event will be held on Friday, July 10, 2026, at Akihabara UDX. Free admission; advance registration required. In addition, three lucky visitors will be selected in a raffle to receive AMD's latest SCU35 evaluation board. This is a model that’s hard to come by as an individual. Since seating for the seminar is limited, please pre-register as soon as possible using the link in the description.
Let's take a look at the Nano R4 right away. Basically, it hasn't changed from the Nano's form factor. By the way, the one on the left is an Arduino Nano-compatible board. It costs around 600 yen. The genuine boards are pretty expensive. I'll discuss the price later.
Regarding uploading, you can do both by connecting them to a computer via USB, but whereas the Nano used a Mini-B connector, the Nano R4 now features a USB-C port. To begin with, I often don’t even have a Mini-B cable, so the switch to USB-C is a welcome change.
The specifications for pin headers and component mounting have also changed. The Nano uses standard through-holes, and there are components mounted on the back as well. On the other hand, the Nano R4 features a single-sided through-hole design, and there are no components mounted on the back side at all. Therefore, this board is designed for surface-mount installation onto other printed circuit boards.
For DIY keyboards, I use the Raspberry Pi Pico series microcontroller boards. Sometimes they are surface-mounted directly onto the keyboard circuit board, and the same thing can now be done on the Nano R4. I don't think mass-producing using the Nano R4 board happens very often, but for small-batch production and motherboards, it's great that it's designed for surface-mount installation.
The microcontroller I'm using is an ATmega328P. It is an 8-bit microcontroller. The operating frequency is 16 MHz, with 32 KB of flash memory and 2 KB of RAM. Anyone who has used Arduino will be surprised by how little RAM it has. I think there are probably many people who have suffered because of this. Especially when dealing with large libraries or array buffers, I'd run out of RAM, and there were times when I really struggled to find a way to reduce memory usage.
As for the Nano R4, it includes the same Renesas RA4M1 32-bit Arm Cortex microcontroller as the Uno R4 and others. Compared to the standard Nano, the performance of the microcontroller itself has improved dramatically. Since it has a built-in floating-point unit (FPU) and DSP, it's fast at calculations and has 256 KB of flash memory. With 32 KB of RAM, I no longer need to program while being so mindful of computation time and RAM capacity. Since this tiny Nano device contains a microcontroller with fairly high performance, it provides a great deal of peace of mind when used in embedded systems.
As you can see, the Nano R4 is generally a superior version of the Nano, so if you're planning to buy a Nano now, I think you should probably go with the Nano R4. And then there's the price. The original Nano costs 4,200 yen at Akizuki. The Nano R4 costs 2,860 yen, so for some reason, the newer model is cheaper. Compatible Nano boards are often available on Amazon for about 600 yen each. Given the cost considerations and performance differences, it comes down to which one to choose.
By the way, regarding R4 series compatible devices, there are some Minima clones out there, I suppose, but they're not as common as they were with the Uno R3. In addition, there are virtually no compatible devices for the Nano R4. I don't know the details, so this is just a guess, but perhaps they don't actually sell the microcontrollers themselves to vendors who aren't very familiar with Renesas. That's how it feels.
Regarding how to use them appropriately, when you aren't using a display, there are few instances of A/D conversion in the program, and the computational complexity isn't that high, I think the Nano will be sufficient. On the other hand, when would you use the Nano R4? When using a display that consumes a lot of RAM, performing A/D conversion multiple times within a program, or performing a large number of calculations. In that case, I think the Nano R4 would be the best choice.
Although I’ve left this out of the main feature overview this time, the Nano R4 includes an op-amp, analog output using a D/A converter, and CAN communication. This is how it differs from the previous Nano.
However, not everything is fully backward-compatible, so the only thing to watch out for is that the current on the I/O pin is 8 mA on the Nano R4. Since the current was previously 20 mA, please be careful when connecting relays or LEDs directly, as there may not be enough current. In the case of the Nano R4, there might be times when you must use an external buffer circuit or driver.
Now, let's run a demo that clearly illustrates the performance differences between microcontroller boards. To be specific, we’ll run an FFT and display the results on the screen. This is a test that gives you clear results for differences in performance, such as A/D conversion speed, RAM capacity, and processing speed.
It looks something like this. The one on top is the Nano, and the one on the bottom is the Nano R4. The signal source input is located here, and it is fed into both microcontrollers. We convert that signal from analog to digital, perform an FFT calculation internally, and display the results on the screen. Now let's actually input a signal.
This is what the waveform looks like. When I change the frequency, the waveform looks like this. To be fair, both of them are capable of performing FFTs properly, but actually, the computational load differs significantly between the Nano and the Nano R4.
First of all, the display is different. Both use almost the same program, but depending on the microcontroller board you're using, I'm changing the number of samples used in the FFT. The Nano has 32 samples, while the Nano R4 has 256 samples. The reason there are fewer samples for Nano is mainly insufficient RAM and slow sampling rates. It is difficult to fit more than 32 samples of data into 2 KB of RAM. If we increase the number of samples used in the FFT calculation any further, we exceed the RAM capacity, and it simply won't work anymore.
As shown on this screen, even with 32 samples, out of the maximum 2,048 bytes of RAM, global variables are using 639 bytes, and it says there are 1,409 bytes remaining. It looks like there's still some room to spare. However, since this OLED frame buffer uses nearly 1 KB, the amount of RAM is often just enough. Even if you increase the sample size to 64, it compiles successfully and I can upload it, but the microcontroller does not operate even when powered on. On the other hand, the number of samples for the Nano R4 is set to 256. Although it has eight times the number of samples as Nano, there is still plenty of RAM available.
The number of FFT samples also affects the FFT results. Since the Nano has 32 samples, its frequency resolution is also coarse. You can see that the number of bars that can be displayed has decreased, right? On the other hand, the R4 has 256 samples, so the frequency resolution of the FFT results is also higher. In fact, if you try changing the frequency of the input signal, you can see that there’s a difference of this magnitude. As you can see, the frequency resolution is completely different. It really drives home how much the amount of RAM available affects the size of the program you can create.
The processing speed of the microcontroller itself and the speed of the A/D conversion also play a role. As for the Nano, the A/D conversion speed is slow, and since the internal calculations aren't that fast either, the maximum sampling frequency is 8 kHz. Therefore, the upper frequency limit for signals that can be analyzed using FFT is 4 kHz. Since the Nano R4 has fairly fast processing speeds and sampling rates, the sampling frequency can go up to about 20 kHz. It turns out you can actually perform an FFT all the way up to 20 kHz in the audible range. It performs about five times better.
However, the A/D conversion used here is when using the analogRead function available in the Arduino IDE. This analogRead is quite slow. If you write code that directly manipulates registers for the Renesas microcontroller in the R4, the sampling frequency can be set as high as about 100 kHz. The performance gap between the Nano and Nano R4 microcontrollers is really evident here.
So, today I reviewed the Arduino Nano R4. Compared to the R3-generation Nano, it offers a significant performance boost. If you wanted to use the Nano form factor but had no choice but to use a different microcontroller because of performance limitations, I think the Nano R4 will be a real lifesaver.
On the other hand, there are now many affordable, high-performance microcontrollers available, like the Raspberry Pi Pico 2 and Seeed Studio’s XIAO. Given the current situation, would you still choose the Nano series, or replace it with another microcontroller? Cost reduction and performance improvement—is it really possible to achieve both? It might be best to think it over carefully before making a decision.
So, if you found this video helpful, please give this video a thumbs-up and subscribe to the channel. If you have any questions or concerns, please feel free to leave a comment. Thank you for watching the video all the way to the end.
Article published · Updated