WWIV BBS: When a College Kid Accidentally Built a Networking Empire
How Wayne Bell started with interpreted BASIC and a 10MB hard drive, hit the 64KB memory wall, and somehow created one of the most influential BBS software packages ever
Okay, picture this: It’s December 1984, and some college kid named Wayne Bell decides to put up a BBS using an IBM-PC with a 10 megabyte hard drive and a Hayes 1200 baud modem. His software? Written in interpreted BASIC, crawling along slower than molasses, competing mostly with Apple II systems that were also running in interpreted BASIC.
Fast forward to today, and WWIV is still around, still actively developed, and still has a devoted following of sysops running boards worldwide. Not bad for a project that started because Wayne wanted to see if he could build something better than the Apple II BBSes he was seeing.
This is the story of how a UCLA student accidentally created one of the most enduring BBS software packages in history, and why running into the 64KB memory limitation was the best thing that ever happened to him.
The Interpreted BASIC Days (Or: How to Hit a Wall at 64KB)
When Wayne Bell first fired up WWIV v1.0 in late 1984, he was working within the constraints of IBM interpreted BASIC on a machine that most people today would consider a calculator. We’re talking about systems where 64KB of RAM was considered generous, and a 10MB hard drive was serious storage.
But here’s the thing about interpreted BASIC: it was slow. Like, painfully slow. And worse yet, it had this hard memory limitation that meant you couldn’t really build anything substantial. Wayne was doing “pretty strange stuff with memory allocation and string storage” just to keep the thing running.
You know you’ve hit the wall when users try typing in 30 lines of a message and get an “out of memory” error. Yeah, that’s not exactly the user experience you’re going for.
Wayne knew it was time to move on to “something better.” That something turned out to be Turbo Pascal 2.0.
The Turbo Pascal Revolution (And Why Version 2.0 Was a Pain)
Moving to Turbo Pascal 2.0 solved the memory problem, but created a whole new set of headaches. Turbo 2.0 had NO support for directories. None. All file I/O had to happen within your current directory only. Try building a serious BBS system when you can’t even organize your files properly!
And don’t get me started on the communication routines. Wayne was basically banging his head against the wall trying to get decent comm code working.
But then Turbo Pascal 3.0 came out, and suddenly Wayne had the tools he needed. He put up WWIV v2.0, got some “REAL interrupt-driven comm routines” working, and things started moving along nicely.
There was just one problem: Wayne had to go to UCLA.
The UCLA Problem (When College Gets in the Way of BBS Development)
Here’s something you don’t often hear about in BBS history: sometimes real life gets in the way of your digital empire. Wayne had to take his BBS down when he went off to UCLA, because apparently college requires things like “attending classes” and “being physically present.”
But during Christmas vacation in December 1985, Wayne got that irresistible urge that every programmer knows: “I should put this back up and make it better.” So he did some major revamping and called it WWIV v3.0.
This version was still running on Turbo Pascal 3.0, but Wayne added something crucial: a file section. Getting XMODEM working was “quite a bit of work,” and he had to go back and reformat all his data files to allow for file descriptions.
Here’s the best part: Wayne had never actually been on any other IBM-type BBS, so he had no clue how a file section was supposed to work. His approach? “Things turned out pretty randomly.”
Sometimes the best innovations come from not knowing how things are “supposed” to be done.
January 1, 1986: WWIV v3.0 Goes Public
On January 1, 1986, Wayne finally released WWIV v3.0 to the world. And like every software release ever, it immediately went through “quite a few revisions, especially in the first week or two.”
But here’s where it gets really interesting: Wayne had to resume classes at UCLA, which meant he was “pretty much writing WWIV without running a BBS.” He was coding blind, basically developing software for a system he couldn’t properly test.
As Wayne put it: “As you may guess, this caused a few unfortunate bugs to slip by me, but that’s life.”
This might be the most honest thing any software developer has ever said about their release process.
The Week-Long BBS Experiment (June 1986)
By June 1986, Wayne decided to add ANSI color support and call it WWIV v3.2. This meant reformatting the user list to store color preferences and “a few other little fun things,” so he decided to put up a test BBS.
For one week. That’s it.
You’d think nobody would bother calling a BBS that was explicitly stated to only be up for a week, right? Wrong. The thing got “pretty good activity.” And to make it even more interesting, Wayne wasn’t even there for half of it! He had his friend Stephen Davis calling up and remotely managing the experimental BBS.
This was 1986, remember. Remote system administration wasn’t exactly a standard practice. Wayne was basically pioneering remote BBS management out of necessity.
The best part? “It even managed to make it without crashing.”
The Y-Modem Bug That Wouldn’t Die
After releasing v3.2, Wayne discovered he had a pretty bad bug in the Y-Modem routine. The BBS would read in a block of data, and THEN seek to the right place in the file, instead of seeking first and then reading.
If you’ve ever done file I/O programming, you’re probably cringing right now. That’s the kind of bug that can corrupt data in spectacular ways.
Wayne came out with v3.20a rather quickly to fix this. Nothing quite like a file transfer bug to motivate rapid patches!
WWIV v4.0: The C Language Adventure
In June 1987, Wayne decided to rewrite everything in C. There was just one tiny problem: he had never written anything in C before in his life.
“I eventually got the hang of things,” Wayne noted with characteristic understatement.
But here’s where Wayne made one of those promises that every developer regrets: he said WWIV v4.0 would support networking among systems. This sounded like a great idea to him.
The only problem? “I had no clue as to how I would go about implementing it at the time.”
So he relegated networking to “don’t hold your breath” status, secretly thinking he might never actually get around to it.
Famous last words.
The Accidental Network Revolution
Surprisingly, Wayne did get around to implementing networking relatively soon. But by then, everyone had already installed WWIV v4.0 on their systems, so he was stuck with the network addressing format he’d dreamed up when “I had no clue how it would work”: a number from 1-65535 indicating which system was which.
This was not exactly the optimal solution, but Wayne had to design an entire network architecture around this limitation.
The networking software came about in the most random way possible. Wayne was bored one day, had been talking with someone about networking, and decided to start writing a program to send files between computers. There was no planning at all - he just “pretty much sat down and typed it in.”
That casual afternoon of coding became NETWORK.EXE, the foundation of WWIVnet.
The Multi-Tasking Reality Check
One feature that people kept requesting was multi-line WWIV - the ability to handle multiple users simultaneously. Wayne’s response was refreshingly honest about the technical realities:
“That just is not practical.”
The problem wasn’t with WWIV itself, but with the entire ecosystem. WWIV depended on many external programs - door games, editors, archiving programs - and you couldn’t practically run external programs without a multi-tasking operating system.
Wayne’s assessment: “PC-DOS was not designed with multi-tasking in mind.”
This was one of those fundamental limitations that no amount of clever programming could work around. Sometimes the platform just isn’t ready for what you want to do.
The Hack Paranoia of 1991 (And Why We Needed Better Security)
The early ’90s were wild times for BBS security. The WWIV News archives from 1991 are filled with warnings about various hack attempts, particularly the infamous “NETWORK.COM hack” where attackers would upload ZIP files containing malicious NETWORK.COM files designed to trash systems.
Wayne Bell’s response? He released UNZIP, a program that would scan ZIP files before extraction, looking for suspicious content like directory paths ("" and ”/”), or files named “PKZIP”, “PKUNZIP”, or “COMMAND”. If anything looked fishy, extraction was blocked completely.
This was classic Wayne Bell problem-solving: practical, effective, and built right into the core software. While other BBS packages were getting hacked left and right, WWIV was evolving to stay ahead of the threats.
The paranoia was real though. Sysops were sharing tips like setting files to read-only, changing passwords regularly, and being extremely careful about who got upload access. The community was learning network security the hard way.
The Network Compression Revolution (1991)
One of the coolest innovations in the WWIV News era was network compression. By 1991, Wayne had integrated PKZip technology directly into the networking software with NET24, making programs like NetZip obsolete overnight.
Here’s what blew my mind reading the old newsletters: the compression ratios were incredible. Sysops were reporting 50%+ savings on network traffic, which meant thousands of dollars saved on long-distance phone bills. When you’re calling BBSes across the country every night to exchange mail, every byte counts.
Wayne’s implementation was elegant: if both ends of the connection were running NET24 or higher, the network software would automatically compress outbound packets and decompress incoming ones. No external programs, no complicated setup - it just worked.
But here’s the technical detail that shows Wayne was ahead of his time: he recommended NOT using MNP5 modem compression if you were using network compression, because you’d just be compressing already-compressed data. But V.42bis was fine since it was smart enough to detect already-compressed content.
This guy was thinking about layered compression protocols in 1991!
The Corporate Transformation
In January 1998, Dean Nash purchased WWIV and WWIV Software Services from Wayne Bell. This transformed WWIV from a college kid’s project into a proper business with “full corporate posture.”
Craig Dooley was appointed Support Coordinator, and the whole operation became more formalized. Sometimes growth means giving up the informal, hacker-friendly approach for something more structured.
Going Open Source (2004)
On September 18, 2004, WWIV Software Services made an announcement that would ensure WWIV’s long-term survival: WWIV 5.0 would be open source under the Apache License.
This was huge. Instead of being dependent on a single company or developer, WWIV became a community project. The code moved from Sourceforge to GitHub in 2015, where development continues today.
WWIV 5.0: The Modern Era
WWIV 5.0 development started in 1999, picked up steam in 2003, and continues with daily build releases to this day. That’s over 25 years of continuous development!
Think about that: software that started as interpreted BASIC on a 10MB hard drive is still being actively developed in 2025. How many pieces of software can claim that kind of longevity?
The Lessons from Wayne’s Journey
Wayne Bell’s WWIV story teaches us some important things about software development:
1. Constraints breed innovation - The 64KB memory limitation forced Wayne to move to better tools
2. Sometimes ignorance is bliss - Not knowing how file sections “should” work led to creative solutions
3. Remote work isn’t new - Wayne was remotely administering systems in 1986
4. Promises have consequences - That casual networking promise led to building an entire network protocol
5. Platform limitations are real - No amount of clever coding could make DOS truly multi-tasking
6. Community sustains software - Going open source ensured WWIV’s survival beyond any single developer
The WWIV Hall of Fame
The official WWIV Hall of Fame recognizes the key contributors:
- Wayne Bell (Random, WWIVnet @1) - The creator
- Dean Nash (Trader Jack) - WWIV Software Services
- Adam Caldwell (The Emporer) - WWIVEdit
- Craig Dooley - WWIVToss
The Local Connection: Spokane’s WWIV Scene
Speaking of the real-world impact, WWIV boards were everywhere in the early ’90s. Right here in Spokane, Ken was running the Exodus BBS (@5921, WWIVnet) and hosting the “USRobotics Information Network” sub that provided monthly newsletters and technical info for high-speed modem users. This was serious business - Ken was distributing national BBS lists of boards running USR modems and providing technical support that you couldn’t get anywhere else.
These were the boards I was calling into back in the day. While Wayne Bell was coding away at UCLA, sysops like Ken were running the local nodes that made WWIVnet actually work. Every @5921 message that flowed through the network was because some guy in Spokane decided to dedicate his phone line and hard drive space to keeping the community connected.
It’s wild to think about: your local BBS sysop was basically running internet infrastructure before most people knew what the internet was.
Still Running Strong
Today, WWIV continues to evolve. There are still active WWIV boards running worldwide, and the software supports modern features while maintaining that classic BBS feel that made it special.
From interpreted BASIC on a 10MB hard drive to modern C++ with GitHub hosting, WWIV represents one of the longest-running software development projects in BBS history.
Not bad for something that started because a college kid wanted to build something better than those Apple II boards he kept calling.
The Legacy Lives On
WWIV’s influence extends far beyond its own user base. The networking concepts Wayne developed, the multi-platform approach, and the community-driven development model all became standard practices in later software projects.
And that casual approach to development - “I was bored one day… so I decided to start writing a program” - perfectly captures the experimental spirit that drove the entire BBS era.
Sometimes the best software comes from college students who don’t know what’s impossible.
Sources:
- Wayne Bell’s “Official History of WWIV” from WWIVNEWS Volume 1, Issue 1 (January 1991)
- WWIV Software Services documentation and announcements
- WWIV Documentation Project
- WWIV News Archives 1991 - Including references to local Spokane BBS scene
- Personal experience from the Spokane BBS community, circa 1991
Want more BBS software stories? Check out our posts about Renegade BBS customization and FidoNet’s global network.
