Orange Pi put the OrangePi O1 on sale on 1 November 2026. The board is built on the Sophgo BM1688, an eight-core Arm Cortex-A53 platform with a RISC-V C906 helper core and a tensor engine rated at 16 TOPS at INT8. The 8GB variant lists at $238.99 on Amazon, the 16GB variant at $379.99 with a cooling fan, as of November 3, 2026. AliExpress carries the same boards at $304.40 and $499.40.
Those prices are not the interesting part. The spec sheet prints 16 TOPS, and Orange Pi lists Llama2-7B, Qwen1.5-1.8B, Gemma-2B and ChatGLM3-6B as supported models. Nobody prints the number that decides what those models actually do on this board: the memory interface. The BM1688 reaches its memory through two 32-bit LPDDR4X channels. That is the whole story of the O1, and it is the same story every cheap edge accelerator tells.
The number on the spec sheet is not the number that runs the model
Decode is a memory problem wearing a compute costume. Once a model’s weights are loaded, generating one token means reading every weight once. For a quantized model in single-stream generation, the arithmetic per byte of weights is roughly two operations: one multiply and one accumulate per weight. A chip rated at 16 TOPS on a bus that delivers 34 GB/s has 469 operations available per byte of memory traffic. It needs two.
That ratio is arithmetic intensity, and it is the reason a board can advertise 16 TOPS and produce single-digit tokens per second. The compute is not the scarce resource. The bus is. The O1 is roughly 235 times over-provisioned for single-stream decode, and that over-provisioning is what you are paying for.
What the memory interface actually is
Sophgo publishes the interface, not a bandwidth figure. The BM1688 datasheet lists LPDDR4/LPDDR4X on a 2×32-bit interface. The Banana Pi module that carries the same chip specifies 8GB LPDDR4X at 64 bits and 4266 Mbps. Multiplying those two published numbers gives 2 x 32 bits x 4266 MT/s = 34.1 GB/s theoretical peak. That is my own arithmetic, not a published spec, and Sophgo does not print a bandwidth figure for this part anywhere I could find.
For comparison, Hailo’s own documentation puts the Hailo-10H on-module memory at 17 GB/s peak on a 32-bit LPDDR4X bus running at 4266 MT/s. The Coralboard SL sits at the other end of the same problem: 2 GB of memory, a small bus, and 605 MB reserved before it produces a single token because its shapes are fixed at compile time.
The ratio nobody prints
Here is the same class of hardware lined up on the two numbers that matter. Bandwidth figures are vendor-published where marked, and derived from published interface specs where marked as arithmetic. Token rates are measurements from the named source, not theoretical ceilings.
| Platform | Rated compute | Memory bandwidth | Ops per byte | Measured decode |
|---|---|---|---|---|
| OrangePi O1 (BM1688) | 16 TOPS INT8 | 34.1 GB/s (my arithmetic from 2×32-bit @ 4266 MT/s) | 469 | None published |
| Hailo-10H module | 40 TOPS INT4 / 20 TOPS INT8 | 17 GB/s (Hailo documentation) | 2,353 | 1.01 tok/s on Llama-3.2-3B INT4 (Edge-LLM-Bench); 11.2 tok/s on the same model size from a different source |
| Jetson Orin Nano Super | 67 TOPS sparse INT8 | 102 GB/s (published) | 657 | 12-18 tok/s on Llama 3.1 8B INT4 |
| Sophgo SE7-32 (BM1684X) | 32 TOPS INT8 | Not published for this board | – | 10.25 tok/s on Llama2-7B INT4, vendor-published |
| Raspberry Pi 5 CPU only | None | Comparable to 17 GB/s per the Edge-LLM-Bench paper | – | 0.32 tok/s on DeepSeek-R1-Distill-Qwen-1.5B |
The pattern is consistent across every row. The boards with the highest ops-per-byte ratios have the lowest measured token rates. The Jetson is the least over-provisioned of the group and it is the fastest one. That is not a coincidence, and it is not a software problem.
Two measurements of the same chip disagree by a factor of eleven
The Hailo-10H is the clearest case, because there are two independent measurements of it.
Edge-LLM-Bench, an academic benchmark published through ACM, ran six language models on a Raspberry Pi 5 with the Hailo-10H and found that the accelerator does not improve raw token throughput over the host CPU for small models. It reduced total system power by 51 percent and freed the host CPU and memory for other work. On DeepSeek-R1-Distill-Qwen-1.5B it measured 1.53 tokens per second against 0.32 on the CPU, with energy falling from 33.24 to 3.47 MJ per million tokens.
A separate industry measurement reports 11.2 tokens per second on Llama-3.2-3B INT4 at 3.2W of board power on the same silicon, against 8.4 tokens per second at 14.8W on a Jetson Orin Nano. Those two numbers cannot both describe the same toolchain, the same batch size, or the same measurement method. One is a compiled graph under a benchmark harness with wall-clock timing; the other is a vendor-adjacent test under unstated conditions. The gap is not a contradiction in the hardware. It is a contradiction in how the number was produced.
That is the practical lesson for anyone buying on a TOPS figure. A tokens-per-second number is only meaningful with the model, the quantization, the batch size, the context length, and the timing method attached to it. Without those, it is marketing.
What this means if you are running models locally
For a 7B model at INT4, weights come to roughly 3.5 to 4 GB. On a 34.1 GB/s bus, the theoretical ceiling is about 8.5 to 9.7 tokens per second before KV cache traffic, sampling, and the host-side tokenization overhead. Real numbers land below that. The same arithmetic on the 17 GB/s Hailo interface gives a ceiling near 4 tokens per second for a 7B model, which is why the measured results on that platform sit in single digits.
This is the wall that produced the 0.77 tokens per second on the VENTUNO Q, and it is the ceiling that the 273 GB/s Axera bus describes from the other direction. Every edge board is a memory machine with a compute accessory attached.
Where the O1 is genuinely good is not decode. It decodes 16 channels of 1080p30 video and encodes 10, runs JPEG at 480 frames per second, and takes input from six camera sensors. A vision workload reads a frame once and processes it with high arithmetic intensity, which is exactly the shape of work a 16 TOPS engine was built for. If the job is a network video recorder with object detection, this board is well matched to it. If the job is an agent that generates text, the bus is the constraint and the TOPS figure is irrelevant.
What to buy for the workload you actually have
If the task is continuous text generation on a small model, the cheapest path that produces usable output is still a board with a wide bus, not a board with a high TOPS number. The hardware ladder in the budget guide is organized by bandwidth per dollar for that reason.
For the specific parts:
- Orange Pi O1 8GB at approximately $238.99. The 34.1 GB/s interface is the only defensible reason to buy it over a Pi 5 at a similar price, and the value is in the video pipeline, not the language model.
- Orange Pi O1 16GB at approximately $379.99. Extra capacity does not change the bus width. It changes which model fits, not how fast it runs.
- Raspberry Pi 5 AI HAT+2 kit with Hailo-10H at approximately $339.98. Buy this for the 51 percent power reduction and the freed host CPU, not for throughput. The published measurement says it does not beat the host CPU on token rate for small models.
- Hailo-8 M.2 module, 26 TOPS at approximately $214.99. It has no memory interface of its own and no path to a language model. It is a vision accelerator, and it is a good one at that price for vision work.
One more practical note before ordering. Mainline Linux kernel support for the BM1688 has not landed. Sophgo’s toolchain works through its own SDK, its forked kernel, and the LLM-TPU repository, which handles compilation to bmodel files and supports BM1688 for Qwen, Llama, DeepSeek distills and several vision-language models. Model compilation runs on an x86 host and needs a large amount of working memory. That is a real cost in time, and it is not on the spec sheet.
The number to ask for
Before buying any edge board for language work, ask for the bus width and the memory clock. Multiply them. Divide the model’s quantized weight size by that result. That gives the ceiling, and every published measurement on these boards lands below it. The TOPS figure tells you what the chip could do if memory were free. It is not free on a $239 board.

