Dev Log on Phosphor BBS

Markdown in a Terminal: Building a MarkdownWidget for jterm

Wed, 23 Sep 2026 00:00:00 +0000

Every BBS has the same problem: text that wants to be formatted. Help screens with headings and bullet lists. News articles with paragraphs. Mail that would really use a code block for that error dump. The traditional answers are all bad in the same way — hard-coded ANSI sequences baked into strings, a private wiki-syntax nobody else can read, or walls of plain text with no structure at all.

jterm now ships a third answer: a MarkdownWidget that parses real markdown and renders it as styled terminal lines.

Publishing 0.1.1: The Deploy That Exited 0 and Published Nothing

Wed, 23 Sep 2026 00:00:00 +0000

jterm 0.1.1 is on Maven Central. The build that put it there was green in seventeen seconds of test time — and took nine and a half minutes of wall clock, plus a mid-flight correction when we discovered the first deploy had quietly published nothing at all. This post is the release notes for the process, because the failure mode is one every maintainer of a Central-published library will hit.

The Case of the Blended Batches: A Race Hidden Inside a Replace

Wed, 23 Sep 2026 00:00:00 +0000

The jterm thread-safety suite exists to answer one question: can a widget survive being redrawn from one thread while another mutates it? It has run thousands of times across dozens of widgets, mostly to say yes. On the morning we cut the 0.1.1 release, it said no — and the test that failed wasn’t even the one that was broken.

Two failures, two days apart

The release gate runs the whole suite, 2,926 tests. The first full run failed one test: FireworksTest.renderFrameProducesOutput — the fireworks animation was supposed to paint visible pixels after five frames and, once out of 2,926, it painted nothing. We re-ran the class in isolation: 12/12 green. Read the render path: fresh instance, deterministic math, five calls that each draw a rocket or particles. The failure looked like noise under load — the kind of flake you shrug at and re-run.

Y/M/D and a Digit: Composing Chart Ranges from a Unit and a Number

Wed, 23 Sep 2026 00:00:00 +0000

The stock chart on Phosphor’s finance door had five time windows, chosen by five keys: 1D, 3M, 6M, 1Y, and 0 for “all history.” That’s the standard menu — every finance app has it. And like the standard menu, it had a wall you hit the first time you actually used it: you can’t ask for 3Y. Or 2M. Or 10D. Every range anyone might want is either pre-built or impossible.

Chat From Anywhere: The Ctrl-T Popup

Sun, 20 Sep 2026 00:00:00 +0000

On a traditional BBS, chat is a place. You navigate to the chat section, you sit there, you talk. When you want to check your mail you leave chat — and the conversation — behind. That’s fine when chat is an event you schedule. It’s terrible when it’s ambient, the way a community actually works: someone drops a line into the channel while you’re reading the board, and you want to answer without losing your place.

The Case of the Very Random Dead Ctrl-T

Sun, 20 Sep 2026 00:00:00 +0000

Two weeks into the popup chat feature, users started reporting the same thing in different words: Ctrl-T is very random. Sometimes it opened the chat popup instantly. Sometimes it did nothing — not even an error. Same terminal, same screen, same key. First press of the session would work, three presses in a row would work, then a press after closing the popup with ESC would go dead. Then it would work again. There was no pattern, which was the most maddening part — a consistently broken key is a bug report; an inconsistently broken key is a haunting.

Blackjack in Phosphor: A Door Game as a Language Test

Sat, 19 Sep 2026 00:00:00 +0000

Every language looks fine in its own test suite. The tests were written by the same people who wrote the language, with the same blind spots. The only honest benchmark is a program someone actually wants to run.

So when the question came up — “would it be easy to create a simple blackjack game for the BBS?” — the answer was: yes, and that’s exactly the test Phosphor needs. Blackjack is a sweet spot for a scripting language’s first real workload. It has genuine state (a shuffled deck, two hands, a bankroll), real control flow (a dealer AI that hits to 17, ace soft/hard counting), string wrangling (card glyphs), user input, and persistence. If the parser, the evaluator, and the door bridge can carry all of that, the language is real. If they can’t, we find out where.

UserDefaults for a BBS: A Generic Preferences and State API

