Eleven seconds. That’s roughly how long a single background image took to crawl in over a 56k modem back in 1996, and somebody just made ChatGPT recreate that exact agony on purpose. This Redditor built 56k.rip, a web app that drops you into a fake Windows-era desktop, complete with network throttling that mimics dial-up speed and a stash of hidden Easter eggs. I love this project because it’s not nostalgia bait, it’s a genuinely tricky prompting challenge dressed up as a joke.
What’s new: the site behaves like a full simulated 1996 desktop environment inside your browser tab. Windows load slow, layouts are chunky and table-based, and there’s a real “modem handshake” feel to how content trickles onto the screen. The creator didn’t hand this look off from memory. They used ChatGPT as a build partner and shared exactly which prompts got the retro effect right and which ones fell apart.
A few things stand out about the build itself:
- A fake desktop shell that hosts multiple simulated “apps” at once, the way old Windows machines juggled several clunky windows.
- Real dial-up style throttling, so pages don’t just load instantly behind a spinner. They crawl in, piece by piece, the same way a JPEG used to render top to bottom.
- Hidden Easter eggs scattered through the experience, rewarding people who poke around instead of just glancing at the homepage and leaving.
- Table-heavy, structural CSS instead of modern flexbox, which is what actually sells the mid-90s illusion.
Here’s the twist. Getting the slow-load feeling wasn’t about writing bad code, it was about writing very specific code. The original poster found that asking ChatGPT for “slow loading” produced generic, boring lag, the kind you’d get from throttling a fetch call at random. Asking for exact latency functions produced the real deal: that agonizing, staggered 56k crawl everyone who grew up with dial-up still remembers in their bones. Precision beat vibes every time.
Where it got messy: ChatGPT kept letting the retro browser’s CSS leak out of its own frame and bleed onto the fake desktop underneath it. Picture opening a simulated browser window and watching its styles quietly hijack your taskbar. The author had to step in and manually fix the scope isolation, because the model kept losing track of which styles belonged inside the simulated browser and which belonged to the desktop shell wrapped around it. It’s a small bug with a big lesson: LLMs are great at generating convincing surface-level CSS, but they’re shakier at reasoning about containment once things get nested.
Here’s a mini-workflow worth borrowing if you’re building any kind of nested UI, retro or not:
- 🕹️ Describe the exact mechanism, not the vibe. Instead of “make it slow,” ask for a specific latency function with real numbers attached: connection speed, packet delay, load stagger.
- 🖥️ Ask for structural, table-heavy CSS if you want an authentic pre-2000s look. Modern flexbox and grid won’t get you there. Old-school markup patterns will.
- 🔒 When you’re nesting a simulated UI inside a real one, like a fake browser inside a fake desktop, call out iframe or shadow-DOM boundaries explicitly in your prompt. Don’t assume the model will infer the scope on its own.
- 🧪 Test the boundary case first, before building out the rest of the simulation. Confirm styles stay contained. Catching leakage early saves you from untangling it across a dozen components later. Layer in the fun stuff, like Easter eggs, once the foundation actually holds.
If you want to try building something similar, you don’t need much beyond a ChatGPT tab and a willingness to describe your effects in painfully specific terms. Start small: pick one retro element (a loading crawl, a chunky button, a dithered background) and nail the exact mechanism before you stack five more on top of it.
The main limitation the original poster ran into is worth flagging for anyone attempting the same thing: CSS scope boundaries are still a soft spot for these models on nested, simulated interfaces. Compared to other nostalgia projects floating around Reddit, most of which just slap a Windows 95 theme over a normal fast-loading site, this one actually earns its retro feel by simulating the network layer too, not just the visuals.
Pro tip: when you want a model to nail a very specific technical sensation, whether that’s slow load, glitchy render, or retro compression artifacts, give it the underlying mechanism instead of the adjective. “56k modem latency curve” beats “make it feel old” every single time.
Pro tip two: if you’re fighting CSS scope leakage like this creator was, try naming the containment strategy directly in your prompt, iframe, shadow DOM, or a scoped CSS-in-JS approach, rather than just describing the visual result you want. Models default to global styles unless you box them in on purpose.
This is a fun reminder that the best AI builds right now aren’t the flashiest ones. They’re the ones where someone got specific enough to make the model actually behave. Go poke around 56k.rip and see how much of 1996 you still remember 🐌. And if you’ve cracked a clean way to force strict scope boundaries out of an LLM, the original poster is still hunting for that answer, so it’s worth dropping your approach in the comments.
Prompts used to force ChatGPT into recreating 1996 dial-up speeds and retro UI
by u/Scholeristical in ChatGPTPromptGenius