forth

36 Articles

Tiny Forth Could Be The Smallest

November 6, 2023 by 29 Comments

When you think of a programming language, you probably think of a hefty compiler or interpreter. Maybe its on a bunch of floppies, a CD, or even an EEPROM. But what about a language that fits in a single disk sector? A language like that would — in theory — be used to help bootstrap a computer system and that was the idea behind Sector Forth and, later, Sector Lisp. However, there’s a new game in town: milliForth, which claims to be the smallest ever at 422 380 bytes.

Why would you want such a thing? Well, first of all, why not? Even as a form of code golf, packing a functioning language into a tiny space seems interesting. However, you could also presumably use something like this to boot a small system or on a system with limited storage.

Continue reading “Tiny Forth Could Be The Smallest” →

Learn Forth On The Commodore VIC-20

November 3, 2023 by 14 Comments

Although BASIC was most commonly used on home computers like the Commodore VIC-20, it was possible to write programs in other languages, such as Forth. Conveniently, all it took to set up a Forth development system was inserting the cartridge into the VIC-20 and powering it on, with the VIC-FORTH cartridge by [Tom Zimmer] being a popular choice for the Commodore VIC-20. In a recent video, the [My Developer Thoughts] YouTube channel covers Forth development using this cartridge.

In addition to the video tutorial, the original VIC-FORTH Instruction Manual is also available, together with the 1541 disk image. In an upcoming video, the Commodore 64 version of the cartridge will also be covered, which is called 64Forth, and which is also readily available to tinker with. For those interested in learning more about [Tom Zimmer] and his Forth-related work, a 2010 interview could be interesting. This covers the other platforms which he developed an implementation for.

As for why Forth might be interesting to developers and users, this comes mostly down to the much lower overhead of Forth compared to BASIC, while avoiding the pitfalls of ASM and resource-intensive nature of developing in C, as the entire Forth development system (compiler, editor, etc.) comfortably fits in the limited memory of the average 8-bit home computer.

(Thanks to [Stephen Walters] for the tip)

Continue reading “Learn Forth On The Commodore VIC-20” →

A NOR Gate For An ALU?

April 5, 2023 by 18 Comments

If you know anything about he design of a CPU, you’ll probably be able to identify that a critical component of all CPUs is the Arithmetic Logic Unit, or ALU. This is a collection of gates that can do a selection of binary operations, and which depending on the capabilities of the computer, can be a complex component. It’s a surprise then to find that a working CPU can be made with just a single NOR gate — which is what is at the heart of [Dennis Kuschel]’s My4th single board discrete logic computer. It’s the latest in a series of machines from him using the NOR ALU technique, and it replaces hardware complexity with extra software to perform complex operations.

Aside from a refreshingly simple and understandable circuit, it has 32k of RAM and a 32k EPROM, of which about 9k is microcode and the rest program. It’s called My4th because it has a Forth interpreter on board, and it has I2C and digital I/O as well as a serial port for its console.

This will never be a fast computer, but the fact that it computes at all is ts charm. In 2023 there are very few machines about that can be understood in their entirety, so this one is rather special even if it’s not the first 1-bit ALU we’ve seen.

Thanks [Ken Boak] for the tip.

Forth Cracks RISC-V

January 8, 2023 by 48 Comments

Over the decades there have been many programming languages, some of which have flowered briefly, and others that have stuck around despite newer, better, and faster competition. Few languages embody this last group more than FORTH, over five decades old and still cropping up wherever a simple, elegant, fast, and compact stack-based programming language fits the bill. [Alexander Williams] has now taken it somewhere new, with a FORTH in RISC-V assembly which runs on the GD32 series of microcontrollers that are RISC-V lookalikes of the popular STM32 ARM parts.

We have to admit to last having used FORTH on an 8-bit home computer in the 1980s, aside from a moment’s idle play on discovering that the Open Firmware on Apple computers is a FORTH interpreter. Thus we’re intrigued by this implementation, but not from a position of FORTH expertise. We’d expect such an efficient language to be extremely quick though, so it’s definitely something to keep an eye on for when a suitable dev board comes our way. If it interests you, take a look at the GitHub repository.

HP-41C, The Forth Edition

October 21, 2022 by 45 Comments

