Enthusiast Runs DeepSeek-V4-Flash on 64 GB of RAM With No GPU: Up to 15 Tokens per Second

Talk about running large models locally usually comes down to one question: how much VRAM do you have? An enthusiast has published the llama-modchip project under the Apache 2.0 license and claims that an ordinary PC with 64 GB of RAM is enough for a 284B-parameter model. No graphics card is needed, and no swap either. Let's look at what exactly was done and whether the claim holds up.

What the project achieves

llama-modchip is a set of patches for the ggml/llama.cpp kernels, plus quantization tools and scripts for running sparse MoE models directly on a CPU. The target model is DeepSeek-V4-Flash: 284B parameters in total, 13B of them active.

Here are the author's numbers. Peak memory use is about 58 GB with a 256,000-token context. Prefill, meaning the "reading" of the prompt, runs at 44 tokens per second. Generation delivers 9 to 15 tokens per second. The tests ran on a 16-core Ryzen 9 9955HX. That is roughly the pace at which text is still comfortable to read as it appears on screen. It is fine for chat or background tasks, but already sluggish for interactive work with long documents: at 44 tokens per second of prefill, loading a large context takes a noticeable amount of time.

Why this is possible at all

Two techniques come together here.

The first is built into the model itself. MoE (mixture of experts) works like a big library where, for each question, you open only the relevant books, the experts. Everything is stored, but only a small part is computed. In compute terms, DeepSeek-V4-Flash is therefore closer to a mid-sized model: only 13B parameters work on each token. A CPU can handle that load. The bottleneck is elsewhere: all 284B weights have to sit in memory.

The second technique is the author's own work. He aggressively quantizes the routed experts to 1.56 bits per weight using the IQ1_S scheme, and he uses a custom file format. As a rough estimate, 284B weights at slightly over one and a half bits each come to a little more than 50 GB. That fits into 64 GB and leaves headroom for context and the operating system.

The upshot is simple: MoE solves the compute problem, and quantization solves the memory-footprint problem. In this setup, a graphics card is simply not needed.

Where the catch is

There are several catches, and they are worth keeping in mind.

First, the word "lossless" in the README. It means only that the logits match an unpatched build running the same quantized weights. In other words, the kernel patches break nothing. No one has compared the result with the full-precision model. And at 1.56 bits per weight, there is almost certainly some quality loss; the only question is how large it is. For code, long reasoning chains and tool calling, even a small degradation can be critical.

Second, all the numbers come from the author himself. There are no independent reproductions yet, so speed and memory use may differ on other hardware.

Third, compatibility. The quantized files do not open in standard llama.cpp, Ollama or LM Studio. You need the project's own build, which means putting up with a fork and keeping an eye on whether it stays maintained.

What to do with this

For developers and product managers, the takeaway is pragmatic. This is not yet a production-ready solution but a proof of concept: a frontier-sized MoE model can be made to fit on an ordinary desktop. If the measurements are confirmed, teams will get a cheap way to run large models locally for prototypes, offline scenarios and tasks where data cannot be sent to the cloud.

The practical plan: wait for independent reproductions, and if you have a spare 64 GB machine, run the model yourself on your own tasks and compare it with an API or with smaller models. Quality on your data will decide whether the 1.56-bit version deserves attention. A speed of 9–15 tokens per second may be acceptable for offline agents or batch processing, but not for interactive products serving dozens of users.

The broader trend is clear, though. Memory and graphics cards keep getting more expensive, and software optimizations like this one are starting to compete with hardware. For now it is more of a promising claim than a new standard, but the direction is worth watching.