Building a Seven-Node Raspberry Pi CM5 "Mini Supercomputer": How Does It Actually Perform?
イチケン / ICHIKEN
In this video, the creator behind the Ichiken channel tries to build a palm-sized "mini supercomputer" from seven Raspberry Pi Compute Module 5 boards. The goal is to find out how well the cluster performs. The tests include a simple parallel calculation, two standard supercomputer benchmarks, and a comparison of power efficiency against today's leading machines. The speaker's overall view is that the cluster is far from state-of-the-art. Still, it shows respectable parallel scaling and reaches roughly the level of a top supercomputer from about 30 years ago, and the speaker calls that "quite romantic."
What the Compute Module 5 Is
The Raspberry Pi Compute Module 5 (CM5) is much smaller than a regular Raspberry Pi 5. The speaker explains that it is mainly intended for industrial and embedded applications. For that reason, buyers can tune cost and specifications by choosing between larger or smaller RAM and storage, and between versions with or without wireless communication. Several ports that come standard on the Raspberry Pi 5 are left out, including USB, wired LAN, HDMI, and the GPIO pins. The processor is placed on top, in a layout the speaker describes as designed for compact use.
Storage is one notable difference. A standard Raspberry Pi 5 has no onboard storage and needs a separate SD card or SSD. The CM5 can be ordered with storage built in, and on the board shown it is mounted on the underside. For this project the speaker chose the top configuration in the lineup: 16GB of RAM, 64GB of storage, and wireless capability. The reasoning was that the boards could be reused in other projects later.
Rising Prices and a Certification Caveat
The speaker notes that Raspberry Pi has officially raised prices because of shortages of RAM and storage. Their highest-spec unit was bought in December 2025 for 21,000 yen before tax. At the time of the video, the same configuration was listed at 35,000 yen before tax. The speaker considers themselves lucky to have bought early.
There is also a regulatory point. When the speaker purchased the modules, they did not show Japan's radio compliance certification (giteki). For a project like this cluster, the speaker suggests either disabling the wireless function or choosing a model without wireless from the start. They add that the non-wireless models are also cheaper.
Why Not Use the Official I/O Board
Using a CM5 by itself is difficult. It has a 200-pin connector on the back and has to be plugged into a carrier board. That board can be home-made, bought from a third party, or be the official Raspberry Pi I/O board for the CM5. Once mounted on the official board, the CM5 can be used much like an ordinary Raspberry Pi 5.
The speaker decided against buying one official I/O board per module. The cluster does not need HDMI, USB, or GPIO on each node, so that approach would waste money. Instead, the speaker looked for a cheaper way to cluster the modules and settled on the NanoCluster kit from Sipeed.
Assembling the NanoCluster
The NanoCluster uses a small adapter board for each module. The CM5 sits on the adapter, and the adapter plugs into a shared motherboard. Each adapter has slots for a microSD card and an SSD, plus a USB-C port for power. The speaker likes the SSD slot because it allows storage to be expanded further. They also suggest that a CM5 with wireless could be used simply by plugging it into this setup, but they note they have not confirmed this. The finished build holds seven CM5s in one compact unit.
Idle Behavior: Power, Heat, and a Noisy Fan
The whole cluster runs from a single USB power cable. The cooling fan is quite loud. At idle, with no computation running, the cluster drew about 21W, and temperatures were in the low 30s °C. The speaker points out that temperatures rise further under load. For that reason, they argue that even a mini supercomputer this small needs a cooling fan.
Monte Carlo Pi: Clean Parallel Scaling
The first test estimates pi with the Monte Carlo method, using 200 million samples. On a single node, the calculation took about 20 seconds. With two nodes, the time dropped by half, and it kept falling as more nodes were added. With all seven nodes, it finished in 2.9 seconds, roughly one-seventh of the original time.
The speaker's interpretation is that the benefit of parallelism is clearly visible here. For workloads like Monte Carlo calculations, adding nodes shows the effect of supercomputer-style use very directly.
LINPACK: Tens of GFLOPS, but Not Seven-Fold
The next test is LINPACK, which produced results in the tens of GFLOPS. One node scored 38.8 GFLOPS, and seven nodes scored 85.9 GFLOPS. The speaker notes that this is not a seven-fold increase. In this benchmark, adding nodes did not raise computational performance in proportion.
To give the number some context, the speaker compares it with historical machines. By their account, 85.9 GFLOPS is about the performance of a state-of-the-art supercomputer from around 1993–1994. The speaker finds it remarkable that a machine comparable to a 30-year-old supercomputer now fits in the palm of a hand.
HPCG: Much Lower Scores, but Proportional Scaling
The speaker explains that LINPACK is weighted heavily toward raw computation. Some people argue that it does not reflect the performance of real scientific applications, which also depend on memory access. The speaker also notes that real applications probably involve a lot of data exchange between CPU and memory. For those reasons they also ran HPCG.
As the speaker describes it, HPCG is closer to real scientific workloads because it includes memory access and communication patterns. Memory bandwidth and inter-node communication, which LINPACK does not show, have a large effect on the score. As a result, machines that score well on LINPACK can score much lower on HPCG.
The cluster followed that pattern. It scored 1.10 GFLOPS on one node and 6.54 GFLOPS on seven nodes, far below the LINPACK figures. However, unlike LINPACK, the HPCG result grew in proportion to the number of nodes. The speaker adds a caveat: these results come from a single cluster unit. They do not know whether the same trend would hold if several of these clusters were connected together.
Power and Heat Under Full Load
With all seven nodes computing, the cluster drew 62W. Because about 60W of heat is produced in such a small space, the unit gets quite hot, peaking at about 70 °C. The speaker concludes that cooling is essential for a Raspberry Pi supercomputer, however small.
Power Efficiency Against Real Supercomputers
The speaker explains why power efficiency matters. Leading supercomputers often consume several to several tens of megawatts, which produces enormous annual electricity costs. Power use at that scale also makes cooling difficult. So even when builders want more computing power, power and cooling may become the limits first. That is why the amount of computation per unit of power has become an important measure of supercomputer performance.
Using a chart of GFLOPS per watt, the speaker gives these figures:
- KAIROS, described as currently first in the world for power efficiency: 73.3 GFLOPS/W
- El Capitan, currently first in the world by LINPACK score: 60.9 GFLOPS/W
- Japan's Fugaku: 15.4 GFLOPS/W
- The Raspberry Pi CM5 cluster (measured): 1.4 GFLOPS/W
The speaker notes that KAIROS and El Capitan both use GPU accelerators and do most of their computation on GPUs, which raises their efficiency. Fugaku, like the Raspberry Pi cluster, runs on CPUs only. The speaker therefore considers Fugaku the fairer comparison. Even so, the mini cluster reaches only about one-tenth of Fugaku's efficiency. The speaker explains this by pointing out that Fugaku has specially designed processors and fast memory, while the CM5 is a general-purpose single-board computer.
Conclusions
In summary, the seven-node CM5 cluster reached 85.9 GFLOPS on LINPACK, which the speaker says is comparable to a top supercomputer from around 1993–1994. On HPCG, which includes memory-access effects, it reached 6.54 GFLOPS. That leaves a large gap between the two benchmarks, but the speaker considers it a good result that HPCG performance scaled with the number of nodes. In power efficiency, the cluster is far behind current leading supercomputers.
The speaker still finds it interesting that this much can be done with general-purpose Raspberry Pi boards. They stress that the point is not only chasing performance. Building a small cluster like this can also be a worthwhile way to learn. One question remains open: whether the proportional scaling seen in HPCG would continue if several clusters were linked together.
This video is brought to you courtesy of DigiKey. Hello. Today, let's see if we can build a mini supercomputer using Raspberry Pi, a single-board computer.
We'll use the Raspberry Pi Compute Module 5. It's called CM5. As you can see, unlike a regular Raspberry Pi, the size is much smaller. CM5 is mainly intended for industrial and embedded applications. To make it easier to adjust costs and specifications, you have a choice of RAM and storage capacities, with or without wireless communication. USB, wired LAN, and HDMI ports, which came standard with Raspberry Pi 5, are not included here. Using CM5 with this commercial feel, we are going to build a mini supercomputer.
But first, here is today's sponsor. You probably have opportunities to purchase parts at DigiKey. In fact, DigiKey does more than just sell parts. They also create useful content. From Resources at the top, open the Applications & Technology Center. In this issue, we will look at Embedded & Microcontrollers.
Starting with the microcontroller's instruction set and basic structure, it touches on what types of microcontrollers are available. There are also microcontroller board shape comparisons. According to this, the Raspberry Pi CM5 used in this project has a system-on-module form. When you get to the bottom, it's pretty voluminous. In particular, the differences between microprocessors, microcontrollers, and digital signal processors are quite interesting.
Read this page in its entirety, and I think you'll be able to figure out what a microcomputer is. If you see the word microcomputer in Ichiken's videos and are wondering what a microcomputer is in the first place, or if you have any questions about microcomputers, please contact us. If you want to start embedded development in the future and are wondering how to choose a microcontroller, please contact us. Please check out the link in the description!
First, let's look at what kind of board CM5 is. Among the available models, today we are using one with 16GB RAM, 64GB storage, and wireless capability. Thinking about using it for various projects in the future, I selected the highest specifications among the choices. Naturally, we are buying from DigiKey again!
About the price: Raspberry Pi is also experiencing a shortage of RAM and storage, and prices are officially increasing. This one was purchased in December 2025. The price at that time was 21,000 yen without tax. Now, the price is 35,000 yen without tax. Part of that is because I bought the highest-spec model, but the price has gone up quite a bit. I was lucky to buy it early.
When I bought it, there was no indication of technical compliance. For applications such as building a mini supercomputer like this one, it would be good to turn off the wireless function or choose one that doesn't have wireless capability from the start, especially since it can be done more cheaply without wireless functionality.
Compared to a regular Raspberry Pi 5, the size is much smaller. This is helped by removing the wired LAN, USB, and HDMI ports that were on Raspberry Pi 5, as well as the GPIO output pins. The processor and other components on top are arranged in a compact layout.
The standard Raspberry Pi 5 is not equipped with storage, and a separate SD card or SSD must be provided as storage. With CM5, you can choose a model with storage. If you look at the reverse side, storage is implemented here.
When trying to actually use CM5, it's pretty hard to use this on its own. We're going to plug it into something like a motherboard. On the back of CM5, it has a 200-pin breakout connector. You can connect it to a homemade motherboard, a third-party motherboard, or the Raspberry Pi Foundation's official I/O board for CM5. If you insert it like this, it can be used just like a regular Raspberry Pi 5.
We are going to build a supercomputer this time, so I'm not going to buy an I/O board for every CM5 I have. That would be very wasteful in terms of cost, because running the mini supercomputer doesn't require HDMI, USB, or GPIO for every CM5 unit. Therefore, I decided to look for something that could build a mini supercomputer at an even lower cost.
If you look around the world, there are many different things for sale. Sipeed's NanoCluster is a kit that allows CM5 modules to be clustered. So I'm going to combine CM5 with this kit to build a mini supercomputer.
Looking at NanoCluster, we see a conversion board like this. Put CM5 here, and then insert it here. It's like this: CM5 goes on top of the conversion board, which then plugs into the motherboard.
The conversion board has slots for a microSD card and an SSD, and USB-C for power. I like the fact that there are slots for SSDs and so on. Storage can be further expanded. I have not confirmed this, but a CM5 with wireless would probably be usable just by plugging it into this. We will assemble it.
Assembled this way, seven CM5s are clustered. Now let's actually use it. Plug in the USB cable for the power supply, and it works.
It's started up. The cooling fan is quite noisy. Power consumption is about 21W at idle, without any calculations running. Temperatures are in the low 30s. This is the temperature with no calculations. If you perform calculations, the temperature rises further. Therefore, even a mini supercomputer of this size requires a cooling fan!
First, I decided to calculate pi using the Monte Carlo method. What were the results? With one node, it took about 20 seconds of computing time. In this case, we calculate 200 million times. With two nodes, the time it takes to do the calculation is halved. From there, as the number of nodes increases, the computation time becomes shorter and shorter.
The time taken with seven nodes is 2.9 seconds. The calculation that originally took 20 seconds is done in one-seventh of the time. The effects of parallelism are clearly visible. With Monte Carlo calculations like these, increasing the number of nodes makes the effect of using it like a supercomputer pretty obvious.
We will try other benchmarks as well. Next is a benchmark using LINPACK. The execution results are shown below. It is tens of GFLOPS. Does adding more nodes improve computational ability in proportion to the number of nodes? From what I see here, that doesn't seem to be the case. It was 38.8 GFLOPS with one node and 85.9 GFLOPS with seven nodes. Not exactly a sevenfold increase.
Incidentally, how does this performance compare to past supercomputers? It has about the same computing performance as a state-of-the-art supercomputer in 1993–1994. Something as good as a supercomputer from 30 years ago fits in the palm of this hand. Amazing, isn't it?
In this case, we used LINPACK. This benchmark heavily emphasizes computing performance, and some say it doesn't measure performance including memory access and other factors, as in a real scientific computing application. In actual applications, I think there is also a lot of data exchange between the CPU and memory. That's why we tried HPCG next.
HPCG is a benchmark that includes memory access and communication patterns close to those of real scientific computing applications. Memory bandwidth and inter-node communication performance, which LINPACK doesn't reveal, have a significant impact on scores. Therefore, even computers that show high performance in LINPACK can have significantly lower scores in HPCG.
Here are the results of the HPCG run. Compared to LINPACK, the GFLOPS have dropped significantly: 1.10 GFLOPS for one node and 6.54 GFLOPS for seven nodes. HPCG also takes memory access and other factors into account, so is this the power of the Raspberry Pi supercomputer? But unlike with LINPACK, computing power is increasing in proportion to the number of nodes. This time, the results were based on only one unit of this cluster. We do not know if the trend will be the same when multiple units of this cluster are connected in parallel.
When performing calculations on all seven nodes, power consumption was 62W. I also measured the temperature. Since about 60W of heat is generated here, it's pretty hot. The highest temperature was about 70 degrees Celsius. Even when building a supercomputer with Raspberry Pi, cooling is essential.
Next, we will look at power efficiency. The power consumption of a state-of-the-art supercomputer is often several MW to several tens of MW. In this case, the electricity bill alone can amount to billions of dollars a year. Also, if power consumption is that high, cooling will be difficult. Therefore, even if you want to increase the computational power of the supercomputer, cooling and power can become limiting factors first. When that happens, power efficiency—the indicator of how much can be calculated with the same power—becomes important for assessing supercomputer performance.
We will look at the graph here. This graph shows how many GFLOPS can be calculated per watt of power consumption. The world's current number one in power efficiency is a supercomputer called KAIROS, with a power efficiency of 73.3 GFLOPS/W. To its right, El Capitan, currently ranked number one in the world by LINPACK score, is at 60.9 GFLOPS/W. Japan's supercomputer, Fugaku, is at 15.4 GFLOPS/W. In contrast, the Raspberry Pi CM5 mini supercomputer I made this time measured 1.4 GFLOPS/W.
What I want to draw your attention to here is that KAIROS and El Capitan have GPU accelerators. They increase power efficiency by having GPUs do most of the calculations. Fugaku, on the other hand, runs on CPUs alone. This Raspberry Pi cluster also performs calculations only on CPUs, so Fugaku is a better comparison. However, compared to Fugaku, the mini supercomputer we built this time has only one-tenth the power efficiency.
Fugaku is a supercomputer with specially designed processors and fast memory. In contrast, CM5 is a general-purpose single-board computer. That's why it turns out this way.
This time, I built a mini supercomputer using seven Raspberry Pi CM5s. It achieved 85.9 GFLOPS on seven nodes in LINPACK, comparable to the performance of a state-of-the-art supercomputer around 1993–1994. I think there's something quite romantic about the same performance as a supercomputer from 30 years ago fitting in the palm of your hand.
In HPCG, which includes memory access in its results, it achieved 6.54 GFLOPS on seven nodes. There was a big performance gap compared to LINPACK, but I think it's a good result that computational performance scaled in proportion to the number of nodes.
In terms of power efficiency, there was a big difference compared to state-of-the-art supercomputers. I think it's quite interesting that you can do this with a general-purpose board like Raspberry Pi. Of course, it's not just about chasing performance. It would also be interesting to put together a cluster or mini supercomputer like this for study purposes.
If you found this video helpful, please give us a high rating and subscribe to our channel! If you have any concerns, please leave a comment as well. Thank you for watching the video until the end.
Article published · Updated