A developer built a way to run a 744-billion-parameter AI model on a laptop. I think that is insane.
The developer goes by JustVugg, and the project is called Colibri. According to its README, it began as a one-person project on a laptop with 12 CPU cores and 25 GB of RAM. That is the achievement that caught my attention: getting an enormous AI model running on a computer with so little working memory.

Colibri’s README. This guide focuses on the 744B model; the larger models have different hardware requirements.
Colibri runs an already-trained model by keeping most of it on storage and loading the pieces it needs into memory. You still need hundreds of gigabytes of storage, and the original setup was painfully slow. The project reports roughly 10–20 seconds per token, a small piece of text, in those early tests. The original results and their limitations.
But getting it running at all is what makes me stop and think. If this is what one developer could get started, what happens over the next six to twelve months as more people work on making it faster and better?
Suppose that progress eventually gets us to a $2,000–$3,000 computer at home that can run a giant model at a speed you would actually enjoy using. How much AI work would you still pay a cloud service to do? How much expensive GPU hardware and fast memory would buyers still need for that work?
That is where this becomes a bigger story. Could a project like Colibri be an early sign of trouble for the companies behind the trillion-dollar AI infrastructure bet? It has not proved that shift is coming. But it gives us something concrete to watch.
The assumption worth challenging
In March 2026, NVIDIA CEO Jensen Huang wrote:
“Trillions of dollars of infrastructure still need to be built.”
That is his view of the industry's future infrastructure needs, not a claim that NVIDIA has already spent trillions. Read the original.
Now put another possibility beside it: developers finding ways to run useful AI with less expensive hardware per task. If that progress is fast enough, buyers could reconsider which machines they need, how much fast memory they need, and how much work they need to rent from someone else's data center.
I think that is the potentially disruptive part of Colibri. Running a giant model on limited hardware is impressive. Making that model useful enough to change a purchasing decision would be a much bigger deal.
Where NVIDIA and memory makers could feel pressure
The first pressure could come from buyers who can move some everyday AI work onto computers they already own. A small company might handle certain document or coding tasks locally. A developer might experiment without renting a larger machine. Those are possibilities, not outcomes this project has established.
If the local option meets their needs, some buyers could spend less on premium GPUs or cloud inference, the process of using an already-trained model. Suppliers would have to compete with a cheaper way to get that work done.
Memory is a more complicated story. Colibri shifts work across GPU memory, ordinary RAM and storage. It still needs substantial storage, and faster SSDs can help. Some memory companies sell several of those products. Micron, for example, supplies high-bandwidth memory, DRAM, NAND and SSDs. A shift away from one expensive configuration could create demand for another.
There is also a plausible outcome where cheaper AI leads people to use much more of it. Hardware needed for each task could fall while total demand grows. NVIDIA already promotes local AI on its own hardware, so it could benefit from that market too.
Training new models and serving large numbers of users quickly still require substantial computing resources. What remains open is how much of our everyday AI work will need to happen on expensive shared infrastructure.
Why the next 6–12 months matter
It is easy to look at a slow demonstration and move on. I want to watch how much hardware developers need for the same useful result as the software improves.
Over the next six to twelve months, I will be looking for three things:
Useful speed on a complete $2,000–$3,000 setup. Count the computer, RAM and SSD, then measure how long a real answer takes.
Quality that holds up. A faster result matters only if the model still does the job well.
Results other people can repeat. Different prompts, longer conversations and ordinary users should work too.
Developers can improve caching, reduce unnecessary data movement and make better use of the CPU and GPU together. Colibri's team is testing those ideas in the open. Some experiments help; others do not. Storage bandwidth remains a physical limit. The project's open experiments.
Six to twelve months could bring meaningful progress. It could also expose limits that take much longer to solve. Nobody has established a reliable date for giant models to become comfortable everyday tools on a $3,000 home computer.
But if that threshold arrives sooner than expected, the question for hardware companies becomes how much buyers will pay for capabilities they can now get another way.
What Colibri makes possible today
Colibri is free, open-source software for running supported AI models. Think of it as the player. The model you download is what the player runs.
One of its reference models is GLM-5.2, with 744 billion parameters. Parameters are the numbers a model learned during training. More parameters alone do not guarantee better answers, but 744 billion gives you a sense of the scale.
Colibri supports specific downloadable models. It does not give you the private models behind ChatGPT, Claude or Gemini.

