Just a few days ago, on September 10, DeepSeek open-sourced its latest and most powerful DeepSeek V4.1 Flash model under the MIT license. It is a 552-billion-parameter (552B, excluding the Engram model) mixture-of-experts model that can run with as few as 8B active parameters, and the company even used it to replace its original flagship V4-Pro. But just one day after this massive model launched, a developer on X squeezed this 552B model onto a 16GB M1 Mac mini, and it actually “ran.”
However, although it can “run,” it’s not guaranteed to run fast. The author FP4 Brain (the account name directly pays homage to the FP4 four-bit floating-point format, which fits this matter well) said that using original FP4/FP8 weights, SSD streaming, and a homemade MLX runner, he did successfully load the DeepSeek V4.1 Flash model on a 16GB small computer, but the cost was: the first token output takes 108 seconds to wait for, and afterward it averages 23 seconds “per generated character.” The original text even specifically notes in parentheses, “don’t confuse this with tok/s (tokens generated per second).”
got deepseek V4.1 flash running locally on a 16GB m1 mac mini
original FP4/FP8 weights, ssd streaming + custom mlx runner
108s ttft and about 23s/token (not to be confused with tok/s) pic.twitter.com/sOq3wB2XWM
— FP4 Brain (@thefp4brain) September 11, 2026
The video frame he attached maxes out the absurdity: a Mac mini M1 (8-core CPU, 8-core GPU), 16GB RAM, 1TB SSD, a checkpoint size of 475 GiB, yet only a 4 GiB weight cache. The entire model is nearly 30 times larger than memory and simply cannot fit, so it can only rely on SSD streaming to move weights in and out layer by layer, reading the disk once for every layer computed. The dashboard itself is honest about it too: the read volume includes the operating system cache, and the peak MLX usage on the weight side does not represent the memory usage of the whole machine; at the bottom of the screen it also labels the cumulative logical read volume for “checkpoint bytes requested,” along with “4 GiB weight cache plus compiled decode,” all evidence that this model is barely holding on by “reading while computing.”
got deepseek V4.1 flash running locally on a 16GB m1 mac mini
original FP4/FP8 weights, ssd streaming + custom mlx runner
108s ttft and about 23s/token (not to be confused with tok/s) pic.twitter.com/sOq3wB2XWM
— FP4 Brain (@thefp4brain) September 11, 2026
In the video, what’s running is the prefill stage. The 40-layer model is stuck at “Layer 00 / 40” without moving, and the question it was asked is: “explain what is navier stokes” (explain what the Navier-Stokes equations are). Normal speed is just too painful, so the author replayed the video at 12x speed. Someone in the comments immediately caught the point: “I was about to say, huh, it seems barely usable, and then I realized the video was sped up.”
16 minutes, in exchange for one sentence.
In an actual test on the same machine and with the same question, it ran for 16 minutes 21 seconds, waited 127.9 seconds for the first token, averaged 30.7 seconds/token, read 373.3 GiB of data from the SSD throughout, and finally produced a 28-token answer: “The Navier-Stokes equations are a set of partial differential equations that describe how fluids (liquids and gases) move.”
To generate a single definition of fluid mechanics, this machine burned through nearly 80% of its checkpoint read volume (373.3 GiB out of 475 GiB), and on average, for every character it produced, the hard drive had to move 13.3 GiB. When the same question was thrown at the official DeepSeek API, off-peak input cost only US$0.15 (about NT$5) per million tokens, output US$0.60, doubling at peak, and the answer came back in just a few seconds. The local instance running at home, meanwhile, was: press Enter, go brew coffee, come back just in time to see the first character slowly emerge. The author also admitted in the comments that a whole sentence takes about 16 minutes. That works out to about 2.6 characters per minute; to put together a 500-character short piece, you’d have to wait more than three hours. Interestingly, the post text says 108 seconds to first character and 23 seconds/character, but a screenshot of the same configuration measured 127.9 seconds and 30.7 seconds/character in practice—even “running fast” is a matter of luck.
Comments section: You call this running? It’s more like crawling.
This post has accumulated more than 1,200 likes and 65 comments, and community reactions broadly split into two camps, both very witty. The mocking camp: “You call this running? It’s more like crawling.” “108 seconds of thinking, and all it did was say the name of that noun in your question.” “You can go to sleep first; the answer will be waiting there for you in the morning.” “And it even lost to Qwen3.8-flash-next.” Some also asked seriously: Streaming weights from SSD is one thing, but how long a KV cache can actually be loaded? The author’s reply was very honest: “Are you willing to wait for this test?”
The warm-and-fuzzy angle actually holds up too: “I still say this is progress—go for it!” “You got it running in the end; that’s impressive.” “It’s better than nothing.” Both camps are saying the same thing: loading a 475 GiB model on a machine with 16GB of memory is itself a kind of technical romance of trading time for space.
The model itself: 552B, MIT-licensed, and a price war at 30% off.
Joke aside, at least it got this model actually running locally on an ordinary machine without quantization (though its practical usefulness is close to 0). V4.1-Flash is the smallest member of DeepSeek’s current new architecture family: 552B parameters, MIT license, 1 million token context, and native image input support. It uses a causal encoder-decoder design, with 20 encoder layers plus 20 decoder layers. The decoder’s global KV cache is projected directly from the encoder’s last-layer hidden states, so it does not need to be recomputed layer by layer. The KV cache itself is compressed to 4-bit, with each token taking up only 890 bytes, about one quarter of the previous-generation V4-Flash, while the SSD persistent cache is only one eighth. It is so powerful that the company has officially retired the previously experimental vision model and V4-Flash, routing all calls to V4.1-Flash.
The official scorecard is equally impressive: it scored 90.6 on Terminal-Bench 2.1, beating Claude Opus 5’s 89.1 and GPT-5.6 Sol’s 88.8, with a 74.2% solve rate on DeepSWE v1.1. The base version also edges ahead slightly on Bench: MMLU-Pro 74.1, HumanEval 79.4, GSM8K 93.0, all slightly above V4-Pro-Base. Output pricing was cut from $3.96 (about NT$129) to $1.20 (about NT$39), a reduction of about 70%.
The official API beta schedule was actually very tight: it went live on September 8, went offline on September 10, leaving only a two-day testing window, and then the weights were open-sourced right after. For people running AI locally, the race only truly begins the moment the weights go open source. According to community estimates, this model’s official 4-bit version totals about 510 GB, and not even two DGX Sparks (256GB memory) can fit it, so it can only be crammed in through quantization and streaming. People have already released MixedQ2 GGUF, MLX 2-bit, MLX 4/8-bit, and more.Extreme quantization version, lowering the threshold bit by bit.
Conclusion
Although the results this author demonstrated are quite absurd, most people still give credit, because everyone can see: although this Mac mini runs slowly enough that it could be made into a 12x-speed video, it is indeed using the original weights, without any requantization, to run a 552B open-source model. Trading 16 minutes for one definition of Navier-Stokes sounds absurd, but this is the necessary path for local AI from “can’t run” to “can run.” Next time you want to ask it a question, remember to brew your coffee first.
Source: KOCPC Chinese