Bridging a 40-Year Tech Gap: Running AI Chat and Image Generation on a 286

A 1990s 286 Tandy 1000 TL/3 running AI chat and image generation smoothly — this isn't science fiction. It's something developer Rowan Underwood actually pulled off with a system called DeskMind. He shared the project on Reddit, sparking widespread discussion among retro hardware and modern AI enthusiasts alike.

Getting a 286 to Talk to Modern LLMs

The core idea behind the system is to keep the ancient machine completely shielded from modern data formats. DeskMind is a native DOS program; the 286 connects to WiFi via a PicoMEM 2 network card and the mTCP protocol stack, communicating with a lightweight Python server running on a modern PC.

All the real compute happens on modern hardware: chat is powered by a Qwen3.8-27B model running on a 5090 GPU (NInfer), while image generation is handled by Krea 2 (ComfyUI) on a 4090. The key design principle is that the 286 never sees JSON, base64, or PNG — formats it simply can't handle. The server pre-processes everything into plain text lines and image data already prepared to be copied directly into video memory.

This division of labor is essentially "protocol downscaling" — translating the complex output of modern AI into the simplest form that 40-year-old hardware can understand, leaving the old machine responsible only for what it's good at: display and input.

mTCP is a lightweight TCP/IP stack designed for DOS environments, developed by Michael Brutman. It allows DOS programs running on 8086/286-era processors to connect to a network via standard Ethernet cards or compatible hardware. PicoMEM is an expansion card based on the Raspberry Pi Pico microcontroller that can emulate various legacy PC expansion hardware (including network cards) and provides WiFi connectivity — one of the most common modern solutions for getting 1980s–90s computers onto wireless networks. Together, they allow an otherwise isolated 286 to establish a TCP connection to a modern server on the local network with minimal protocol overhead and no OS-level changes to the host software. CP437 is the original IBM PC character encoding page, containing Latin letters, box-drawing characters, and a set of special graphic characters — the standard character set for DOS text interfaces. Converting Unicode to CP437 in real time is a necessary step to ensure model output displays correctly on a legacy DOS terminal.

Multimodal Without Function Calling

One clever aspect of the project is how it achieves mixed text-and-image output without relying on complex function calling. The system prompt instructs Qwen to wrap image requests in <draw>...</draw> tags whenever it wants to generate a picture.

The server captures this tag mid-stream, immediately triggers Krea 2 to generate an image, applies dithering, then pushes a picture ready notification to the 286. In testing, typing "draw me a logo for a 286 AI" takes roughly 9 seconds from pressing Enter to a thumbnail appearing in the chat window.

The system also supports visual understanding: Qwen Vision can "see" what's displayed on the 286's screen. When a user asks about an image, the model receives both the original and the 16-color dithered version — so it can meaningfully answer questions like "why does the sky look stripy." The most recently generated image stays in the conversation context, supporting follow-up questions.

Making the Model "Aware" It's Running on a 286

One of the most interesting details is that the system prompt makes the model explicitly aware it's running on a 286 — 80 columns wide, 16 colors. As a result, Qwen proactively keeps its responses concise and sticks to pure ASCII. When asked for game recommendations, it suggests era-appropriate titles like Wolfenstein 3D or Commander Keen.

To accommodate a 1990-era screen, the server performs extensive real-time cleanup: stripping reasoning traces, removing Markdown on the fly, converting Unicode to the CP437 code page (bullets become CP437 block characters), and merging fragmented tokens into lines of roughly 48 characters to prevent the 286 from constantly redrawing the screen with each token update.

The author also applies differentiated reasoning intensity by task: low intensity for chat (responses begin in about 2 seconds), medium for rewriting image prompts. Prompt "enhancement" is specifically tuned for dithered display, favoring images with large flat areas of color, strong contrast, and simple backgrounds. The rewritten prompt is shown first in an editable field on the 286, and these rules can be edited directly from the Tandy side.

The Dither Lab and Performance Numbers

The server GUI includes a built-in "Dither Lab" supporting multiple algorithms — Floyd-Steinberg, Atkinson, Bayer, Yliluoma — with preview at the Tandy's actual screen aspect ratio. Dithering is the soul of low-color-depth display; how well 16 colors can simulate gradients and texture determines the overall visual quality.

On the performance side: Krea 2 generates a 1024×768 image at 8 steps in about 10 seconds (target display resolution is 640×200); transferring a 64,000-byte image over PicoMEM WiFi takes roughly 1 second at 56–79 KB/s. The bottleneck in the entire pipeline is clearly on the modern hardware generation side, not the 286.

The project is open-sourced under GPLv3 on GitHub.

Dithering is a technique that simulates colors or grayscales beyond a display's capability by arranging pixels spatially. When a device can only show a limited palette (16 colors here), dithering algorithms interleave different colored pixels to exploit the human eye's visual blending and produce the impression of smooth transitions. Floyd-Steinberg diffuses quantization error from the current pixel to its neighbors, producing a natural grain; Atkinson diffuses only part of the error, trading some accuracy for sharper edges; Bayer uses a predefined matrix to generate a regular ordered dot pattern, well-suited for images with distinct color blocks; Yliluoma is more compute-intensive but produces superior results when simulating palette color mixing. This is precisely why the project's prompt rewriting tilts toward large flat color areas and high contrast — such images lose the least visual information after dithering and best preserve the appearance of the original on a 16-color Tandy screen.

Technical Lessons Beyond the Nostalgia

Beyond the self-deprecating "why am I like this" framing, this project demonstrates an architectural pattern worth taking seriously: thin client + heavy server. The role the 286 plays is no different in principle from any modern terminal calling a cloud-based LLM — it's simply an input/output device, with the actual intelligence happening elsewhere.

The difference is that modern terminals can at least parse JSON and handle HTTPS. This project takes the adaptation layer to its logical extreme, pushing every complexity outside the protocol handshake entirely to the server side. For anyone thinking about how edge devices and low-compute terminals can access AI capabilities, the idea of "completely externalizing complexity" is genuinely instructive. It's also a reminder that what we call "hardware requirements" is, in many cases, a question of software layering and design.