An AI on a Floppy Disk: What Tiny 2.1 Can Teach Me About Local Models

Front of a 3.5-inch floppy disk
A real 3.5-inch floppy disk illustrates the storage scale. It is not a photographed Tiny 2.1 installation. Image: DiscoA340 · CC0 1.0. Resized proportionally; full frame retained.

An AI model that fits on a floppy disk gets my attention for a different reason from a new model that tops a leaderboard. I want to know what has been kept, what has been left out and whether the small size makes the project more useful—or simply more interesting to understand.

Tiny 2.1 is firmly in the interesting category. Its creator presents it as a small question-answering neural network for DOS, with public source code and downloadable model files. The appeal is immediate for anyone who enjoys old computers: a machine associated with command prompts and floppy disks producing answers through a trained model. Tiny 2.1: project repository and files

I have examined the project's documentation and source structure for this article; I have not run its executable or benchmarked a 486. My verdict is that this looks much more valuable as a compact learning project than as a reason to buy retro hardware or replace a capable modern assistant.

What actually fits on the disk

The repository describes a model with about 367,000 parameters, four layers and a width of 96. It works character by character and stores its weights using eight-bit quantization. The listed TINY.BIN file is 381,808 bytes, while TINY.EXE is 53,604 bytes. Together that is 435,412 bytes, comfortably below the nominal capacity of a 1.44 MB floppy. Tiny 2.1: project repository and files

That arithmetic establishes a storage claim. It does not establish the amount of working memory needed to run the program, the speed of an answer or the breadth of its knowledge. I would keep those questions on separate lines of a specification sheet.

The distinction is familiar from much larger local models. A compact download can still need additional memory for intermediate calculations and runtime state. A model may fit on a drive but respond too slowly for a particular task. Tiny makes those differences unusually visible because the hardware constraints are so small.

There is also something refreshing about being able to inspect the essential files without downloading several gigabytes. The educational value starts before execution: the storage budget, data representation and interface are small enough to discuss concretely.

The old computer still has requirements

The project instructions ask for roughly 540 KB of free conventional memory. The creator says a Pentium or a 486DX with a floating-point unit can answer in seconds, while machines without the relevant hardware support can be much slower. Those are the author's compatibility and performance claims, not results from my own collection of computers. Tiny 2.1: detailed project instructions

That qualification matters with retro systems. Two machines described casually as “a 486” can differ in ways that are decisive for numerical code. Available conventional memory also depends on the environment in which DOS is running. A bootable machine is not automatically a correctly prepared benchmark machine.

For curiosity alone, I would start with equipment or an established DOS environment I already use. Buying an old desktop, finding a working drive and troubleshooting the setup would turn a free download into a separate hobby budget. That may be enjoyable, but the purchase should be justified by the hobby rather than by an expectation of cheap general-purpose AI.

The repository offers the download without a purchase price: US$0 or €0 for the files at the time of checking. Electricity, hardware and time are separate. I also did not find a license file in the repository root, so “publicly available source” is the description I can support; I would not assume unrestricted redistribution rights. Tiny 2.1: project repository and files

Small weights do not mean a small modern chatbot

The creator reports training the model on around 3,500 facts. The longer instructions distinguish performance on familiar question wording from questions using different wording or combinations, reporting roughly 90 percent and 61 percent respectively in the described tests. Those figures come from the project author and should not be treated as independently verified general-knowledge accuracy. Tiny 2.1: detailed project instructions

For me, that is the most informative part of the story. A model can produce plausible answers in the small world it has learned while becoming much less reliable when the wording or task moves outside that world. The ability to generate text does not tell us how well it will handle an unfamiliar request.

I would also avoid calling a correct answer proof that the model has reasoned through a problem. It might have learned a useful relationship, reproduced a familiar pattern or arrived at a correct string through a narrower mechanism. A few entertaining examples cannot distinguish those possibilities.

That does not reduce the achievement of fitting a functioning neural network into this environment. It gives the achievement a precise shape. The impressive part is making the computation work within the constraints, and the useful next question is how much behavior survives those constraints.

What the source lets me check

The published C source defines a vocabulary of 97 entries and a context limit of 128 characters for the question and answer. Its weight tables pair signed-byte values with floating-point scaling information. This is a concrete example of why “eight-bit weights” does not mean every number used by the entire program is an eight-bit integer. Tiny 2.1: C source

The file also contains explicit memory allocation and an error message for insufficient memory. These details make the project suitable for studying how a model is represented and loaded. They do not prove that a particular executable exactly matches the source, and I have not performed that verification.

I like the teaching opportunity here. A student can follow a weight table, a scale and an input limit without first managing a large framework. Even asking why the character budget includes both question and answer leads to a useful discussion about what a model can retain during generation.

The questions I would use to evaluate it

A proposed evaluation, not results from a completed test
Question typeWhat it would reveal
Familiar factWhether a basic supported question receives the expected answer.
Same fact, different wordingHow much the response depends on a familiar phrasing.
Incorrect premiseWhether the model challenges the mistake or continues it.
Unknown or recent factHow it behaves outside the knowledge described by its creator.
Longer questionWhat happens near the documented input-and-answer budget.

I would write the questions and expected answers before trying the program, then keep every output. Selecting only the funniest or most successful responses would produce a good demonstration and a poor evaluation.

The timing method deserves the same care. A useful result would identify the processor, floating-point support, available memory, software environment and whether the clock includes startup. “Runs on an old PC” is an engaging description; a repeatable setup tells the next person what to expect.

For this kind of project, an honest failure can be more educational than an impressive answer. If a harmless change of wording breaks a response, we learn something about generalization. If a false premise receives a confident continuation, we learn why fluent output needs external checking.

What I make of the AI-built claim

The repository attributes the program's development to Fable 5.2 and its training to Opus 5.5. I can report that attribution, but the repository statement is not an independent audit of how the work was produced. The published implementation is the part readers can inspect directly. Tiny 2.1: project repository and files

That is how I prefer to judge AI-assisted coding more generally: by the resulting artifact, the clarity of its limitations and the checks that another person can repeat. A charming origin story does not remove the need to understand the code or establish whether it meets its purpose.

Tiny 2.1 gives me a reason to think about efficiency without turning smallness into a competition of its own. For a dependable assistant, I still need adequate capability, good evaluation and acceptable response time. For learning how neural-network inference is assembled under severe constraints, a floppy-sized project can be far more approachable than a sprawling production system.

That is where I would spend my attention: reading, experimenting with a clearly recorded setup and learning from the limits. The disk is the hook. The small, inspectable engineering problem is the reason to stay.

Comments

Popular posts from this blog

Obsidian’s New Search: Less Friction for Notes in Two Languages

OPPO Find X9 Ultra vs Find X10 Pro Max: Is the Older Ultra Still Worth Buying?

OPPO Find X10 Technical Preview: Cameras, Design and Missing Specs