A laptop with a 30-watt GPU outruns llama.cpp: how mojo-dllm gained 285 stars in a week with no one reposting it

A Dutch math graduate and AI engineer wrote a local inference engine for a diffusion language model from scratch in Mojo, which had just gone open source. The headline is a comparison table against llama.cpp on the same laptop: nearly 2x faster on CPU. Nobody on HN, X, or Reddit is pushing it, yet it went from 54 stars to over 300 in the first week of November. Below: what it is, where the stars came from, what's worth copying, and where to build if you want a similar project.

A laptop in October 3

The earliest benchmark files in the repo are dated 2026-10-03: a 13-gen i5-13420H laptop, 12 threads, 32 GB RAM, power set to performance. The GPU is an RTX 3050 laptop card with its power capped at 30 W and 6 GB VRAM. The repo was created at midnight on 10-04, and v0.1.0 shipped that same day.

The author, Vladimir Rotariu, lists on his personal page: "Senior AI Engineer, formerly ING." He holds a double bachelor's in mathematics and physics from the University of Groningen, and his thesis covered Bohmian mechanics and scattering theory. The first line of the page reads "temporary account, original is @vladimirrotariu." That original account currently doesn't open on GitHub, and the reason is unclear.

The top of the README is a GIF: LLaDA-8B faces a fully masked "canvas," denoising over 16 steps. It fixes the end-of-sequence filler first, then a haiku gradually surfaces. Right after that is the benchmark table (LLaDA-8B, Q4_K_M, 128 tokens, 32 steps):

(README benchmarks: CPU portion measured at 10-03, GPU portion at 11-03)

The sentence under the table is the key part: every number is rendered from the result files in bench/results/, and if the table and files don't match, CI fails. He also added two fairness tests: sweeping llama.cpp's thread count from 4 to 12 to find its best result, and comparing forward passes alone to exclude sampler differences. On the GPU with Dream-7B it is actually a bit slower (18.29 vs 18.66), and that's stated plainly in the table.

What it is

Diffusion language models (LLaDA, Dream, and similar) don't write left to right one token at a time. They lay down a whole block of masked tokens and lock in the most confident ones each step until it's full. That means each step reruns the entire model over the whole canvas, so the workload looks more like a chain of matrix multiplications than the one-token-at-a-time work of autoregressive models.

llama.cpp added diffusion support in July 2025, but only as a command-line tool in its examples folder, with no optimizations for this workload. mojo-dllm targets that gap: GGUF loading, the tokenizer, quantized matmul, GPU kernels, and the denoising loop are all written in Mojo, and the runtime needs no Python. At load time it repacks Q4_K / Q6_K weights in groups of 8 rows to feed AVX-VNNI instructions, and on GPU it uses int8 tensor cores. Each model's sampler follows the official code, and logits are compared against llama.cpp one by one. Install is a single ./mojo-dllm setup command, and doctor tells you what's missing. The limits are stated clearly too: Linux x86-64 only, requires AVX2, and the GPU has only been tested on one RTX 3050.

Where the stars came from

(GitHub daily stars)

Every public channel I could check: no Hacker News posts; searching "mojo-dllm" and "LLaDA Mojo" on X over 30 days returned 0 results; Reddit turned up nothing; the Modular forums and blog don't mention it. The coverage that does exist is all from automated aggregator sites: AI Intelligence Station (10-09), Devotd (10-29, trilingual English/Chinese/Korean), AiBoss (11-01), and AI Byte Core (11-04). Machines pulled these from new GitHub repos and wrote them up automatically. Some of the 54 stars from October probably came from here (inference).

The only tactic I could actually observe: recruiting with pre-cut issues. Of the repo's 120 issues, 100 were opened by the author himself, with dozens opened in a cluster on 11-03 and 11-04, each tagged easy / medium / hard, good first issue, or help wanted. His personal page says: "These issues are sized small enough that you can finish one without knowing the codebase." In the same window, 6 outside accounts submitted 23 PRs, most already merged: QinXi-ai filed 14 starting 10-26, and inmassat filed 5 in a single day 11-04. These accounts look like people, or AI agents, specialized in farming open-source contributions: one account was created 10-29 and already has 35 PRs, while another has 160 PRs from half a year. Accounts like this often star the repo in passing.

One more detail: the author's profile links to a maintainer agent he wrote, "an unattended maintainer that runs Claude Code on a schedule, reviews PRs, opens issues, and organizes the issue list," which he states maintains his other project SysKnife. How many of those 100 neatly split issues were opened by the agent isn't visible from outside (my guess: a fair share). SysKnife also gained 55 stars the same week, with a single-day peak at the same 11-03, which suggests the two repos were noticed together through the author's account rather than because of one post.

I found no specific trigger for why growth accelerated sharply from 10-31 to 11-02. GitHub doesn't publish the stargazer list, so I can't rule out inauthentic stars.

Why this one