Sat, 19 Sep 2026 00:00:00 +0000

Every non-trivial app eventually faces the same question: where does small user configuration live, and where does user data live? macOS answered this decades ago with two separate systems — UserDefaults for typed, user-visible settings, and the file system for documents. We had been living with neither, and it showed.

The mess we had

Phosphor already had a real preference engine. PreferenceResolver resolves settings through three levels — user, then group, then global — backed by the database, cached with proper invalidation, and connected across processes with Postgres LISTEN/NOTIFY. Screens could even bind to a preference reactively, so flipping a toggle redraws every open screen instantly. For the language side, .phos scripts read settings with pref("key") and write them with set_pref("key", value).

Give Every Column Its Fair Share: Per-Column Widths in the jterm Table Widget

Fri, 18 Sep 2026 00:00:00 +0000

Tables are the workhorse of every BBS screen. Message lists, who’s online, file areas, the sysop’s session dashboard — all of them are just rows and columns. And until this week, every column in a jterm Table got the same slice of the screen. Seven columns at 80 characters? Eleven characters each, whether you’re rendering a two-letter status flag or a 24-character username.

Equal division is the correct default — it’s fair, it’s predictable, and it requires the developer to decide nothing. But “requires no decisions” is a polite way of saying “offers no control.” A session table’s Screen column wants room to breathe; its Spy column (a two-character checkbox) is wasted space at eleven characters wide. The information density of the screen was being decided by arithmetic, not by design.

The Case of the Garbled Borders: Fixing SyncTERM Support

Fri, 18 Sep 2026 00:00:00 +0000

Every BBS lives or dies by its client support. MuffinTerm works. The web client works. And then a user pointed out that the most popular terminal program in the BBS world — SyncTERM, the client that most of the people dialing into boards in 2026 are actually using — rendered every screen as mojibake. Box borders turned into ┬í┬┐ soup. The login screen was unreadable. Our own sysop confirmed it the same evening from his own machine: “completely messed up.”

The Doorbell for the Dev Blog: Why We Ship an RSS Feed

Thu, 17 Sep 2026 00:00:00 +0000

Every post from this dev log — 39 of them now, from “Why I’m Building a BBS in 2026” to this morning’s piece on the three-door security model — is available over RSS at:

https://phosphorbbs.net/index.xml

Paste that into any feed reader and the posts come to you as they publish. That’s the whole feature. But it’s worth a short post, because RSS is doing something specific for this project, and because most readers stopped being shown how feeds work about fifteen years ago.

Whitelist, Gray List, Blacklist: The Three-Door Security Model

Thu, 17 Sep 2026 00:00:00 +0000

A community server needs doors with different rules. Some addresses should always get in. Some burned their welcome and should cool off. And a few — after a human looked at what they did — should never come back, from any transport, ever.

Phosphor’s connection security grew one layer at a time, and the result is a three-list model that’s worth explaining as a unit, because each list answers a different question.

Page Sysop: The Classic BBS Ritual Gets a Phone Push

Wed, 16 Sep 2026 00:00:00 +0000

Every classic BBS had a ritual for I need a human right now: page the sysop. It was the doorbell of the system — one keypress, a line of text, and somewhere in the house a person heard a chime and knew someone was waiting. Legacy boards grew it organically because they had a specific human property: the sysop was a person in a room, not a support ticket queue.

Five Bugs in One Morning: Debugging the Phosphor iOS Client

Fri, 04 Sep 2026 00:00:00 +0000

The QR pairing post ended with a working native iOS client for Phosphor BBS. What it didn’t cover is what happened next: the app crashed randomly, the keyboard never appeared, and the whole UI rendered in a sad little window in the middle third of the screen. One morning of debugging later, every bug had a root cause, and every root cause was a lesson worth writing down.

This is a war story. Five bugs, five root causes, and the one thread that ties them together: things that pass every test and still fail on real hardware.

The Screen That Lied: Building Idle Timers That Actually Tick

Fri, 04 Sep 2026 00:00:00 +0000

Here’s a bug report you can’t reproduce with a test: “the sessions view shows a list of users logged in, and when they change state Connected → disconnected the display updates immediately — but the idle time doesn’t update. If I quit the window and reopen it, the idle times are current again.”

