Some tech demos whisper. Others kick open the beige plastic door, boot with a cheerful Windows 98 startup sound, and ask a 26-year-old Pentium II to generate text like it just wandered out of an AI conference. That is the charm of the experiment behind Modern AI On Vintage Hardware: LLama 2 Runs On Windows 98: a modern language-model architecture squeezed into an operating system from the dial-up era, running on hardware that once considered a CD burner a luxury item.
The project, demonstrated by EXO Labs and later covered by retrocomputing and hardware outlets, is not about replacing data centers with dusty desktops from the attic. Nobody is suggesting your old family PC should become the next enterprise AI platform, unless your enterprise specializes in Minesweeper and printer-driver trauma. The point is more interesting: AI inference can be surprisingly portable when software is simplified, models are small, and engineers are stubborn enough to argue with legacy compilers until something works.
In a world where artificial intelligence is often associated with massive GPUs, cloud subscriptions, and cooling systems that sound like jet engines, seeing Llama 2 on Windows 98 feels wonderfully rebellious. It reminds us that modern AI is not only about scale. It is also about efficiency, openness, local computing, and the ancient programming magic of “just make it run.”
What Actually Happened?
EXO Labs set out to run a small Llama-style language model on a Windows 98 Pentium II machine with 128 MB of RAM. The computer was old enough to have opinions about USB devices, which is another way of saying the team had to use PS/2 peripherals. Getting files onto the machine also required a step back in time: FTP over Ethernet, with modern conveniences politely shown the door.
The team used llama98.c, a modified version of Andrej Karpathy’s llama2.c, an educational pure-C inference engine designed to run Llama 2 architecture models with minimal dependencies. In normal modern development, we casually assume newer compilers, modern C features, memory mapping, and operating systems that do not panic when handed a contemporary workflow. Windows 98 is not that friend. It is the friend who still has every cable from 1999 and somehow needs all of them.
To make the demo work, the code had to be adjusted for the realities of old C tooling and the Windows 98 environment. The team used Borland C++ 5.02, avoided modern language features, moved variable declarations to the start of functions, replaced unsupported timing calls, and simplified model loading. The result was not a toy screenshot. It ran.
The Hardware: A Pentium II Walks Into an AI Lab
The machine at the center of the experiment was a Windows 98-era PC powered by an Intel Pentium II processor and 128 MB of RAM. For perspective, many modern browser tabs can consume more memory than this entire computer had available. A typical smartphone today is not just faster than this machine; it is faster in a way that feels rude to mention at family gatherings.
Yet the old system generated text using a tiny Llama 2 architecture model. Reported results showed a 260K-parameter model producing roughly 39 tokens per second, while a larger 15M-parameter model ran at about one token per second. That second number sounds slow until you remember the machine was built for an era when watching a JPEG load line by line felt normal.
Why the Model Size Matters
Here is the important caveat: this was not the full-size Llama 2 model that people associate with modern AI chatbots. Meta’s Llama 2 family includes models with billions of parameters, including 7B, 13B, and 70B versions. Those models require far more memory and compute than a Windows 98 Pentium II can provide. The Windows 98 demo used very small Llama-style models, often trained on narrow or simplified datasets.
That does not make the achievement fake. It makes it technically meaningful. AI models are not one-size-fits-all beasts. A huge general-purpose chatbot and a tiny story-generation model are different tools, just as a cargo ship and a canoe are both boats but only one belongs in your garage. Small language models can still demonstrate grammar, structure, and basic coherence when their domain is narrow enough.
How Llama 2 Fits Into the Story
Llama 2, released by Meta in 2023, became a major milestone for open-weight AI development. It gave researchers, developers, hobbyists, and companies a powerful family of language models to study and deploy under defined licensing terms. While the full Llama 2 models are large by vintage-computing standards, the architecture inspired a wave of experimentation around smaller models, local inference, and simplified runtimes.
Karpathy’s llama2.c captured this spirit beautifully. Instead of wrapping AI inference in layers of infrastructure, it showed that a Llama-style model could be trained and run with a surprisingly small amount of code. That educational minimalism is exactly why the Windows 98 experiment was possible. When the software is lean enough, old machines have fewer excuses to hide behind.
The Porting Challenge: Modern AI Meets Old C
Running AI on old hardware is not as simple as copying a file and double-clicking it. The operating system, compiler, CPU instruction set, file system, networking tools, and memory model all get a vote. Unfortunately, many of them vote “absolutely not.”
One of the most interesting parts of the Windows 98 Llama demo was the porting process. Modern C and C++ projects often rely on features that old compilers do not understand. Windows 98 also predates many assumptions built into today’s software. Some modern binaries may use CPU instructions or system calls that older machines cannot handle. Even if the source code is small, the surrounding software ecosystem can be a minefield.
EXO Labs avoided much of that problem by leaning into pure C. The team worked with a vintage compiler that could run directly on Windows 98. They changed code patterns that were normal today but awkward or unsupported in that environment. This is the sort of engineering work that looks simple only after someone else has done it. Before that, it is mostly coffee, error messages, and muttering at beige plastic.
Why FTP Was the Unsung Hero
File transfer became its own subplot. Modern USB storage was not a friendly option. Old systems can be picky about file systems, storage size, drivers, and peripherals. FTP, however, survived the decades with impressive grace. By connecting the Windows 98 machine over Ethernet to a modern computer, the team could move model weights, tokenizer files, and code across the network.
This is a lovely detail because it shows how durable simple protocols can be. FTP is not glamorous. It will not appear in a keynote wearing a black turtleneck. But in this case, it did the job while shinier tools sat outside looking confused.
Why This Demo Matters
The obvious reaction is amusement. A modern AI model on Windows 98 sounds like a meme wearing a lab coat. But the deeper lesson is about local AI. The more AI can run on ordinary devices, the less dependent users become on remote servers, constant internet connections, and centralized platforms.
Local inference has several practical advantages. It can reduce latency because prompts do not have to travel to a distant server. It can improve privacy because data can stay on the device. It can lower recurring costs for simple tasks. It can also make AI available in environments with poor connectivity, strict security rules, or limited budgets.
Of course, running a tiny model on a Pentium II is not the same as running a competitive general-purpose assistant. But it proves an important concept: the lower bound for AI inference is lower than many people assume. With the right model, the right runtime, and the right expectations, useful language generation can happen on surprisingly modest hardware.
Small Language Models Are Not a Joke
Large language models get most of the attention because they are impressive generalists. They can write, summarize, reason, code, translate, and occasionally hallucinate with the confidence of a man explaining cryptocurrency at a dinner party. But small language models have their own role to play.
A small model trained for a narrow task can be useful, efficient, and easier to deploy. Think of text autocomplete for a specialized app, command interpretation for embedded systems, simple story generation, offline documentation search, or controlled natural-language interfaces for industrial tools. Not every AI job requires a giant model. Sometimes you need a pocketknife, not a bulldozer.
Research around datasets like TinyStories has shown that small models can produce surprisingly coherent text when trained on carefully constrained material. That idea connects directly to the Windows 98 Llama experiment. A tiny model cannot know everything, but it can still perform a narrow language task convincingly enough to prove that model design and training focus matter.
The Retrocomputing Angle
Retrocomputing is often misunderstood as pure nostalgia. Yes, there is nostalgia involved. Beige towers, CRT monitors, floppy drives, and the sound of a hard drive seeking like a tiny mechanical squirrel are part of the appeal. But retrocomputing is also a form of technical archaeology. It reveals how much modern software depends on layers of abstraction, and how much can still be done when those layers are stripped away.
Running Llama 2 architecture models on Windows 98 forces engineers to confront fundamentals: memory, CPU instructions, file formats, compiler behavior, and operating-system limitations. It is educational because the machine refuses to hide complexity. Modern systems often make development feel seamless, which is wonderful until something breaks and nobody knows which abstraction is crying.
On vintage hardware, the machine tells you exactly where the limits are. Sometimes it tells you by crashing. Sometimes it tells you by refusing to recognize your mouse. Either way, it is honest.
What This Says About AI Efficiency
The AI industry has spent years chasing bigger models, larger datasets, and more powerful accelerators. That work has produced astonishing capabilities, but it also raises questions about cost, power consumption, accessibility, and centralization. The Windows 98 Llama demo lands at the opposite end of the spectrum. It asks: how small can we go and still get something interesting?
That question is becoming more important. Quantization, efficient inference engines, CPU-focused runtimes, and 1-bit model research all point toward a future where AI runs across many kinds of devices. Projects such as llama.cpp, llamafile, BitNet, and other local AI tools are part of the same broad trend: make inference lighter, simpler, and more portable.
The future of AI will probably not be only cloud or only local. It will be mixed. Huge frontier models will live in data centers, while smaller specialized models will run on laptops, phones, edge devices, robots, appliances, and maybe the occasional museum-grade PC brought back from retirement.
Practical Examples of Where Tiny Local AI Could Help
Imagine a factory tool that needs to understand a small set of maintenance commands without sending data outside the building. A specialized small language model could interpret technician notes or generate simple troubleshooting steps locally.
Consider educational toys or offline reading devices. They do not need a massive general-purpose chatbot. They may only need to generate age-appropriate stories, answer simple questions, or adapt prompts to a narrow curriculum. A small, controlled model is often safer and cheaper for that kind of use.
Think about accessibility tools in low-connectivity areas. Offline text prediction, simple summarization, or voice-command interpretation could be valuable even on limited hardware. The Windows 98 demo is extreme, but the principle applies to old laptops, budget phones, school computers, and embedded systems.
Developers also benefit from these experiments. Minimal inference code is easier to inspect, debug, teach, and modify. It turns AI from a mysterious cloud service into something closer to ordinary software. That matters for education, trust, and innovation.
The Limits: Let’s Not Get Carried Away
It is tempting to treat this demo as proof that any old computer can run “AI.” That would be overstating things. The model was tiny. The output quality is not comparable to modern cloud-based assistants. Larger models slow down dramatically, and full-scale Llama 2 models are far beyond what 128 MB of RAM can handle.
Security is another issue. Windows 98 has been out of support for many years and should not be connected casually to the modern internet. Any experiment like this belongs in a controlled environment, preferably isolated from real personal data and public networks. Vintage computing is fun; turning an unsupported operating system into your daily online workstation is less “retro chic” and more “please enjoy this malware buffet.”
Still, limitations do not erase the value of the experiment. They define it. The point is not that Windows 98 is secretly a modern AI workstation. The point is that AI inference can be reduced, adapted, and understood at a smaller scale than the hype cycle usually suggests.
Why Developers Love Experiments Like This
There is a special joy in making software run somewhere it was never expected to run. It is the same spirit that puts Doom on calculators, Linux on strange devices, and retro games on hardware that was originally designed to display restaurant menus. These projects are playful, but they are not pointless.
They reveal assumptions. They expose hidden dependencies. They teach optimization. They inspire better tools. Most importantly, they make technology feel approachable again. A 700-line C inference engine is easier to reason about than a cloud AI stack spread across containers, services, APIs, dashboards, and billing pages that look calm until the invoice arrives.
The Llama 2 Windows 98 project is part of that tradition. It says: take the big idea, strip it down, make it visible, and see where it can go. Sometimes it goes all the way back to 1998.
Experience Section: What It Feels Like to Run Modern AI on Vintage Hardware
Working with a project like Modern AI On Vintage Hardware: LLama 2 Runs On Windows 98 feels less like installing software and more like negotiating with a time traveler. Modern development teaches us to expect instant downloads, package managers, fast compilers, searchable error messages, and hardware that can brute-force small mistakes. Vintage hardware teaches patience. It also teaches humility, usually within the first five minutes.
The first experience is physical. You notice the weight of the machine, the yellowed plastic, the ports that no longer appear on modern laptops, and the oddly satisfying click of old peripherals. A PS/2 keyboard does not feel like a lifestyle accessory; it feels like equipment. The computer boots slowly enough that you have time to reflect on your choices. Then Windows 98 appears, and suddenly the whole project becomes charming in a way no virtual machine can fully reproduce.
The second experience is friction. Nothing is automatic. A modern USB drive may not work. A file may be too large. A compiler may reject syntax that would pass without complaint today. A timing function may not exist. A memory-loading method may fail. Each problem is small on its own, but together they create a puzzle box. That puzzle is the real fun. You are not merely running AI; you are rebuilding the bridge between eras.
The third experience is surprise. When the model finally begins generating text, even slowly, it feels slightly absurd. This old PC was never meant to participate in the age of large language models. It was born into a world of dial-up connections, bundled screensavers, and software boxes big enough to store camping gear. Watching it produce tokens is like seeing a retired typewriter learn jazz. You know the result is limited, but the fact that it works at all is delightful.
The fourth experience is perspective. Modern AI often feels distant because it lives behind APIs, cloud dashboards, corporate product names, and enormous infrastructure. On Windows 98, the illusion disappears. You can see the files. You can inspect the code. You can understand the compromises. The model is no longer magic vapor floating in a data center; it is math, memory, loops, and text output. That makes AI less intimidating and more educational.
The fifth experience is respect for efficiency. On a powerful machine, inefficient code can hide. On a Pentium II, inefficient code stands on a table and announces itself. Every allocation, every file read, every unsupported feature matters. This environment rewards simplicity. It makes minimalism feel practical, not aesthetic. A small model with a small runtime becomes a lesson in doing more with less.
For hobbyists, this kind of project is pure joy. For developers, it is a reminder that portability matters. For AI researchers, it is a tiny but memorable signal that the field should not only chase bigger models. For everyday readers, it is a great story: modern artificial intelligence squeezed into a machine old enough to remember when the internet made noise before connecting.
In the end, running Llama 2 on Windows 98 is not about pretending the past can outperform the present. It is about proving that the present can learn from the past. Good engineering is not always bigger, louder, and more expensive. Sometimes it is a small C program, a stubborn team, an Ethernet cable, and a beige computer that refuses to become irrelevant.
Conclusion
Modern AI On Vintage Hardware: LLama 2 Runs On Windows 98 is more than a clever retrocomputing stunt. It is a compact lesson in AI portability, efficient inference, local computing, and software minimalism. The experiment shows that even though modern AI is often associated with billion-parameter models and expensive infrastructure, the underlying ideas can be adapted to surprisingly constrained systems.
No, your Windows 98 tower will not replace a modern GPU server. It will not become the family chatbot, unless your family enjoys waiting and debugging network settings. But as a demonstration, it succeeds brilliantly. It proves that small language models can run in unexpected places, that old hardware can still teach new lessons, and that the future of AI may be more diverse than a single cloud dashboard.
The beige box lives. The llama runs. Somewhere, a floppy disk just shed a tear.
