#forth

JUPITER ACE (1982)

the home computer that refused to speak BASIC

Every single home computer in 1982 ran BASIC. Every single one except this little white box from Cambridge.

the origin story

Two engineers walk out of Sinclair Research and decide to build their own machine. Steve Vickers wrote the ZX Spectrum's BASIC. Richard Altwasser designed its motherboard. Their verdict on BASIC? They weren't fans.

"Comparing Forth to Basic is like comparing a Gothic cathedral to a mud hut." — Steve Vickers, 1982

They named their company Jupiter Cantab, rented a spare room in Altwasser's house in Cambridge, and got to work.

what made it weird

The Ace ran FORTH — a language where you stack tiny building blocks called "words" on top of each other. Alien syntax, steep learning curve, and absolutely beautiful to the right kind of mind. It ran 10× faster than BASIC on identical hardware. The machine had a Z80A chip, 3KB of RAM, and cost £89.95.

No colour graphics. No software library to speak of. Just raw, elegant speed.

the rise and fall

April 1982 ZX-Spectrum launches. Vickers & Altwasser quietly start planning their exit.

September 1982 Jupiter Ace goes on sale. Built in a spare room.

December 1982 Stocked by Laskys and Debenhams. Christmas boom. Optimism.

July 1983 Altwasser quits to be with his newborn. The writing is on the wall.

November 1983 Jupiter Cantab folds. 14 months of existence. £140K in debt.

why it failed (and why that's sad)

The market wanted games. Kids wanted BASIC. The Ace had monochrome graphics, almost no third-party software, and a language that required you to think differently. It wasn't a bad machine — it was a machine built for a world that didn't exist yet.

"We sold a lot of machines to the few hundred Forth enthusiasts — and that was it." — Steve Vickers, looking back

PikaPC Runs Mandelbrot ... Fast

I've used a Mandelbrot fractal rendering program written in BASIC as a sort of benchmark for all my homebrew projects. It's fairly computationally intensive and it's a decent visual demo.

Well I have a new homebrew project, and while it's not running BASIC, it is running Forth, a high-level environment. It's time to run Mandelbrot.

I've never used Forth before. Rosetta Code has a couple example Forth programs for rendering color bitmap images that should be a good starting point. I immediately ran into problems though. To start, PPCForth is a very minimal Forth implementation. There are common Forth words that aren't included. Forth is traditionally written in Forth so missing words is something that can be worked around. But then things got weird.

It started with Forth giving errors about unterminated loops and conditionals. PPCForth only supports the Forth do..loop (incrementing) and begin..until (conditional) loops. I found that it has a bug where an if..then statement inside a begin..until loop will choke up the function compiler. That seriously reduces the utility of the begin..until loop, but I can work around that.

Working around the begin..if..then..until loop bug, I was able to get it to compile my function without error, but when it ran it just ran unchecked, never exiting the do loops. I did some tests and found that it can handle nested loops without issue. And then I found the next big bug in PPCForth — the leave word, which should exit a loop early, breaks nested loops. Ok, I can work around that too.

Finally, I had a program that would run to completion and exit as expected. But its output was just a solid rectangle of the same character repeated. I tried adjusting starting values, iteration limits, conditions, etc. Best I could get it to do was render a small circle in the middle of the output instead of anything that resembled the Mandlebrot set.

This time the bug was my own code. Since PPCForth doesn't have floating point number support, I needed to build the program to use integer arithmetic only. To do this, I scaled all numbers by 1000 to use fixed-point arithmetic (e.g., the number 0.5 would be represented as 500). But I've never been great with mathematics and I had missed something important — adding and subtracting scaled numbers requires no modification, but multiplying two scaled numbers requires an additional step of dividing the product by the scaling factor. A few new division instructions later, and finally I had a working Mandelbrot fractal renderer in Forth.

It takes less than two seconds.

My 68000 project took something like ten minutes to run the BASIC program, and Wrap030, at its fastest, took something like ten seconds to run the same program. An assembly version using the 68882 floating point coprocessor on Wrap030 took right at two seconds.

This is definitely not a one-to-one comparison. A BASIC interpreter is much heavier than Forth, and BASIC was using slower floating-point arithmetic instead of faster integer arithmetic. In addition, I've weakened PikaPC by using only an 8-bit ROM bus and 16-bit RAM bus, where Wrap030 can run programs from a full 32-bit RAM bus. Even still, PikaPC running a higher-level language on a reduced memory bus is comparable, if not faster, than my 68030+68882 running bare-metal at the same clock speed. PikaPC is off to a great start.

Well now that it runs, how fast can I get it to run?

I am running PikaPC at the rated speed of its CPU, 25MHz. Can it be overclocked?

32MHz? No problem.

40MHz? Runs just fine.

50MHz? It's definitely unhappy, but it does eventually boot and run the Mandelbrot program. And wow does it ever! At this point, the limiting factor is the 38400bps serial connection to the terminal.

Below the break is a gif of PikaPC overclocked to 50MHz running the Forth Mandelbrot program. The video has not been sped up; it really is that fast. It might be a little uncomfortable for those with sensitivity to flashing lights.

What's next for PikaPC? I want to add video output. I have some ideas I want to explore with video generation, and since I've made the jump to 3.3V logic this would be a great time to also make the jump from CPLDs to FPGAs.

For now, all of the design files and code are available on GitHub.