What looks like a Sinclair ZX81 but runs Forth? If you said a Jupiter ACE, you get a gold star. These are rare because ordinary people in 1982 didn’t want Forth, so only about 5,000 of the devices were sold. [Cees Meijer] assumes they are unaffordable, so he built a replica and shows you how you can, too. [Scott Baker] built one recently; you can see his video below.
The resemblance to the Sinclair computer wasn’t just a coincidence. Richard Altwasser and Steven Vickers were behind the computer, and both had worked for Sinclair previously. In addition to being famous for using Forth, the machine initially had a badly manufactured case and an unreliable keyboard. A later version tried to correct these issues, but there were fewer than 1,000 made. [Cees’] replica used a design from [Grant Searle] with some modifications.
We liked the realistic look of the 3D printed keyboard. The keyboard uses white plastic with raised letters. A quick black spray paint followed by sanding gives the appearance of black keys with white printed text.
Overall, this is a good-looking build of a computer you probably won’t see in person. We wish Forth had caught on in the early PC world, but it didn’t. [Grant] was prolific with replica computers, and [Cees] isn’t the only one who used that work as a starting point for their own projects. If you want real old-school Forth, you have to go back a few more years.
There is no need to go this way. There was a Forth interpreter written in BASIC for the Spectrum. :-D
Olaf
Forth, written in BASIC?? That must’ve been slower than molasses in January!
Molasses in January is pretty quick around here.. The trick is to stop it boiling in the sun.
The first thing that grabbed my attention in the video was the Heathkit H8 computer behind him!
Wow, stumbled upon this gem and couldn’t resist sharing a hearty laugh! Who knew a Forth-running Sinclair ZX81 doppelganger existed in the form of the Jupiter ACE? The 3D printed keyboard with the illusion of black keys and white text is a stroke of genius. Kudos to [Cees Meijer] for making the unaffordable a reality with a spot-on replica. Reading this, I’m convinced the 80s missed out on the Forth revolution – imagine a world dominated by Forth-powered PCs! Thanks for the trip down retro-tech lane, [Grant Searle] and [Cees] – you’ve earned a virtual gold star!
So many reasons both ways.
https://retrocomputing.stackexchange.com/questions/3315/early-forth-for-personal-computers
To borrow a sentence: “It gave everyone 100% control of everything all of the time. ” Awesome control, awesome responsibility.
“… if you said Jupiter Ace, you get a gold star.”
Reminded me of a low-end consumer electronics brand in the US during the 1980s, Gold Star. Which could have distributed a cheap personal computer about that time.
https://en.m.wikipedia.org/wiki/GoldStar
Nothing wrong with the brand or their products– was early days and imagine overseas distribution, support back then before Internet and banging rocks together.
These days the brand is called LG, mid- to high-end laptops and appliances.
Lucky Goldstar = LG
I have one of their DMMs hanging in the garage.
The Jupiter Ace was the machine that taught me Forth. The real genius of it is the built-in decompiler. Unlike most Forth systems, code isn’t written in source and then compiled, functions (called Words in Forth) are compiled in-situ and editing them is done with the word ‘edit’, which then decompiles the word on the fly! It can even work for compiler words and definer words (what’s normally called : name ; in FIG Forth). Thus all code is stored in its compiled form and the user doesn’t need to deal with blocks.
The Jupiter Ace has a few significant flaws: the base machine only had 3kB of RAM, of which only 1kB was left for code. It goes about as far as 1k of BASIC on a ZX81; it’s not really more compact owing to the space taken up by definition headers and their names. Secondly, it’s not a fast version of Forth; a 3.5MHz Z80 should be capable of well over 30KIPs, but the Ace barely manages 10KIPs. Thirdly, the keyboard debounce is broken, so it’s always missing keypresses. I originally thought it was due to the ZX Spectrum-like keyboard, but it’s not; the same problem happens on emulators, and it happens because keypress handling isn’t interrupt-driven, so there’s no scanning when it’s processing a keypress. I think the ROM could be modified to fix this.
A decade ago (13 years now), I had a similar problem to the author here, I wanted a Jupiter Ace, but couldn’t afford one, so I developed an Arduino-style self-hosted, Forth-based computer with video out, a keypad for typing programs; 8kB of RAM code for user code and 512kB of flash for program storage. Users would buy the key and children as young as 9 built one.
https://sites.google.com/site/libby8dev/fignition
It’s been featured on Hackaday a few times:
https://hackaday.com/tag/fignition/
Still, getting a Jupiter Ace kit is v tempting, a revolutionary machine!
Are you still selling the kits to the UK?
I sold about 1000 kits around the world (though mostly in the UK, but also the rest of the EU, Australia, and the US). 200 kits were for RS Components in the UK, which kinda prevented me from undercutting them (and they overpriced them), which I think killed it in the end.
I don’t really have enough components left to make more kits, but if there was enough interest I’d order enough components and a PCB for another 100 kits. Ironically, the firmware was pretty much where I wanted it at the end: with floating point arithmetic (better than Jupiter ACE FP as it had higher precision (23-bit binary instead of BCD)); a blitter for proper bitmapped graphics (160×160); multi-block source code editing; some good string functions etc.
I might have to put the price up as there’s been a bit of inflation since 2014 ;-) . I stick to Maker rules for the prices. You can build one on strip board though (I have) and the firmware is freely available.
I saw the team showing the Ace at a computer show in 1982. It looked like a Spectrum, not a ZX81. I thought it was a brilliant idea and would be much faster than BASIC. But the RPN notation of Forth is not a good look and it flopped.
People really seem to have issues dealing with RPN.
A few years ago I bought a single lot of 4 vintage computers for $150. Two Radioshack TRS-80 model 100, and two Jupiter ACE (with THREE 16k RAM expansion modules. Aces were in like new condition, TRSs needed some repair (I ultimately made one working by combining good parts from both).
Yes, it was a Craigslist jackpot.
Tynemouth Software has designed a Jupiter Ace clone kit (they also do ZX80 and ZX81 clones) called the Minstrel. http://blog.tynemouthsoftware.co.uk/2020/05/minstrel-goes-forth.html
Cool! They do a lot of 8-bit clones don’t they?
I got one of these at an auction in the mid 80s for £30. It appealed to me after my first calculator used RPN.
I was suprised to read so few were made and thus they command silly prices today. Must put a note on it when I am next up in the attic for whoever has to clear it out some day.
I believe that a problem with the general acceptance of Forth by the general populace was a lack of entry level documentation. Most starting BASIC books of which I am aware have something like:
10 PRINT “WHAT’S YOUR NAME?”
20 INPUT N$
30 PRINT “HELLO, “; N$; “. HOW ARE YOU?”
Forth starts with discussing RPN and SWAP, DROP, ROT and other stack operations! It’s like expecting a student driver to be able to rebuild a car’s engine before they know how to pull out of the driveway!
Jes’ mah 2¢,
–Rich
BASIC (“Beginners’ All-purpose Symbolic Instruction Code”) is explicitly for beginners. I suppose I could concoct a snarky acronym for Forth (“Fussy Obscurant Reverse Tantrum HodgePodge” would be good), but the real fault lies in the reality that there wasn’t the massive implementation of it in beginning computer science curricula, and thus a relatively small base of users with any exposure whatsoever – few of whom would be cutting their novice teeth on something like the Jupiter Ace.
It’s pretty hard in most Forth’s because it’s not that good at interactive input. In my Forth computer (see earlier comments), it’s possible to do:
create n$ 128 allot
: hello
cls .” What’s your name?”
cr n$ 127 20 4 boxed
cls .” Hello, ” n$ “. .” How are you?”
;
hello
It’s not too far from the BASIC version. FIGnition Forth has cls (so does a Jupiter ACE), and it also has a text field editing function called boxed (BoxEd) which expects the string buffer, the length, then the width and height for the edit region; and sets up an editable text field at the current cursor location (which will be the line below: “What’s your name?” owing to the cr.
FIGnition forth also uses ‘C’ style strings rather than classic ‘pascal’ type (lengthByte:textArray) type strings. The function “. (the opposite way to .” for literal strings) outputs the string whose address is on the top of the stack.
FIGnition Forth can slice, copy, compare and scan strings using “cut, “from, “!, ” [which returns a strcmp style result), cIn”.
Jupiter Ace forth wouldn’t quite do it in the same way; instead it has the function LINE which creates a text editing area at the bottom of the screen and stores the result in the predefined text buffer: PAD. So, you’d probably have:
: hello
cls .” What’s your name?”
LINE
cls .” Hello, ” pad count type .” How are you?”
;
On the Jupiter Ace (or something like that).
I ran my entire first 1802 based system on FORTH. It scanned my hand wired keyboard, operated my memory mapped character based display, and performed all my cassette tape and later floppy access.
When I moved to the 6809 RS CoCo, I found a printed listing for a 6800 FORTH system with a target meta-compiler. I hand entered the source into a Motorola development system we had at work, modified it to take advantage of the upgraded processor (the 6800 code would have run directly on the 6809) and put it on an EPROM to bring home to my beloved Color Computer. On that system I was able to use the CoCo built in code as drivers to run the floppy and wrote a SCSI driver for a hard disk.
I am still looking for that code listing again because it had the ability to compile headless FORTH code for target systems as standalone code.
But alas, the PC started getting cheaper and cheaper to the point that the improved CoCo graphics card I was designing was beaten by a $15 IBM-PC color card.
The PC killed my hobby designing and wire wrapping computer hardware.
Aw you should do it again.
I badly want an 1802 system :)
I ran my entire first 1802 based system on FORTH. It scanned my hand wired keyboard, operated my memory mapped character based display, and performed all my cassette tape and later floppy access.
When I moved to the 6809 RS CoCo, I found a printed listing for a 6800 FORTH system with a target meta-compiler. I hand entered the source into a Motorola development system we had at work, modified it to take advantage of the upgraded processor (the 6800 code would have run directly on the 6809) and put it on an EPROM to bring home to my beloved Color Computer. On that system I was able to use the CoCo built in code as drivers to run the floppy and wrote a SCSI driver for a hard disk.
I am still looking for that code listing again because it had the ability to compile headless FORTH code for target systems as standalone code.
But alas, the PC started getting cheaper and cheaper to the point that the improved CoCo graphics card I was designing was beaten by a $15 IBM-PC color card.
The PC killed my hobby designing and wire wrapping computer hardware.
(I accidently posted this to the older article from the link as well.)
Damn! I used to have a Jupiter Ace when I was a kid. It got thrown out years ago. I wish I’d known how much they’d go for now!!