The sysop was right, and the cause was architectural. Every screen in Phosphor BBS is drawn by our own terminal UI toolkit, jterm — a pure-Java, lanterna-style TUI framework with double-buffered, diff-based refresh. That diff-based refresh is the crown jewel: when you redraw, you only pay for the cells that changed. But it had a blind spot.

A QR Code on a Text Screen: Pairing Phones to a BBS Without a Login

Wed, 02 Sep 2026 00:00:00 +0000

There’s a moment in every mobile-client story where the design gets embarrassing. Your BBS just grew a beautiful native iOS app — SwiftUI, an embedded terminal, SSH, the works. And then someone asks the question that matters: how does the phone prove it’s you?

The boring answer is a login form on a touchscreen. Type your username. Type your password. Maybe paste a token. On a touch keyboard. For a terminal system whose whole identity is that it never needed a GUI.

Ctrl+C to Step Away: Keyboard Shortcuts for Phosphor's Session Persistence

Mon, 31 Aug 2026 00:00:00 +0000

Last week we shipped session persistence for Phosphor BBS: detach your session, close your terminal, reconnect later, and your screen, cursor, and half-finished input are exactly where you left them. The first post covered the detach/reattach architecture. This post is about the keyboard shortcuts we built to make it feel right.

Because the hardest part of session persistence isn’t keeping the state alive — it’s making the exit feel natural.

The key binding problem

A BBS is not a shell. When you SSH into a Linux box and hit Ctrl+C, you’re sending SIGINT to the foreground process. When you hit ESC in vim, you’re entering normal mode. These are deep muscle memories, and every terminal application has to decide how to honor or override them.

Lite Emacs in Your BBS: The Key Bindings That Make Phosphor's Text Fields Work

Mon, 31 Aug 2026 00:00:00 +0000

If you’re the kind of person who reaches for Ctrl+A to jump to the beginning of a line, or Ctrl+K to delete everything from the cursor to the end, Phosphor’s text fields already speak your language. Every text input in the BBS — username, password, chat message, board post, search query — uses the same set of emacs-inspired key bindings, alongside the arrow keys and Home/End you’d expect.

This is a reference post. Bookmark it.

The Case for Running Your Own Digital Third Place

Sat, 29 Aug 2026 00:00:00 +0000

There’s a sentence we keep coming back to: “I run a DTP server.”

DTP stands for digital third place. If you know Ray Oldenburg’s work, the third place is neither home nor work — it’s the barbershop, the bowling league, the café where the staff knows your order. Sociologists have spent forty years explaining why these places hold communities together, and for the last decade the internet’s best versions of them have been run by companies that turn your community into their product. This post is the case for running the third place yourself — on a DTP server, a category of software that now exists because Phosphor made it real.

tmux for Your BBS: Phosphor Sessions Now Survive Disconnects

Sat, 29 Aug 2026 00:00:00 +0000

If you’ve used tmux or screen, you already understand what we just shipped for Phosphor BBS: the ability to walk away. Close the laptop. Lose the train tunnel Wi-Fi. Kill the app by accident. Come back — and everything is exactly where you left it.

That’s now how sessions work on a Phosphor DTP server. And it changes what kind of place your community server can be.

The problem: a socket is not a person

Traditional BBS software — and, honestly, most modern chat infrastructure — ties a user’s session to a network connection. The socket closes, the connection dies, and everything the user was doing evaporates. You were halfway through writing a long post, three screens deep into a file area, mid-conversation in a chat channel. Gone. Reconnect and you’re back at the login prompt, starting over.

Your BBS in Your Pocket: Push Notifications and the Mobile-Ready Phosphor

Sat, 29 Aug 2026 00:00:00 +0000

The old argument against BBSes — and self-hosted community servers generally — used to be simple: they’re not where you are. A terminal lives on a desk. Your community lives on your phone, in your pocket, buzzing you when something happens. We fixed that. Phosphor BBS is now mobile-ready in the way that matters: it can reach out and grab you when your community needs you, and put you back exactly where you were when you answer.

Live Spellcheck in a Terminal: Yellow Highlights, No Popups

Sat, 15 Aug 2026 00:00:00 +0000

