Should you buy this instead of an NVIDIA DGX Spark?

Read the report that says this does not work →

No.

You are here because you want to run a large model on your own machine, you priced an NVIDIA DGX Spark at $4,700, and you started looking for something cheaper. That is a reasonable thing to do and we did the same thing, which is why this company exists.

Buy the NVIDIA DGX Spark. If you cannot, buy nothing yet. What follows is the detail, because you should not take our word for it either.

---

How big a model can it run?

This is the question people ask second, and the answer is the most interesting thing about the machine.

On capacity alone: about 6 trillion parameters. At the report's 1.58-bit ternary compression, the array holds more parameters than any model published anywhere. On that measure we beat everything.

Now the other half. To produce one word, a normal model has to read every weight it has. So what decides speed is not how much you can store, it is how fast you can read it back — and reading the full array once takes 4.9 minutes. That six-trillion-parameter model would fit, and would spend about two days on a single paragraph. It would never finish a sentence.

So the array is not where the model goes.

It is not a model size. It is a memory.

The one configuration the Feasibility Report is willing to call theoretically possible keeps the model itself in ordinary host memory — ~13.8 GB, small — and gives the array a different job: holding the conversation history.

The array is 1.28 TB raw — approximately 1.2 TB usable once it is formatted and striped. Measured as history, that is roughly 7.7 million tokens — around 5.8 million words of things the model can still see, or sixty times a 128,000-token context window.

That is the number we would like to put on the poster.

Why we are not going to

Every new word makes the model re-read the entire history. Storing 7.7 million tokens is not the problem; reading it back, once per word, is.

At a five-second budget per word, the usable history is about 131,000 tokens — 1.7% of what physically fits.

An NVIDIA DGX Spark reads that same 128,000-token history in 0.04 seconds. We take 4.9 seconds. On the row that decides whether the thing is usable, we are 122 times slower.

So the whole array buys a working memory about the size of the $4,700 machine's window, and takes 122 times longer to consult it. We have checked this arithmetic more than once, hoping to find an error in our favour.

One more number, which we did not go looking for

Filling 7.7 million tokens at 1.5-3.0 tok/s takes 30 to 59 days.

The cards are projected to wear out after ~64 days.

You can fill the memory almost exactly once. The array dies at roughly the moment it is full.

A note on our own report

The Feasibility Report gives both a decode speed of 1.5-3.0 tok/s and a ~20 GB cache at a 128,000-token context. Our arithmetic above cannot make those two agree: at that cache size, one read per word is 4.9 seconds, which is not 1.5-3.0 tok/s. The decode figure appears to describe a much shorter context, closer to ten thousand tokens.

We are not going to reconcile them by choosing the flattering one. Both are published as written, and this paragraph is here so that you find the discrepancy from us rather than on your own.

---

What you plug it into

We should have led with this and did not.

There is no computer in any kit, and you need one. The array is a peripheral. It does nothing on its own — it is forty card readers that a Linux machine treats as one large, slow disk.

The configuration the report calls possible keeps the model's weights in the host's own memory, so that machine needs 32 GB of RAM, a spare Linux install, and enough USB to talk to forty readers at once. It also runs hot and thrashes, so it should not be the laptop you work on.

The part that changes the numbers

~4.1 GB/s is forty cards times their 104 MB/s rating. It is what the media could supply. It is not what a computer will get out of them, because everything has to fit through the host's USB controllers, and one USB 3.0 controller carries about ~450 MB/s.

Reaching ~4.1 GB/s takes 9 independent USB 3.0 controllers. Most desktops have one. Adding hubs does not help: a hub shares one uplink, it does not create another. The reference rig specifies four powered hubs, and if all four hang off the same controller the whole array runs at about an ninth of the headline figure.

So the number in our own comparison table is a ceiling nobody reaches, and we would rather say that here than let you find it after the parts arrive.

And the price

Against $4,700, that is about a third of the price rather than a quarter. And the DGX Spark is a computer that arrives working, where this is a box of parts plus a second computer you have to own, power, and find room for.

---

What you are actually comparing

Two numbers get confused constantly, and the whole decision turns on telling them apart.

How much a machine can hold, and how fast it can reach it.

We win the first row by ten times. We lose the second by more than a hundred.

The first number is the one on our posters. The second is the one you will actually feel, every second you use it. If you take one thing from this page, take that.

What "1.5-3.0 tok/s" feels like

Model speed is usually quoted in tokens per second. A token is roughly three-quarters of a word. Here is the same 500-word answer on both machines:

Between 45-60 s pass before the first word appears at all, on a long prompt.

Put another way: you read at about 250 words a minute. This machine writes at roughly a third to a half of the speed you read. You will finish each sentence before it does and wait for the next one.

The Feasibility Report we commissioned describes it as:

It is functionally the equivalent of watching a human type.

We have not disputed that and we put it on the front page.

Three things people get wrong

"More memory means bigger models." True. It does not mean faster, or even usable. A model that fits but generates at 1.5-3.0 tok/s is a model you will stop using by Thursday.

"1.28 TB for a quarter of the price is a good deal." Per gigabyte, yes, and that is the only measure by which it is one. Storage is cheap. Getting to it quickly is what costs money, and that is what you are declining to pay for here.

"It says memory, so it is memory." It is not. The array is exposed to the operating system as swap-backed block storage over USB. It is not RAM and does not perform like RAM. Your computer already does this with its hard drive when it runs out of memory, and you already know what that feels like.

What you would actually experience

You buy a kit of parts. Nothing arrives assembled and there is no circuit board in the box, because we do not sell one — you build it on perfboard yourself.

Then you solder for a weekend. Then there is no software, because OpenFARCE is pre-alpha and is not included in anything we sell. Then, if you get it running, you wait 45-60 s for a first word and watch text appear more slowly than you read it.

Then, after roughly ~64 days of continuous use, the cards begin to wear out, because that is what happens to consumer flash under this workload. We sell replacements. That is not a workaround, it is the design.

What to buy instead

We would rather say this here than have you find out later.

• You want to run large models locally and can afford it. Buy the NVIDIA DGX Spark. It is an excellent machine and it will beat this by every measure we publish.
• You cannot afford it. Rent time on a hosted GPU. It will cost less than this kit and work immediately.
• You want a lot of fast storage on a small computer. Buy a $25 USB SSD. It beats this array on write speed, random access, latency, endurance, reliability and power draw, and ties it on sequential reads only because both are limited by the same USB controller.
• You want to understand why all of the above is true. Then keep reading.

So what is this for

Learning what the memory wall actually is, by building a machine that runs straight into it.

Everything that makes this bad storage — slow, fragile, short-lived, forty separate devices that fail one at a time — is what makes it legible. An SSD hides all of it inside one chip. This does not hide anything. You can watch load spread across the array, watch a single card overheat and drag the rest down, pull one out and watch the whole thing stop.

That is a real thing to own. It is not the thing on the poster.

What we have actually built

Not the array. Eight cards, not forty, in eight USB readers on one powered hub, attached to a Raspberry Pi. About $70 of parts.

It is a working prototype of a thing we describe at five times the scale, and we would rather say that plainly than photograph it from a flattering angle. Every measurement it produces will carry the number of lanes it was measured on.

Every figure on this page is the Feasibility Report's projection until that rig runs. None of them is a measurement yet.