July 14, 2026 - Out of the Quiet: VCF East, a Public Beta, and Batch 6
====

 [SubHeading: The one where I finally tell you how VCF went]

The last time I posted here in earnest about FRST, back in December,
I was "exiting stealth mode" -- taking preorders, promising EVT boards
"in a few weeks," and cheerfully imagining decks in backers' hands by
Spring.  And then the phlog went quiet.  My apologies for that -- but
the quiet wasn't idleness.  If anything it was the opposite.
I disappeared into the lab, and I owe you the story of where I went.

The short version: I took FRST to VCF East, and then I spent the
spring making the software genuinely, unreasonably good.  The longer
version is below, and it's a big one -- grab a coffee, or, you know, 
just skim and drop to the TLDR; below. ;)

## VCF East: FRST's first public outing

In April I packed up my three MODEL4 prototypes -- two rainbow, one
black -- and took FRST to VCF East -- the project's first public
debut.  It was a real sprint to get the firmware demo-worthy and
there were plenty of things that only got half-finished, but VCF
was the perfect venue and the response was great.

(I also took a Model 3 -- to help give context for the Plan 9
evolution -- and who doesn't love seeing Doom on a tiny screen?)

Showing a strange little e-ink Plan 9 terminal to people who _get_
strange little machines is a particular kind of joy.  What got me was
how many of them just... _got it_, right away -- no long pitch needed.
My favorite moment of the whole show: someone looked it over, thought
for a beat, and said, "I don't know what it is, but I want one."  :)

There's a fitting bit of symmetry, too.  VCF was celebrating the Apple
1's 50th birthday -- a real, original Apple 1 was being demoed in the
next room over.  So I set FRST's show price at $333.33, on the
logic that I'm promising a machine only _half as good as an Apple 1._
And a few folks took me up on it and put money down on the spot --
which is how Batch 6 quietly got its start (more on that below).

If you came by the table and tried it -- thank you.  It meant a great
deal.  And if this alternate-timeline idea of mine resonated with you
even a little, well... read on, because the thing you held in April
has grown up quite a bit since.

## What I've actually been building

Here's the confession that explains the silence: somewhere along the
way I made a decision to ship you something that is genuinely _good_.
To take the strong foundation of the Public Alpha's demos and fulfill
the mission to build something I want to use every day -- doing the
kinds of things still worth doing on a computer.  I went deep on the
software and I'm excited to share that the Public Beta release looks
great and I've been daily-driving this beta branch and it's perfect
for navigating the "old Internet" -- the proto-web era of gopherspace
and [telnet] BBSes.

(A reminder for new visitors: I've chosen to leverage the latest
Claude models to assist in this development.)

Here's just a few of the highlights of the FRST Computer Public Beta:

The shell and the namespace.  At the center is `zrc`, an rc-flavored
shell in the spirit of Plan 9's command language -- pipes, functions,
etc.  And now it runs as _multiple_ shells now, screen-style: three
concurrent sessions you flip between with a keystroke.  Read in one,
download in another.  And underneath it all is the thing that makes
all of this possible:  the flux capacitor!  I mean, a 9P namespace!  ;)
Files, devices, and remote servers all hang under one tree, bound with
`mount` and `bind`.  "Everything is a file" isn't a slogan here; it's
the plumbing.

The network is a filesystem.  This is where the Plan 9 thesis
stops being theoretical and starts being _fun_.  You `attune` to a
data crystal and borrow its uplink -- and here's the trick: that
uplink can ride over Bluetooth.  Switch a FRST's WiFi off entirely and
it still reaches gopher, telnet, and BBSes over BLE, using either an
Aether Data Crystal (more on that in a future post, I suppose) or my
AetherNet gateway/companion iOS app.  You see, the power of 9P allows
each deck to mount the remote '/net' fs locally, borrowing the network
stack of a remote device. (more on some of the other fun things this
property affords later...)

The TCP apps now include finger client and a pretty serviceable telnet
client, backed by a real `vt` VT100/ANSI emulator, but it's the gopher
browser that's the real star -- complete with inline images and a few
helpful (gopher++?) extensions.  Oh!  And the LoRa mesh shows up as a
filesystem too -- `/net/aether`, with your neighbors and live stats
as _files_ -- and `achat` for mesh messaging and file transfer with
no towers, no accounts, no subscriptions.  (that's right, 9P over
LoRa!)

Pictures on a 1-bit screen!  The e-ink terminal renders with
partial-refresh so typing feels alive, and it grew an image pipeline:
PBM, and now JPEG / PNG / GIF, decoded and Floyd-Steinberg dithered
down to crisp 1-bit for the display.  Real photographs, on paper-white
e-ink.  There is also a persistent two-bar status chrome framing every
screen -- your shell up top, and along the bottom a little dashboard of
signal, mesh activity, memory, uptime, and a clock, each with its own
hand-drawn pixel icon.  Small, deliberate touches.