Every modern editor highlights misspelled words as you type. Squiggly red underlines in Word, yellow backgrounds in Google Docs, dotted lines in VS Code. It’s so standard you forget it’s there — until it isn’t.

Terminals don’t have spellcheck. The terminal is a character grid. There’s no DOM, no CSS, no per-character styling primitive. Or so the conventional wisdom goes.

We just shipped live inline spellcheck in jterm and Phosphor BBS. Misspelled words light up in yellow as you type — in chat, board posts, mail compose, any text field. No popups, no pre-submit prompts, no context switches. Just yellow where the typos are.

Ghost Text Completion: Bringing Modern Editor UX to the Terminal

Fri, 14 Aug 2026 00:00:00 +0000

If you’ve used VS Code, fish shell, or Google’s search bar, you’ve seen ghost text — that dim, semi-transparent suggestion that appears ahead of your cursor as you type. You ignore it if it’s wrong. You press Tab to accept it if it’s right. It never gets in your way, but when it works, it saves you keystrokes.

We just shipped ghost text completion in jterm and Phosphor BBS. Every text input — chat messages, board posts, mail compose, even the mail “To” field — now suggests completions as you type. Press Tab to accept. Press anything else to dismiss.

Animated Borders: Living Frames in a Terminal UI Toolkit

Wed, 12 Aug 2026 00:00:00 +0000

A border in a terminal UI is usually a static thing. Four corners, four edges, drawn once and forgotten. Box-drawing characters sit there like a picture frame — functional, boring, dead.

jterm’s new AnimatedBorder system changes that. Borders can now sparkle, march, rotate, pulse, and scan. The login dialog in Phosphor BBS picks one at random for every new connection, so each user sees a different animated frame when they log in. The terminal isn’t a static page anymore — it’s alive, even down to the border.

Designing Reusable Config Screens: From Vertical Labels to Table Layout

Wed, 12 Aug 2026 00:00:00 +0000

Every config screen in Phosphor BBS used to be a snowflake. SystemConfigScreen had its own layout. AiConfigScreen had its own layout. They looked different, behaved differently, and shared no code. Adding a new settings screen meant copying one of them, stripping out what you didn’t need, and writing the rest from scratch.

This is the story of how we fixed that — extracting a reusable TableConfigScreen parent class and converting every config screen to the same table-based layout, killing about 150 lines of boilerplate in the process.

The Auto-Approve Dead-End: A BBS Onboarding Bug Story

Wed, 12 Aug 2026 00:00:00 +0000

Here’s a bug that’s easy to introduce and embarrassing to discover: a new user creates an account on your BBS, the system auto-approves them, generates a temporary password, and sends it to their BBS mailbox. The user can now read that password — by logging in. Which requires the password. Which is in the mailbox. Which they can’t open.

Classic chicken-and-egg. Let me walk through how this happened, why it was hard to spot, and how we fixed it.

Hal: An AI SysOp That Never Leaves the Server

Fri, 07 Aug 2026 00:00:00 +0000

Phosphor has a staff member now. His name is Hal, he listens on the #sysop channel and to direct messages, and he can answer “who’s online,” look up connection logs, walk through board stats, or take care of routine admin work — while the sysop is doing something else. Everything he knows and does stays on the machine the BBS runs on.

The off-grid constraint

The design rule that shaped everything: AI features use local Ollama only. No cloud APIs. A community server whose value proposition is you own the place cannot quietly forward your users’ conversations to a third party. Hal runs against localhost:11434, silently disables if Ollama is down, and is opt-in, off by default. If the network is gone, Hal keeps working — which matters for a server that’s supposed to run through anything.

Two Dialects, One Schema: Supporting H2 and Postgres Without Losing Your Mind

Fri, 07 Aug 2026 00:00:00 +0000

A BBS should boot on a laptop with no database server installed. It should also run a production community for years on a real database with real operational tools. Those are different requirements, and Phosphor satisfies both by maintaining one schema in two dialects: PostgreSQL for production, embedded H2 for zero-config installs.

This post is the field guide to what that actually costs — the failure modes, the patterns that keep them manageable, and the bugs we hit so you don’t have to.

