This is a teardown of one repository, not another buying guide. VRAM sizing and card budgets belong to the VRAM sizing SOP; per-million-token API pricing belongs to the pricing review; the cua computer-use resource is a different open-source project for driving a desktop; and the Hy4 preview self-hosting SOP follows the vLLM and SGLang server path. None is about the same thing. This piece stays with one GitHub project: what it is, how to install it, how the tiering works, what the license allows, which models it runs, and where the boundaries lie.
That project is JustVugg/colibri, a hierarchical MoE inference engine written in pure C. Its home is the colibri repository, the address to trust when cloning or downloading: https://github.com/JustVugg/colibri. A GitHub snapshot taken on November 4, 2026 lists a main branch, C as the primary language, 47,567 stars and an Apache-2.0 license; the repo was created on July 1, 2026 and last pushed on November 4, 2026. A daily AI research digest dated November 2, 2026 recorded roughly 655 stars for the day, and a GitHub trending list dated November 3, 2026 included it too.
How does a model with hundreds of billions of parameters run on a machine with no discrete GPU and only a two-digit amount of RAM? That is what colibri is built around. Its tagline is Tiny engine, immense model, and its description calls it a hierarchical inference engine for frontier MoE models. Six sections follow: what it is, the three tiers, the engines, the install, the demo and license, and the timing.
What it is: a tiny engine for an immense model
colibri is a local inference engine written in pure C, one file per model family, with no GPU required. The install section below corrects the phrase zero dependencies.
The idea rests on MoE sparsity: a model huge on disk uses only a small slice of itself per token. The README uses GLM-5.2 as the example, 744B parameters, about 40B active per token, and only about 11 GB of routed experts changing between tokens. The dense part, attention, shared experts and embeddings, stays in RAM; routed experts stay on disk and are read when the router asks for them, behind a cache that learns which experts your work uses. The model need not fit in fast memory, it has to be placed. Where a weight sits decides speed, not which weights or router decisions produce the answer.
The README gives three reasons: run models this size on hardware people own, show every expert firing on a dashboard, and keep the engine small enough to measure and improve. As an open research platform, an optimization earns its place only through reproducible end-to-end measurement, and the default policy never silently changes precision or router semantics. Less fast memory may cost speed, never a quietly different model.
The three tiers: hot, warm, cold experts
The description compresses the mechanism into one line: hot experts on the GPU (CUDA, Vulkan), warm ones in RAM, cold ones streamed from NVMe.
The hot tier is GPU VRAM, holding the most frequently routed experts and dense layers: NVIDIA cards take CUDA, any GPU with a Vulkan 1.2 driver takes Vulkan, covering discrete and integrated cards from AMD, Intel and NVIDIA. The warm tier is system RAM with the resident dense part and recently used experts. The cold tier is disk, NVMe above all, where a fast drive matters most for large models. The README is explicit that an expert answered from VRAM, RAM or disk gives the same answer; only speed changes.
Every layer of every token walks five steps: route, union, place, overlap, learn. Measured routing heat decides which experts rise to VRAM, stay in RAM or fall back to disk, via a per-layer LRU cache plus a pinned hot set learned from your conversations in .coli_usage, updated each turn, so colibri gets faster with use. Prefetch reads an expert's three matrices in one pread, fetches missing experts while resident ones compute, and looks ahead a layer. Waiting twice for the same disk read is what the design avoids.
13 engines and the models they cover
The README lists thirteen engines, and the source tree holds exactly thirteen .c files, one per model family over shared headers. That gives 13 engines in three groups.
Ten are language-model engines: GLM-5.2 and GLM-5.3 share one, which also runs Mistral-Large-4; then GLM-5.3-Flash, Inkling, Kimi K3, DeepSeek V4 Flash, DeepSeek V4.1 Flash, MiMo-V2.6 Flash and Pro, Qwen3.8-Flash-Next, Qwen3.6 (also Qwen3-Coder, dense Qwen3.8-27B, Flint, Muse Spark Open, LFM3-VL) and OLMoE. One draws pictures, Qwen-Image-2.1. Two answer decisions, Laya and GLiNER2.5-Decide, with a third, Clef, on the Qwen3.6 engine. Checkpoints sharing a supported architecture, such as KAT-Coder v2.5, run unchanged.
colibri reads published GGUF files directly. ./coli import takes the first shard and writes a model directory beside it, with no reconversion or requantization, blocks running as held from IQ1_S to Q8_0, F16, BF16 and MXFP4; every chat engine understands GGUF too. Pure CPU is fine, any GPU goes through Vulkan, NVIDIA cards through CUDA.
One point needs stating plainly. These 13 engines are a general-purpose local engine list for MoE models of this scale, and the model at the center of this batch's trending coverage is not on it. That coverage is about the model; colibri is about an engine hosting models of this class. There is no support relationship, so a general engine is not a deployment recipe for one specific model. Check a name against the README's engine list and sizing tables first. The demo's 744B is separate, covered next.
From download to chat: three steps and the wizard
The README's floor is 8 GB of RAM, 16 GB or more recommended, 22 GB free on disk for the smallest model, an internet connection, and an optional graphics card. That is only the bar for getting installed; per-model RAM needs are listed separately in the sizing tables by machine class.
The install is compressed into three steps. On Windows, click Code, choose Download ZIP, unzip, double-click START-HERE.bat; if Python is missing the script offers to install it. On Linux, using Ubuntu and Debian, four commands form one chain, other distributions swapping package names:
sudo apt install git python3 build-essential
git clone https://github.com/JustVugg/colibri
cd colibri
./start-here.shOn macOS the route is Homebrew: xcode-select --install, brew install libomp git python, clone, then ./start-here.sh. All three platforms end at one entry script, START-HERE.bat on Windows, start-here.sh on Linux and macOS.
The wizard does three things. It looks at your machine, RAM, free disk, CPU and GPUs. It recommends a model that fits, the resident part plus a minimum expert cache in RAM and the download on disk, both required. It gets the engine, building locally when a compiler exists, otherwise downloading a prebuilt binary; on Linux it builds CUDA only for an NVIDIA card with the CUDA toolkit, else Vulkan or pure CPU, and an integrated GPU sharing CPU RAM enables Vulkan only for models measured faster there. It then downloads with progress and resume, starts the service, opens the dashboard, and prints local OpenAI- and Anthropic-compatible endpoint addresses. Run the same script again and colibri starts immediately, no download, no build.
A correction: pure C with zero dependencies is press shorthand, not the README's claim. The engine is one C file per model family with no BLAS and no Python at runtime, but Python runs the setup, launcher, converters and API gateway; Linux needs git, python3 and build-essential, macOS needs libomp, git and python, and prebuilt binaries ship with the repo. The precise statement is written in pure C with no GPU required. Treating zero dependencies as a runtime guarantee is where press phrasing and README stop matching.
The README demo and the license boundary
A terminal demo tops the README. Run ./coli chat and the screen shows colibri v2.1.0, GLM-5.2, 744B MoE, int4, streaming CPU, with ready in 32s and resident 9.9 GB, then an Italian greeting and reply. Read it as a README demo output: GLM-5.2, a 744B MoE model, is the engine's own reference model, not the model in this batch's trending coverage, so do not map one onto the other; 32s and 9.9 GB are readings from one machine and one int4 configuration, not a performance promise or a benchmark to compare across. The demo line carries a check mark, rendered here in words as showing ready in 32s. The README also has measured tables by machine class and a benchmarking protocol; this article flattens none of them into a single speed figure.
The LICENSE file is the Apache License, Version 2.0, Copyright 2026 Vincenzo Fornaro, that is Apache-2.0, with no separate commercial threshold for the engine. But engine and models differ: the engine is Apache-2.0, while each model keeps its authors' license, with the README noting GLM-5.2 weights from Z.ai under MIT and Qwen-Image-2.1 for non-commercial use only. Those are model licenses, not the colibri engine's, and conflating them misleads. NOTICE and THIRD_PARTY_NOTICES.md cover third-party code.
Why it is trending now
A CSDN DevPress daily AI research digest dated November 2, 2026 recorded JustVugg/colibri at roughly 655 stars for the day, describing pure C with zero dependencies running frontier MoE models with experts streamed from disk, where zero dependencies follows the correction above. A Toutiao GitHub trending list dated November 3, 2026 included it too. On GitHub, pushed_at is November 4, 2026, with 47,567 stars in one snapshot and 47,569 in another, so about 47.6 thousand is fair. A repo created on July 1, 2026 reaching that scale in four months rides a broad question: can a model with hundreds of billions of parameters run on a machine you own. It shares this batch's wave of attention, but stays focused on this engine.
FAQ
Q1: Is colibri pure C with zero dependencies, and does installing it need Python or a compiler? A1: The engine is pure C, one C file per model family, with no BLAS or Python at runtime, but the install chain is not dependency-free. The README has Python running the start-here scripts, Linux needing git, python3 and build-essential, macOS needing libomp, git and python, and prebuilt binaries provided. The precise claim is written in pure C with no GPU required; zero dependencies is press shorthand.
Q2: Can it run without a discrete GPU, and what do 8 GB, 16 GB and 22 GB mean? A2: Yes. The README says no GPU is needed and every engine runs on CPU alone; a GPU is just a faster place for weights. 8 GB of RAM is the machine-wide floor, 16 GB or more is better, 22 GB is free disk for the smallest model, and the card stays optional. That is only the startup bar. Per-model RAM is listed in the sizing tables by machine class, and the 744B tier asks for far more than 8 GB, so the floor is not a universal setting.
Q3: Which models does it support, and how does it relate to this batch's trending model? A3: The 13 engines cover GLM, Kimi, DeepSeek, Qwen, MiMo, Inkling, Mistral-Large-4, OLMoE and LFM3-VL, plus Qwen-Image-2.1 and the Laya, GLiNER2.5-Decide and Clef decision models. It is a general-purpose local engine list for MoE models of this scale; the model in this batch's trending coverage is not on it, there is no support relationship, and it is not a deployment recipe for one specific model. Check a name against the README's engine list and sizing tables first.
Q4: What do 744B, 32s and 9.9 GB in the README demo mean? A4: A README demo output. Running ./coli chat shows colibri v2.1.0, GLM-5.2, 744B MoE, int4, streaming CPU, with ready in 32s and resident 9.9 GB. GLM-5.2, a 744B MoE model, is the engine's own reference model, not the model in this batch's trending coverage; 32s and 9.9 GB are readings from that example configuration, not a promise or a benchmark. The README also has measured tables by machine class, which this article does not flatten into one speed figure.
Q5: Does Apache-2.0 allow commercial use, and what license do the model weights have? A5: The LICENSE text is the Apache License, Version 2.0, Copyright 2026 Vincenzo Fornaro, that is Apache-2.0, with no separate commercial threshold for the engine. Keep two layers apart: the engine is Apache-2.0, each model keeps its authors' license, with the README noting GLM-5.2 weights from Z.ai under MIT and Qwen-Image-2.1 for non-commercial use only. Read a model's own license too.
Related reading
- API pricing review - what cloud calls cost when you would rather not manage hardware.
- Hy4 official release coverage - this batch's trending line, about the model release, not a local engine.
- Vision input comparison - multimodal input capability, useful for placing a drawing model such as Qwen-Image-2.1.