Rediscovering the Signalnine Source Code

In 2002, a few of us built a blogging platform. We called it Signalnine, or sig9 on SourceForge, because “Signal Nine” is SIGKILL, the Unix signal you send when something absolutely has to die. The tagline was “The Mozilla of Blogs.” The unofficial slogan, coined by truefluke, was “Where v1.0 is a myth.” WordPress wouldn’t exist for another year.

I found the source code again recently. The original tarball, Sig9-M3-20021113, timestamped November 13, 2002. I pushed it to GitHub mostly as an archival exercise, the way you’d scan an old photograph. I didn’t expect to find it interesting. I was wrong.

The Team

We all studied CS at New Mexico State University. There were three of us as SourceForge project admins: me, Cassandra Bayer (who went by Krach42 back then), and Eric Zeitler. Eric went by EBNF, a nickname he picked up in compilers class, after Extended Backus-Naur Form. Cassandra wrote most of the heavy infrastructure: the ACL system, the template parser, an entire inline documentation system she modeled after Unix man pages. Eric was prolific on the site itself, posting .plan entries and articles with the kind of energy that made the whole thing feel alive.

The three of us wrote the code, but the community around Signalnine was bigger than that. Several of us had come from volunteering at Linux.com, and Signalnine was partly a reaction to that experience. We wanted to build something like it but under our own control, run the way we thought a community site should be run. Terry Warner (keerf) hosted our CVS server at nuthouse.org and kept the infrastructure running. Darren Morrin, posting as truefluke, was the site’s most prolific contributor. Ten of the fourteen articles on a typical front page were his. Tom D came over from Linux.com too. We had an IRC channel on EFNet, #signalnine, because that’s what you did in 2002.

Eric passed away some years ago. Finding his posts preserved in the Wayback Machine archives, his .plan entries, his jokes about “confidential signalnine documents leaked,” was not something I was prepared for when I started this project.

The live site was a Slashdot-style community portal. Not just a blog engine but a place with user registration, article submission, comment threads, polls, daily comics, and sidebar widgets you could minimize and rearrange. We had over a hundred registered users. People posted tech news, argued about Linux distributions, complained about phpBB security holes. The usual.

What the Code Looks Like

It’s PHP 4. Constructors are methods named after the class. Properties are declared with var. Sessions use session_register(), which was deprecated years ago and eventually removed entirely. There’s a get_magic_quotes_gpc() call. A manual srand() with a comment that says “this srand is from richart@zend.com… trust the developers.” It’s a time capsule.

But underneath the period-specific PHP, the architecture is more thoughtful than I remembered.

The heart of the system is the “box” architecture. Everything on the page is a box: login forms, article lists, sidebars, Google search, the comment system. Each box is a self-contained .box file that gets loaded dynamically. Users could configure their own sidebar layout with a string like left(login,google,whatis);bottom(comic) stored in their profile. Boxes had minimize and close buttons, like desktop windows. This was years before WordPress widgets or iGoogle.

The database layer supported both MySQL and PostgreSQL through a hand-rolled abstraction with separate driver files. Queries used a builder pattern ($query = new query("articles"); $query->Constrain("type=1"); $query->Limit(0, 10);) which was pretty clean for 2002 PHP. Passwords used crypt() for cross-database compatibility, which turned out to be the right call.

The ACL system was genuinely sophisticated. Field-level permissions on database columns, with cascading rules from user to group to global. 43 ACL entries in the seed data. The permission type drove form rendering: a theme field automatically generated a dropdown of available themes, a password field rendered a password input. It was more granular than what most CMSes offer today.

The Vision Document

The Wayback Machine preserved something I’d almost forgotten: a design document I wrote, hosted on our CVS server. It opened with “Sig9 Stuff. Yah bahbe.” and was marked “Signalnine Confidential. Your eyes only.” with a grin emoticon. It was not confidential.

The interesting part is the ambition. The document describes wanting to make the content exportable via XML so that independent sites running the same code could share articles with each other. A network of web-based BBSes, each with its own focus (one for open source, one for agriculture, whatever) federated through a common protocol. I was describing ActivityPub fifteen years before Mastodon existed.

We actually built part of it. The export system generated content with MD5 hashes for integrity verification, and the import system could pull articles from other instances. It was rudimentary, but the plumbing was there.

What We Got Right, What We Didn’t

The architecture was ahead of its time in some ways. Widget-based layouts. Database abstraction. Content federation. Full internationalization with gettext, including Japanese translations, which still surprises me. Output format switching between HTML 4.01 and XHTML 1.0.

What killed Signalnine wasn’t the code. It was timing and focus. WordPress launched in May 2003 with a simpler pitch: install it, write posts, done. We were building a community platform with IRC integration and federated content sharing. We were overengineering exactly the way three CS students would overengineer a side project. The market wanted easy. We were building interesting.

Looking Back

The Wayback Machine has 113 captures of signalnine.com between 2001 and 2025. The earliest is a “Coming Soon” page from April 1, 2001. We launched on April Fool’s Day and adopted it as our anniversary, a convenient excuse to push code updates every year. The codebase went through four incarnations: a bare-bones preM1, then Milestone 1, 2, and 3, each a progressively more ambitious rewrite. Signalnine was also loosely associated with Starport, a sister site where the first M3 code went live. The November 2002 captures show the site at its peak: articles flowing in, polls running, users logged in. The query counter in the footer reads “23 SQL queries.” We were proud of that number, though I’m not sure why.

Reading this code twenty-four years later is a strange experience. I can see the fingerprints of three people figuring things out in real time. Cassandra’s careful documentation system sitting next to my quick-and-dirty article renderer. Eric’s poll widget bolted onto the sidebar framework. The comment at the top of the config file that says // EDIT ONLY IF YOU KNOW WHAT THE HELL YOU ARE DOING. We didn’t always know. We did it anyway.

The code is on GitHub if you want to look at it. It won’t run without a time machine and a PHP 4 interpreter. But as a record of what three people thought the web should look like in 2002, before the platforms won and the blogosphere became five websites reposting each other, it’s worth a read.