If you have an HP-41 — arguably the best calculator ever made, you might not have noticed that there’s a version of Forth for it. The code was written a while back in assembly and will work on anything that actually emulates the device properly, such as a SwissMicros DM41X. [Calculator Clique] shows you how it works in a recent video that you can watch below.

The original code dates back to 1984, but some recent detective work by [Angel Margin] has the code running again. If you know about synthetic programming on the 41C and the oddities of its internal architecture, you can’t help but be impressed.

Of course, Forth is meant to be easy to port over, but if you read about some of the architectural challenges, you start to realize this could be one of the more difficult implementations you’ve ever seen. Don’t forget you have what is, by today’s standards, an extremely limited amount of resources.

That being said, calling the HP41C a calculator is almost a crime. It is really a tiny computer hiding inside a calculator case. Then again, the best calculators always are.

We wonder if the code would run on an emulated 41C? Were you part of the TI calculator gang? No problem.

Continue reading “HP-41C, The Forth Edition” →

Old Casio Calculator Learns New Tricks

April 6, 2022 by 12 Comments

[George Stagg] recently found himself stung by the burden of free time while in lockdown. Needing a project to keep him occupied, he decided to upgrade his 90s Casio CFX-9850G calculator to run custom machine code.

All [George] really wanted was for his vintage calculator to understand Reverse Polish Notation (RPN). The calculator in question can already run its own version of BASIC, however the bespoke Hitachi CPU struggles performance-wise with complex programs, and wouldn’t be a realistic way of using RPN on the calculator. An RPN interpreter written in assembly language would be much faster.

The first step in cracking this calculator wide open was a ROM dump, followed by writing a disassembler. Incredibly, the MAME framework already featured a ‘partial implementation’ of the calculator’s CPU, which was a much needed shot in the arm when it came time to write a full-featured emulator.

With the entire calculator emulated in software, the plan from here involved replacing one of the BASIC commands in ROM with new code that would jump to an address in RAM. With 32KB of RAM there ended up being plenty of room for experimentation, and uploading a program into RAM was simplified by using Casio’s original backup software to dump the RAM onto a PC. Here, the contents of RAM could be easily modified with custom code, then uploaded back into the calculator.

With RAM to burn, new routines were created to write custom characters to the screen, and a new font was created to squeeze more characters onto the display than normal. [George] ended up porting a Forth interpreter, which defaults to RPN style, to finally achieve his humble objective. He also managed to get a version of Conway’s Game Of Life running, check out the video after the break.

We can’t get enough of our calculator hacks here, so make sure to check out the CPU transplant on this vintage Soviet calculator.

Continue reading “Old Casio Calculator Learns New Tricks” →

DIY Forth On Arduino

July 8, 2021 by 31 Comments

On a recent rainy afternoon, [Thanassis Tsiodras] decided to build his own Forth for the Arduino to relieve the boredom. One week of intense hacking later, he called it done and released his project as MiniForth on GitHub. [Thanassis] says he was inspired by our series of Forth articles from a few years back, and his goal was to build a Forth interpreter / compiler from scratch, put it into a Blue Pill microcontroller. That accomplished, he naturally decides to squeeze it into an Arduino Uno with only 2K of RAM.

Even if you are ambivalent about the Forth language, [Thanissis]’s project has some great ideas to check out. For example, he’s a big proponent of Makefile automation for repetitive tasks, and the project’s Makefile targets implements almost every task needed for development, building and testing his code.

Some development and testing tasks are easier to perform on the host computer. To that end, [Thanassis] tests his programs locally using the simavr simulator. The code is also portable, and he can compile it locally on the host and debug it using GDB along with Valgrind and AddressSanitizer to check for memory issues. He chose to write the program in C++ using only zero-cost abstractions, but found that compiling with the ArduinoSTL was too slow and used too much memory. No problem, [Thanassis] writes his own minimalist STL and implements several memory-saving hacks. As a final test, the Makefile can also execute a test suite of Forth commands, including a FizzBuzz algorithm, to check the resulting implementation.

Here’s a short video of MiniForth in action, blinking an LED on an UNO, and the video below the break shows each of the various Makefile tasks in operation. If you want to learn more, check out Elliot Williams’s Forth series which inspired [Thanassis] and this 2017 article discussing several different Forth implementations. Have you ever built your own compiler? Let us know in the comments below.

Continue reading “DIY Forth On Arduino” →