And then there's the rest:  Editors (`ed`, `sam`, `vi`, a structural
editor), a pile of games and emulators -- Zork and friends via Frotz,
a from-scratch Apple 1 (that one I built in an evening, just in time
for Apple's 50th), chess, fractals -- pForth, CGA-key identity via
`factotum` (your mesh address is _derived from your own key_, not
handed to you), and -- my favorite bit of engineering pride -- the deck
captures its own coredumps to flash and hands them back over 9P.  It
can tell you why it fell over.  That last one came out of a long,
character-building hunt through a family of BLE/9P/L2CAP crashes: JTAG
sessions, and stack overflows.  And if _you_ hit a bug, sharing the
dump is opt-in and on-brand:  copy it over 9P to the official FRST BBS
(bbs.frstcomputer.net) with your report.

## You can run it right now

Here's the part I'm possibly most excited about: you don't have to
take my word for any of it, and you don't even need a deck.  The
_actual firmware_ -- the same code that runs on the hardware -- is
compiled to WebAssembly and runnable in a browser tab -- over at
frstcomputer.com.  Dial in to the FRST BBS, wander gopherspace,
telnet to your favorite BBS or pubnix, poke around.  (Type `web` once
you're in and it'll give you the lay of the land.)

There's a metered guest tier so anonymous visitors get the whole
gopher/BBS internet -- and when you're ready to make it yours, type
`attune` and it does the rest: mints your cryptographic key, asks you
for a handle, and puts you on the official FRST board, all in one go.
Your identity and your files persist right there in the browser, so
it's a machine you can return to, not a kiosk that resets.

The medium really is the message here.  You can even order a deck
_through_ the deck -- the gopher store is served the same way you'd
reach any board.  Go touch it tonight.  I'd genuinely love to know
what you think.

## And you can read it, too

As of tonight, the firmware source is published.  The whole thing --
the shell, the namespace, the gopher client, the Apple 1, the
coredump plumbing -- is yours to read, build, and patch.  A computer
you own completely should be one you can _know_ completely; that was
always the deal.  And where else would source live but the gopher
hole:

    gopher://frstcomputer.com/1/files
    (frst-1.0.0-beta-src.tar.gz, checksummed, reproducible)

## On hardware -- an honest word (Batch 6)

Now for the hardware update...  All that software depth is exactly
why the hardware isn't as far along as I'd hoped -- something had to
give, and I chose to make the thing _worth_ holding before I held to a
date.  The remaining work is the production board:  Batch 6, the first
proper PCB to replace the hand-wired devkit builds.

The good news is that it's a lot further along than "someday."  Where
it actually stands:

    - Component selection: done.
    - Parts placed on the board: done.
    - Board outline: done.

What's left is the fiddly, physical part -- the mechanical interface:
how the board meets the case, the accessories, the connectors and I/O.
Then I get a first run fabbed and test it.

So my whole focus for the coming month is right there: finish the
layout, get boards printed, test them, spin once if I must.  In the
meantime the Public Beta is out in the browser for anyone to beat on,
and I'll be triaging whatever bugs surface -- but the boards are the
thing.

## Batches, plainly -- and how to get one

I've decided to keep this simple, so here's the whole plan in two
lines:

    Batch 6  -- DVT.  The first full form-factor board, built to be
                handled and lived with (not hand-wired).  Ten units.
    Batch 7  -- EVT.  A refined board, off everything Batch 6 teaches
                me.  A proper little production run [~50? 100?].

Batch 6 is deliberately tiny -- _ten decks_, and that's genuinely it.
Four are already spoken for.  So there's just a small handful of
Batch 6 slots left -- if being among the very first ten appeals to you,
move quick, because ten is ten.

On price, plainly: a MODEL4 is **$444.44**, and $50 holds your slot in
either batch.  The $333.33 you saw at VCF was a show special -- an
introductory price for the folks willing to put money down on a
hand-soldered prototype.  That's the deal early believers get.

If Batch 6 fills (or you'd simply rather have the more polished board),
Batch 7 is where the wider run lives.  Either way, I'm taking slots
now -- and the gopher-commerce store is open:  (enter your name into
your 'query' prompt to kick-off your personalized store experience)

gopher://frstcomputer.com/7/store

## Closing: the alternate timeline is materializing

I keep coming back to this idea of an _alternate timeline_ -- the one
where personal computing stayed personal, where the network was small
and neighborly and yours, where a computer was a tool you owned
completely instead of a portal someone else operates.  For three years
that was mostly a feeling.  This spring it became a system you can boot.

We traded files for feeds, tools for apps, ownership for convenience.
FRST is my small, stubborn argument that we didn't have to.  It's
slower on purpose.  It's text-forward on purpose.  The constraint is
the point.

Thanks for reading all the way down here -- or for skimming honestly,
which I respect just as much.  More soon, and I mean it this time. :)

--
Jon
.