From IRC to iMessage: Rebuilding BBS Chat for 2026

Mon, 03 Aug 2026 00:00:00 +0000

The original BBS chat was IRC. You’d type /join #lobby, see messages scroll by in a flat log — <joe> hey everyone — and if you wanted to talk to someone privately, you’d type /msg joe hey man. It worked. It was 1992.

But nobody talks like that anymore. Your phone shows messages as bubbles. Group chats have avatars and timestamps that fade into the background. You tap a channel name to switch rooms. You @-mention people. The IRC command syntax feels like a foreign language to anyone who grew up with iMessage and Telegram.

How to Build a Digital Third Place That's Actually Yours

Sun, 02 Aug 2026 00:00:00 +0000

You’ve read about digital third places. You understand the problem — Discord isn’t yours, Slack is for work, X is a firehose, Reddit sold your API access. You want a community space you actually own.

Here’s how to build one.

What a real third place needs

Before the how, the what. A digital third place needs five things:

Persistence. The space exists whether you’re there or not. Messages stay. History builds. The community has memory.
Ownership. You control the server, the data, the rules. No platform can change the deal.
Low friction. People can join without downloading an app, verifying a phone number, or accepting a 47-page terms of service.
Regulars. People who come back, know each other, and notice when someone’s missing.
Conversation first. The main activity is talking to people — not scrolling a feed, not playing an algorithm.

If your community platform fails any of these, it’s not a third place. It’s a product you’re using until the company that owns it decides otherwise.

One Platform for Three Things You're Doing in Three Places

Sun, 02 Aug 2026 00:00:00 +0000

You use three different tools for three different kinds of communication. You probably don’t think about it this way, but you do.

Slack or Discord for chat. Real-time, instant, conversational. You’re talking with people right now. Messages flow, responses come in seconds, the conversation moves fast. It’s great for “what are we doing right now” and terrible for “what did we decide last month.”

X or Mastodon for broadcasting. One-to-many, short-form, public. You’re talking at people. A post goes out, it reaches followers, replies trickle in. It’s great for “look at this” and terrible for “let’s discuss this in depth.”

The Internet You Visit on Purpose

Sun, 02 Aug 2026 00:00:00 +0000

There’s a feeling people have about the old internet that they can’t quite name. They remember it — or feel like they should remember it — as a place you went. You connected to something. You arrived somewhere. You were there on purpose, and when you were done, you left.

The modern internet doesn’t work like that. It comes to you. It’s in your pocket, on your wrist, in your glasses. It pushes notifications, feeds, stories, reels, alerts. You don’t visit it. It visits you — constantly, relentlessly, whether you asked it to or not.

The Third Place Problem With Discord

Sun, 02 Aug 2026 00:00:00 +0000

Discord is the most successful digital third place ever built. 200 million people use it every month. Millions of communities live there — gaming groups, study circles, maker spaces, open source projects, friend groups, neighborhoods. It’s where people go to hang out.

And it’s being sold out from under them.

The pattern

Every platform that becomes a third place goes through the same cycle:

Launch. Free, open, no ads, no friction. “We’ll never sell out.” The community grows because it feels safe.
Growth. Investment pours in. The platform scales. Features ship. The community deepens. People invest years building their space.
Monetization pressure. Investors want returns. The platform needs revenue. Ads appear. Premium tiers launch. Data gets harvested.
Enshittification. The community becomes ad inventory. The experience degrades. The rules change. The third place you built is now a storefront, and you’re the product.

This isn’t hypothetical. It’s a documented pattern.

What Is a Digital Third Place?

Sun, 02 Aug 2026 00:00:00 +0000

In 1989, sociologist Ray Oldenburg wrote The Great Good Place and gave a name to something everyone already knew: we need three places. The first place is home. The second place is work. And the third place is the somewhere-else — the pub, the café, the barbershop, the park bench — where you go not to live or to produce, but to be. To be around people. To belong to something that isn’t your family and isn’t your employer.

Federated BBS: How Phosphor Makes Multi-Node Sync Declarative

Fri, 31 Jul 2026 00:00:00 +0000

Every BBS in the 80s and 90s was an island. Your callers dialed your node. Your boards lived on your machine. If you wanted to share content with another sysop, you mailed a floppy.