1. 时机对上了两个圈子。 Mojo 8 月发 1.0 并开源,9-25 的 1.1 把编译器开放出来,MAX 10-22 变成 source-available;同一时间 Google 8 月发了 DiffusionGemma,NVIDIA 10-30 放出量化版。「Mojo 能不能写出真东西」「扩散模型能不能在本地跑」,两边都在找证据,它一次回答了两个问题。这周按 7 天涨星排,Mojo 语言的 GitHub 库里它第一(+285),第二是 Modular 官方仓库(+38)。
2. The benchmarks can be checked. The tech crowd's first reaction to "faster than llama.cpp" is skepticism. Result files committed to the repo, CI validation, thread sweeps, and the losing numbers published anyway made people willing to believe it. Even the machine-written aggregator articles cited "reproducible benchmarks" as the reason to recommend it.
3. The competitors treated diffusion as a side feature. llama.cpp's diffusion support is an example tool. dInfer, Fast-dLLM, and SGLang target server GPUs and PyTorch. Ollada, released around the same time, went for the easy-to-use "diffusion version of Ollama" route and hit 2 stars in two weeks. Independent runtimes built specifically for local CPUs and small GPUs that read GGUF and publish strict benchmarks are basically just this one and diffuse-cpp, and this is the only one written in Mojo.
4. This playbook has worked before. When Mojo launched in 2023, llama2.mojo claimed "faster than llama2.c" and got over 2,100 stars; in 2024, llm.mojo got over 380. "Rewrite a popular ML project in a new language and beat C/C++ on benchmarks" has consistently drawn an audience in the Mojo community, and mojo-dllm is the 2026 version of it.

How many people know about it

Very few. There are no human-written discussions, only aggregator coverage. Its 6 forks are all PR contributors, and nobody has copied it to build a rival. Total stars are under 400, which makes it the top Mojo repo this week, but outside that niche almost nobody has heard of it.

One caveat: far more people star a repo than actually use it. It only supports Linux x86, runs at 1.3 tokens/sec on CPU, and nobody is using it for real work. People star it because it proves a point.

If it were you

Verdict: B. "Build a specialized runtime in a new language for a model category that a big framework only supports incidentally, and lead with a same-machine benchmark" is a clear play that nobody is copying yet, and it's worth trying. The weakness is the low ceiling (Mojo plus diffusion models are both small niches, in the hundreds-of-stars range), and the bar is real skill: nobody without experience writing quantized kernels and SIMD code will produce something that beats llama.cpp.

Who it suits: engineers who have written CUDA / Metal / SIMD kernels, can read the GGUF quantization format, and are willing to spend a month or two sharpening one narrow tool. Also people who want "I built something that beat llama.cpp" on an ML systems resume.

Who it doesn't suit: people hoping to gather stars through packaging and polish. Ollada's 2 stars in two weeks already show this crowd rewards benchmarks, not "easy to use."

How to do it, ranked by how worthwhile:

1. Build the platform nobody's covered: Apple Silicon. mojo-dllm only supports Linux x86, and Mac users are a large share of people running models locally. Writing a diffusion-specific runtime in Metal or MLX, with a headline table comparing M-series chips against llama.cpp Metal, is the most direct gap.
2. Chase the newest diffusion models. DiffusionGemma just came out, NVIDIA just released a quantized version, and mojo-dllm has only gotten as far as tokenizer alignment. Whoever first runs the new model fastest locally, with verifiable numbers, captures this wave of attention. It also still lists block diffusion models as "in research."
3. Apply the playbook to another new language or model category. The same structure (a newly open language or platform, plus a category a big framework only covers incidentally, plus a same-machine comparison against the incumbent) can be reused elsewhere. Before picking a topic, check two things: the big framework really isn't optimized for it, and you really can beat it.

How to get users: copy the two things it did best. First, put the benchmark table on the first screen of the README, commit the result files, validate them in CI, and publish the slow numbers too. Second, cut the issues into pieces "you can finish without knowing the codebase," label the difficulty, and recruit on your personal page. External PRs make a project look alive, and contributors bring stars with them. One thing it didn't do that you can add: post a clear explanation of "why it's fast" on r/LocalLLaMA and the Modular forums / Discord. It reached over 300 stars without a post, so posting will likely add more (inference).

Timing: inference says now is worth it, before the first half of 2027. Mojo just opened up and diffusion models are hot, so this is the stage where whoever shows evidence first wins. Once llama.cpp or MLX officially optimize diffusion models in earnest, the benchmark edge of a specialized runtime disappears.

What would show I got it wrong: (1) if llama.cpp merges dedicated diffusion optimizations within a few months and closes the CPU gap, the opening was temporary, and points 2 and 3 need a new angle; (2) if mojo-dllm's stars flatline in the hundreds over the next few weeks instead of climbing, it means the early-November surge was mostly contributors and aggregator coverage, and this topic's natural ceiling is lower than it looks; (3) if someone ships a Mac version that reaches a thousand stars within a month, demand is bigger than estimated here, and point 1 needs to be acted on quickly, or you should build complementary tools around it.

Data and sources

GitHub: vladimirrott/mojo-dllm repo page, README, benchmark result files, issue and PR lists, daily stars (10-30 to 11-06); author homepage github.com/vladimirrott and the maintainer-agent repo; lacs-project/sysknife daily stars; similar repo stars (11-06). Search on X, Hacker News, Reddit, and the Modular forum (11-06). Aggregator sites: news.micker.com.cn, github.devotd.net, aiboss88.com, aibytecore.in. Competitors: llama.cpp examples/diffusion, the Ollada post on dev.to, the lmsys.org diffusion LLM blog (2025-12). Timing: Modular blog (Mojo 1.0, MAX license), byteiota (Mojo 1.1), the-decoder (DiffusionGemma), Hugging Face (NVIDIA NVFP4 version). Where it says "inferred" or "unverified," that is inference or unverified.