Gforth ANSI Forth, Free and Fast
Have you tried Gforth yet? If you
have not, then you are in for a treat. I've been using the Forth
programming language for years, and Gforth delivers much more than
most versions of Forth I have tried.
For one, Gforth has a full complement of floating point operators.
The original versions of Forth did not have floating point, though they had a
very clever set of integer operators designed by Forth's creator Charles
Moore. With these operators, one could do a lot of fixed point
math, with the ability to keep track of decimal place.
But I found the clever fixed point operators insufficient for working on
extensive math problems without so much head-scratching that I was loosing too
much time, and saving time was one reason I went to Forth in the first place. I
went to the exhausting effort of creating my own version of Forth, written in
c, in order to have such floating point support. Now, Gforth makes it
Gforth is also designed to work well within a modern computer
system, having plenty of file i/o routines to work with
conventional files, as well as still retaining the old block
file handlers and virtual memory system that gave Forth
such power in the days of smaller resource computers.
Gforth also allows one to create Forth programs than can
handle command line arguments much like more conventional
languages, as well as handle Forth commands via the command
Gforth, as is common with other Forth derivations, includes a
built in assembler, letting the user get down and dirty should
hardware control or speed be critical elements of a program.
The included assembler depends upon the platform the Gforth is
running on. Gforth has already been ported to many architectures,
and it's pretty easy to port. This is because most of Gforth
is itself written in Gforth.
While Gforth has the primitive Forth vocabulary and a built
in assembler, don't assume that it's a primitive language.
Gforth also includes support for data structures, and even
objects. In fact, the Forth language has often been described as
a meta language, with which one creates their own languages
targeted to their specific solutions.
I'm using the Debian Linux
version of Gforth. To install it, I needed to only:
This installed the language and its extensions, the Gforth man page, and the
Gforth info file. To find details about the Gforth language, I can always type
info Gforth to get access to a very informative Gforth manual. You can
view an online version of the manual at Gforth
Forth - It's All About Words
Likely, you're familiar with a number of more conventional
computer languages, such as c, c++, BASIC, Fortran, and
maybe Java. With these languages, or whatever else you've
used, you may have just used any text editor to create your
program (a common circumstance in Unix and Linux), or used a
computer language GUI environment. With these languages, you
work within the structure of the respective language and the
limits of its compiler to create a code solution to your problem.
With conventional computer languages, the programming interface is
cognizant only of the specific computer language and its syntax. The
interface is never cognizant of the problem one is trying to solve.
The programmer codes within the interface, compiles the code, and then
optionally executes the code from within the code development interface.
While the code the programmer wrote is executing, the only thing with
knowledge of the problem under consideration is the programmer's code. If
it is discovered that some very useful piece of information should be
printed out, the programmer will usually have to edit the code to add the
new information collection and print routines, re-compile, and re-run.
Within conventional languages, the nature is usually that of functions. Even
intrinsic commands generally operate as functions, where the function
name is an action word, followed by arguments.
If your background is with more conventional languages , you may well
enter into the Gforth environment with the same expectation. But there are some
philosophic differences between Forth and most other languages that you should
understand before you get started. If not, you will likely be frustrated, and
become another voice added to the clamor that Forth is a worthless, primitive,
assembly-like language -- good only if limited computer resources prevent you
from using something more sophisticated.
As to programming environment, when you type in Gforth, you are presented
with a rather bleak looking, empty screen. Gforth has no built-in editor. You
must use an external editor, such as vi, vim, or emacs. If you happen to like
emacs, then you are in luck. Emacs has support for Gforth, making a nice
environment for the development of Gforth code.
When Gforth starts up, it connects you directly to the Gforth
interpreter/compiler utility. Within the Gforth system is a dictionary
or words that Gforth understands. You can type these words and Gforth will
respond by performing the action associated with the word. Try typing in
words and see all the words in the Gforth dictionary. Impressive,
When I say words, I'm implying more than you might suspect. It's better in
many ways to imagine Forth as a human-like language mapped onto a computer,
than to view it as a conventional action-word/parameters model used by most
other languages. With Forth, think more of verbs rather than action
words, and nouns, with adjectives and adverbs used to modify nouns and
In terms of human-speak, Forth is primarily different (than English at
least) in being a post-fix language, rather than pre-fix or in-fix.
For example, imagine that you want to turn and control the speed of some
device. The following commands are typical as to how one might express that
desire in human speak, Forth, and C.
Turn left, set speed to fast
left turn fast set-speed
As you can see in the example above, Forth uses language more similar
to human-speak than does a more conventional language, with the proviso
that each phrase is post-fix. Programming in Forth is accomplished by
creating more targeted words from the existing vocabulary of Forth
primitives, then creating even more expressive words from the extended
vocabulary. Finally, one expresses the solution to one's problem using the
words he/she has taught the Forth system. Then, one saves the new
vocabulary and solution expression to be used whenever desired.
As you create words in Forth, you can test the words interactively by
simply typing them and hitting the enter key. Forth will dutifully find the
words in the dictionary and perform them as instructed. Defining a word is
simple. Just enter a colon, the new word, the existing words that define the
meaning of the new word, and a semi-colon. Some simplistic examples are given
below (Note, expressions between parenthesis in Forth are comments):
( Note that comments begin with left-paren space)|
( Add two to number on stack)
: bump-by-two 2 + ;
( Clip value to be between -10 and 10)
: clip 10 min -10 max ;
( Bump number by 2 then clip)
: bump-and-clip bump-by-two clip ;
In the simplistic example above, note that the first two words are
defined by words Forth already knows. The third definition is composed
of the newly defined words. These new user-defined words are now just as
much a part of the Forth system as the intrinsic words the programmer
started with. Conceptually, that suggests that unlike the conventional
programming technique described above, the Forth programming procedure
increases the vocabulary and knowledge base of the language itself.
One doesn't use a Forth interface to construct a program that holds
a problem solution. Rather one increases the vocabulary of the Forth
system itself to have the solution to a problem.
Get A Witty Astronomy, Physics, Math, Or Linux T-Shirt, Mug, or Poster At Keen Designs
Where to get more information
A great tutorial for programming is Leo Brodie's book Starting Forth,
shown in html form here.
While the book is specific to Forth 79 rather than ANSI Gforth, it presents a
philosophy of Forth that is very instructive, and many of the examples in it
will work with Gforth. See the Gforth info file for specifics and extensions
that are contained in Gforth.
I learned Forth from Brodie's book, and have a couple of copies in
my library. One I bought new when it was in print, and the other from a
used book store. You can find his wonderful books on Forth at
To write an executable program in Gforth, create the vocabulary
definitions needed to perform the desired function and save them into
a text file. Note that you must always define each new word with definitions
that already exist, either in the initial dictionary or referencing words
you've previously created.
Next, put the following line as the first line of your program:
#! /usr/bin/gforth path-to-program-file|
Notice the space between the #! and the reference to Gforth. With
the conventional batch file construct, such as with a perl script, the
space isn't needed. But with Gforth, the #! is a Forth word being
the equivalent of the Forth comment indicator, telling Forth to ignore the
first line. The Linux system, then, handles the line as with all batch
file references, calling the referenced process with the following arguments.
In the case of Gforth, usually the first argument passed to Gforth is the
name of the text file containing a vocabulary extension that also includes the
expression of the problem solution. Just set the file to be executable, and
you have a Gforth program. The following is an example of a Hello
world program written as a Gforth batch script:
." Hello World" cr
In the example, the first line, similar to batch commands in Linux
except for the space after the !# symbols, tells the system to
pass the file to gforth. The second line uses Gforth's print command
to print Hello World and a carriage return, and the last line
tells the Gforth interpreter to exit. In this example, no additional
arguments, which would also occur on the first line, were needed.
How is Gforth different from other Forths?
Having worked with Fig-Forth, Forth 79, and Forth 83, I did find
some significant differences between these and Gforth. Mostly, what I
found is that Gforth had more things already included, like data structure
support and object oriented programming support.
The dictionary design of Gforth is a bit more complex, made so in
order to allow it to execute faster. In fact, Gforth runs very fast
compared to interpretive languages. You may find, however, that some
tricks you were able to perform in other Forths because of a simpler
dictionary design may have to be re-designed to work in Gforth.
As I already mentioned, Gforth
includes floating point math support, as well as more conventional
file support. Within the floating point support is a full complement of
transcendental math functions.
Gforth is a full 32 bit version of Forth, and thus allows one to
create a very large dictionary, or create large array areas for data
handling. One can pass in a memory size argument to has as much memory
as your computer will allow as dictionary space.
The only down side I've found is that because of its more complex design
and larger intrinsic vocabulary, Gforth is larger that the older, 16 bit
versions of Forth I've used previously. Then again, computers generally have
much more resource than in the days I was running Forth on 16 bit computers.
Gforth, like other versions of Forth, is highly extensible. I've
created a vocabulary of words that I find useful, including words that
load additional libraries of words for specific problems. Other words
match up Gforth to other Forths I've used, making it easier to port my
many programs over to Gforth.
If you have any interest in learning about threaded languages, or
especially if you do any hardware control, I highly recommend that you
give Gforth a serious look.