Phosphor changes that. Federation is now declarative — you write 10 lines of Phosphor instead of 200 lines of custom Java protocol code.

The Problem

Today, adding a new syncable resource to a BBS means writing custom Java serialization, a custom message type, a custom deserializer on the receiving end, and custom conflict resolution. This is why most BBS systems only sync boards and chat messages — everything else is too much work.

Phosphor Progress — From Parser to Federation

Fri, 31 Jul 2026 00:00:00 +0000

Twenty-nine commits. Six phases. One language. Here’s where Phosphor stands after the most intense development sprint yet.

The Journey So Far

When I wrote about building the Phosphor parser, the language was a lexer and a dream. Phase 1 was five tasks — tokenizer, parser, declarative processor, hot-reload, BBS wiring. It felt like a lot at the time.

It wasn’t.

Phases 1-2: Foundation

The declarative layer came first. Define your BBS structure — menus, boards, channels, file areas, themes — in a readable syntax. Save the file. The BBS syncs to the database automatically. No restart, no recompile.

Building a Lexer and Parser for a BBS Programming Language

Thu, 30 Jul 2026 00:00:00 +0000

How do you build a programming language for a BBS? You start with the same tools every language uses: a lexer to break source code into tokens, and a parser to turn tokens into a tree. This is the story of how Phosphor’s lexer and parser work, with real code from the implementation.

The Design

Phosphor is a domain-specific language for BBS configuration and behavior. It has two layers:

Declarative — describe the BBS structure: menus, boards, channels, file areas, themes. Imperative — define behavior with event handlers, expressions, and control flow.

Declarative UI: Building Terminal Screens with Widgets in Phosphor

Thu, 30 Jul 2026 00:00:00 +0000

Most BBS systems render screens the hard way: imperative code that clears the terminal, prints line by line, and redraws on every update. It works, but it’s verbose and fragile. One missed redraw and the screen is stale.

Phosphor takes a different approach. You describe the screen as a tree of widgets. The runtime handles rendering, re-rendering on data change, and input routing. You only write callbacks for interactive behavior.

Building the Phosphor Parser — Week 1 Dev Log

Wed, 29 Jul 2026 00:00:00 +0000

The first phase of Phosphor implementation is underway. Here’s what’s happening and why it matters.

The Problem

Every BBS system has the same issue: configuration is either too rigid (hardcoded in the application) or too generic (a config file that can’t express behavior). You want to add a new menu item? Edit Java, recompile, restart. You want a custom login handler? Write a plugin, package it, deploy it. You want to send mail to new users automatically? More Java, more compilation, more restarts.

ANSI Sprites: Animation in a Terminal UI Toolkit

Tue, 28 Jul 2026 00:00:00 +0000

A terminal is a grid of characters. Each cell holds one glyph, one foreground color, one background color. That’s it. There are no pixels, no sprites, no animation frames. At least, that’s what you’d think.

jterm’s sprite library takes that grid and turns it into a animation engine. ANSI art frames become sprite frames. A sprite sheet — a single ANSI file with a grid of cells — becomes a flipbook. Virtual threads drive the animation loop. And the terminal becomes a screen.

Threading the Flood: How Echomail Learned to Stay in Line

Sun, 19 Jul 2026 00:00:00 +0000

Federation is easy to demo and hard to make boring. The exciting part — a post appears on three servers — takes a weekend. The boring part, where the same post shows up in the right thread, with the right timestamp, exactly once, on every node, takes a month of small fixes. This is that month, told through echomail: Phosphor’s flooded, group-addressed message type, the modern replacement for the classic echo areas.

Some Rooms Are Yours Alone: Local-Only Boards and Export Control

Thu, 02 Jul 2026 00:00:00 +0000

The moment you connect your community server to federation, you’ve made a promise on behalf of everyone who posts there: what’s written here travels. For a public board that’s the point. For the board where a handful of regulars plan the group’s next event — or anything else that was only ever meant for the local room — that promise is a privacy incident waiting to happen.

So Phosphor made the boundary explicit, per board, at the schema level.

Terminal Animations: Starfields, Warps, and Living Backgrounds

Sun, 21 Jun 2026 00:00:00 +0000