Project screenshot: Colibri's chat dashboard. The README identifies this demonstration as a six-RTX-5090 setup. The 4 tokens/second shown here is not a performance promise for a home PC. Source and hardware context.
How a giant model runs with less memory
Imagine a library with thousands of books and a small desk. You can work without putting the whole library on the desk. You fetch the books you need, keep useful ones nearby, and swap others out.
Colibri uses a similar approach with a type of model called a Mixture of Experts. The model selects different groups of calculations, called experts, as it generates an answer. GLM-5.2 uses roughly 40 billion of its 744 billion parameters for each token, a small piece of text.
The SSD holds the model files. RAM, your computer's working memory, keeps the always-needed parts and a cache of experts. A supported GPU can add another fast layer. Colibri loads experts when needed and tries to reuse or fetch them ahead of time. The project's explanation.
You still store the model. You just need less of it in fast memory at once. Moving data from storage takes time, which is a big reason answers can arrive slowly.
The suggested download also uses quantization: storing the model's numbers with less precision to reduce its size. That can affect answer quality. Loading those same compressed weights from an SSD does not restore the original full-precision model.

Project screenshot: the Brain view visualizes experts, where they live in memory, and which ones the model uses. It is a diagnostic view, not a picture of the model thinking like a human. Source.
The speed problem is real today
The uploader of the recommended GLM-5.2 conversion reports about 0.89–0.96 tokens per second with an RTX 5080 and 128 GB of RAM, and about 0.62 tokens per second on CPU alone in their tests. Those are uploader-reported results on specific hardware, not a speed guarantee. Model card and measurements.
At one token per second, generating 300 tokens takes about five minutes, plus the initial wait while the computer processes your prompt. A token might be a word or only part of one. A lower-memory machine or slower drive can take much longer.
These figures and screenshots come from the project and its community. I have reviewed the documentation, but have not benchmarked this setup myself. The community reports show how early this still is:
“This way I can get web page open and Kimi works.”
Limalski, August 12, 2026, describing a working Kimi setup through Colibri's browser interface. This was a different model, and the discussion includes setup troubleshooting.
“The response prints to the terminal very slowly.”
tonybarbieri, July 27, 2026, asking for optimization help after getting a Mac setup running. These are community reports, not professional reviews.
Several teams are working toward more accessible AI
Google's Gemma 3n is designed for phones and other everyday devices. Google describes model memory footprints as low as 2 GB or 3 GB for its two variants with the right implementation. That is the model's memory footprint, not the total RAM the whole device needs.
Alibaba's Qwen3 release spans small models and much larger ones, with documented local-running options. DeepSeek-V3 is another giant Mixture-of-Experts example: 671 billion total parameters, with 37 billion active per token.
These teams tackle different parts of the problem. Google is designing smaller models for constrained devices; Chinese teams such as Qwen and DeepSeek have expanded the range of available open models. Colibri explores running enormous compatible models with less fast memory. Together, these efforts give us several routes toward more capable AI on hardware we can own.
Try it yourself: the beginner setup guide
Treat this as a hands-on experiment. You do not need to know how to program, but you will copy a few commands into Terminal on a Mac or Linux computer, or PowerShell on Windows.
Memory: I would start with 24–32 GB of RAM or more. The quickstart advertises a 16 GB floor, but the benchmark notes do not establish a successful large-model run on the cited 16 GB machine. Closing other apps will leave more room.
Storage: allow at least 500 GB of free space on a fast SSD for this walkthrough. That is my headroom recommendation. The linked model's Files page currently lists 429 GB, despite the README's older 372 GB estimate.
Internet: expect a download of hundreds of gigabytes. Check your data allowance and allow hours, depending on your connection.
Graphics card: optional for the CPU setup below. GPU acceleration requires the appropriate backend and configuration.
Step 1: Get the ready-made program
Open Colibri's v1.11.0 release, checked on September 14, 2026. Expand Assets and pick the file for your computer:
Mac with an M-series chip: colibri-v1.11.0-macos-arm64.tar.gz
Modern 64-bit Windows PC:
colibri-v1.11.0-windows-x86_64.zipModern 64-bit Linux PC: colibri-v1.11.0-linux-x86_64.tar.gz
Extract the archive into a folder on your fast SSD. Keep its files together. The same folder will hold the model download, so choose a drive with enough space. The Windows and Linux archives require an Intel/AMD processor with x86-64-v3 (AVX2-class) support. These ready-made downloads do not cover Intel Macs or ARM Windows/Linux computers; check the project’s platform documentation before proceeding.
Step 2: Install Python and open the folder
Install Python 3.10 or newer if you do not have it. Python runs the launcher and local browser interface. You do not need to learn Python to follow this guide. Version requirement.
Open a terminal in the extracted folder, the one containing the file named coli. On Windows, right-click inside that folder and choose Open in Terminal. On a Mac, open Terminal, type cd followed by a space, drag the extracted folder into the window, and press Enter.
Copy the block for your operating system below. These commands create a small, separate tools folder, install the downloader, and check that Colibri can find its engine.
Mac / Linux
python3 --version
python3 -m venv .venv
.venv/bin/python -m pip install --upgrade huggingface_hub
.venv/bin/python coli infoWindows PowerShell
py -3 --version
py -3 -m venv .venv
.\.venv\Scripts\python.exe -m pip install --upgrade huggingface_hub
.\.venv\Scripts\python.exe .\coli infoThe first line should show Python 3.10 or later. Stop and fix any error before proceeding to the big download.
Step 3: Check the download first
Use this exact community conversion. The long name identifies the model format the project recommends. A different GLM download may not work with these instructions.
This command checks the files and download size without downloading the model:
Mac / Linux
.venv/bin/hf download mastouri/GLM-5.2-colibri-int4-g64-with-int8-mtp --local-dir models/glm52 --dry-runWindows PowerShell
.\.venv\Scripts\hf.exe download mastouri/GLM-5.2-colibri-int4-g64-with-int8-mtp --local-dir models/glm52 --dry-runConfirm that your drive has enough free space for the reported total, with room left over. Hugging Face's downloader instructions.
Step 4: Download the model
This is the hundreds-of-gigabytes step. Run the same command from Step 3 after removing --dry-run from the end. Keep the computer awake and wait for the download to finish.
The downloader saves the model inside models/glm52 in your Colibri folder. If the download stops, run that same command again. Hugging Face checks existing files so it does not need to fetch completed, unchanged files again.
Step 5: Check it, then open the chat
Run the first line below and read the readiness report. If it reports missing files or libraries, resolve those before running the second line, which starts Colibri and opens its local dashboard.
Mac / Linux
.venv/bin/python coli doctor --model models/glm52
.venv/bin/python coli web --model models/glm52Windows PowerShell
.\.venv\Scripts\python.exe .\coli doctor --model models/glm52
.\.venv\Scripts\python.exe .\coli web --model models/glm52Keep the terminal open while you use the chat. If the browser does not open, use the local address printed in the terminal. Start with: “Say hello in one sentence.” Give it time to load and answer. To stop the server, return to the terminal and press Ctrl+C. Local dashboard documentation.
Step 6: Fix the common first-run problems
Cannot find coli: your terminal is probably in the wrong folder. Return to the extracted folder containing that file.
Missing model files: check that the download finished and that you are still using the same Colibri folder.
Mac reports missing libomp: this is a helper library. If you use Homebrew, install it with brew install libomp, then repeat the check.
Ubuntu/Debian reports a missing OpenMP runtime: the documented runtime package is sudo apt install libgomp1. If Python cannot create the tools folder, you may also need sudo apt install python3-venv.
It works, but barely moves: try a short prompt, close memory-heavy apps and check the drive. A slow response can be the hardware limit, not an installation mistake.
Could this be the beginning of trouble for the hardware giants?
I think it could challenge the economics of some AI workloads if developers can turn these experiments into reliable, affordable tools. That is a possibility worth taking seriously while the technology is still awkward to use.
The next six to twelve months will give us more evidence. I want to see whether improvements change what people can accomplish on a fixed budget, and whether they start choosing local hardware for work they would otherwise send to the cloud.
Some GPU purchases could become harder to justify. More RAM and faster storage could become more attractive. Or cheaper AI could expand usage enough to reward the same suppliers. We do not yet know which effect will dominate.
If you want to explore these tools as they develop, you are welcome to join us in AI Builders.
How long before a $2,000–$3,000 computer at home can run one of these ginormous models at a speed you would enjoy using? And when it can, how much of today's expensive AI hardware will we still need for that work?