A BBS login screen used to be a static ASCII banner. You’d connect, see a logo made of text characters, type your username and password, and that was it. No motion, no life, no atmosphere.

jterm changes that. The login screen in Phosphor BBS has a living, animated background — stars twinkling, plasma flowing, cells dividing. Every time a user connects, the system randomly selects one of six animated backgrounds and renders it behind the login form. The terminal isn’t a static page anymore. It’s a window into a small, alive world.

Message Boards and Mail: Persistent Communication in Phosphor BBS

Fri, 19 Jun 2026 00:00:00 +0000

A BBS without message boards is just a chat room. Boards are where the community lives — threaded discussions that persist over days, weeks, months. You log in, catch up on what you missed, reply to threads, and start new ones. It’s asynchronous communication at its best.

Mail is the private counterpart — user-to-user messages that nobody else can read. Together, boards and mail form the communication backbone of the BBS.

Real-Time Chat on a BBS: Pub/Sub, Channels, and Wall Messages

Fri, 19 Jun 2026 00:00:00 +0000

Chat is the heartbeat of a BBS. In the 90s, you’d log in, see who was online, and jump into a channel. Messages appeared character by character as the other person typed. It felt alive.

Phosphor BBS brings that feeling back — but with a modern architecture. Instead of a single shared screen, every session runs independently, connected through a pub/sub message bus. Messages route by channel. Sessions subscribe to the channels they’re in. The bus handles delivery.

The SysOp Experience: Building Admin Tools for a Modern BBS

Fri, 19 Jun 2026 00:00:00 +0000

Every BBS needs a sysop. The system operator — the person who manages users, moderates boards, configures channels, and keeps the system running. In the 90s, the sysop sat at the physical machine, running tools from a dedicated admin menu. Today, the sysop connects remotely, just like any other user — but with more power.

Phosphor BBS gives the sysop a full terminal-based admin panel. You connect over Telnet or SSH, log in as a sysop-level user, and get access to tools that regular users never see. Everything runs in the terminal — no web dashboard required.

From Modem to SSH: Building a Telnet/SSH Server in Java

Thu, 18 Jun 2026 00:00:00 +0000

In the 90s, a BBS was a modem bank and a phone number. Callers dialed in at 2400 baud, negotiated a connection, and got a text interface. The protocol was Telnet — a standard from 1969 that’s still surprisingly useful today.

But nobody uses modems anymore. Today’s BBS callers connect over the internet, either through raw Telnet (port 2323, a nod to the original) or SSH. Building both into a Java BBS means dealing with two completely different networking stacks, terminal negotiation quirks, and a class of bugs that only appear when real clients connect.

jterm: Building a Terminal UI Toolkit in Pure Java

Wed, 17 Jun 2026 00:00:00 +0000

Every BBS needs a terminal. But not just any terminal — a fast one, with per-character styling, double-buffered rendering, and a widget library that makes building full-screen applications bearable. That’s what jterm is: a pure-Java terminal UI toolkit with zero native dependencies.

The Three-Layer Architecture

Terminal (raw ANSI/VT100) → Screen (double buffer + diff) → GUI (widgets + layout)

Each layer has one job:

Terminal — raw I/O. Reads keystrokes, writes ANSI escape sequences, handles raw mode and terminal resize events.
Screen — double-buffered rendering. Maintains a front buffer (what’s on screen) and a back buffer (what’s being drawn). On refresh, diffs the two and only sends the changed cells.
GUI — widgets and layout managers. Labels, tables, text boxes, panels, menus. The stuff you actually want to use.

This separation matters. You can use jterm at any layer — raw terminal access for a door game, screen buffering for a custom renderer, or the full widget library for a typical BBS screen.

Why I'm Building a BBS in 2026

Sun, 14 Jun 2026 00:00:00 +0000

I ran a BBS when I was younger. This was before the web — you’d dial in on a modem, read messages, play games, chat with people in your town. It was a community. Then the internet happened, and BBSes faded.

But here’s the thing: what BBSes did well — community, conversation, shared space — the modern internet does badly. Social media is a firehose of noise. Discord is a walled garden. Slack is for work. Nothing feels like a place the way a BBS did.