Last changed: Mon 30 Jan 1995 : manual ready.
Last changed: Sun 28 May 1995 : Addresses, hardware example code.
Last changed: Wed 12 July 1995 : DPMI, 1.06
Last changed: Sun 17 Sept 1995 : minor updates
Last changed: Mon 13 Nov 1995 : phone number changed, Linux & MMURTL
Last changed: Sat 13 Jan 1996 : Linux pre-announcement, user suggestions.
Last changed: Sat 2 March 1996 : Linux latest changes.
Last changed: Sun 10 March 1996 : Polishing for the homepage.
Last changed: Tue 30 April 1996 : changed to HTML.
Last changed: Tue 10 December 1996 : update for Linux 2.0 and Windows NT.
Last changed: Wed 23 April 1997 : update for Windows NT 4.0, iForth 1.07. Removed MMURTL.
Last changed: Fri 9 May 1997 : removed spelling errors, improved clarity.
Last changed: Thu 17 July 1997 : Changed pricing strategy to fight back soaring sales :-)
Last changed: Mon 4 Aug 1997 : Fixed exceptions, fixed Tcl/Tk for Windows NT
Last changed: Mon 7 Aug 1997 : Tcl/Tk screenshot added
Last changed: Sun 10 Jan 1999 : OpenGL screenshots added
Last changed: Mon 25 Jan 1999 : Two more OpenGL screenshots
Last changed: Mon 30 May 1999 : Exchanged one OpenGL screenshot
Last changed: Mon 2 Aug 1999 : New low prices
Last changed: Tuesday, May 15, 2001 8:28 PM: Windows 2000 reference adjusted
Last changed: Saturday, September 22, 2001 9:58 AM: details for release 1.12
Last changed: Wednesday, December 05, 2001 1:21 PM: Added Kagi on-line order scheme
Last changed: Sunday, June 02, 2002 4:53 PM, iForth vsn 2.0
Last changed: Tuesday, September 18, 2007, 19:46 PM, newest iForth only runs on XP and Linux
Last changed: Friday, January 25, 2008, 19:12 PM, new pricing in Euros, new address
Last changed: Saturday, May 17, 2008, 10:19 AM, update for iForth 3.0, the final 32-bit release
Last changed: Wednesday, January 12, 2011, 22:41, Added link to evaluation version of iForth 4.0.6
Last changed: Thursday, July 31, 2014, 23:47, Added announcement of iForth 5.0
Last changed: Sunday, December 07, 2014, 10:34; Corrected location in announcement of iForth 5.0
Last changed: Thursday, February 09, 2017, 19:33, Marcel Hendrix; PayPal button as KAGI went belly-up
Last changed: Sunday, November 19, 2017, 14:06; Marcel Hendrix; Release iForth 6.0
Buy iForth with PayPal
Is iForth actively supported?
Yes, it is, but these pages are updated quite infrequently (Last changed: Sunday, November 19, 2017, 14:06; Marcel Hendrix; Release iForth 6.0).
Release of iForth vsn 6.0
iForth6 (64-bit only) now compiles itself (thank you Hanno!). The release has been extensively tested and bugs of iForth 5.0, notably in the
dynamic linking department, have been fixed. As a result iForth6 runs on Windows (7, 8 and 10), modern Linux, OSX, and some Virtual Machines.
The iserver sources are included. In addition, fJack 3.01 is available for 64bit ARM.
Registered users can download the archive (~300MB) from http://www.iforth.org/release. The passwords haven't changed.
iForth6 compiles itself (metacompiler ported to 64bit)
Fixed major problems of FORGET and dynlibs.frt
Currently no open bugs
Corrected numerous minor flaws in the examples
Forth frame buffer -- on Windows about 10x faster than standard library calls
Device Control Blocks unify and secure the console, disk, null, string, memory, and MIDI I/O streams
Fixed the pipe implementation for Windows 10
Contains full 64-bit assembler and disassembler with SSE/SSE2 capability (a few minor bug fixes).
The thread system has again been massively improved and is now POSIX compliant. Threads give an almost n times speedup with n-core CPUs
in case of heavy FP computations or graphics codes. Graphics, GUI and mouse run in separate threads. On Windows the integrated editor
is back --it did not work on iForth5-- and is also running in a separate thread. Each thread has its own console and graphics context.
The graphics, mouse and keyboard, and all other I/O, are thread-safe.
PAUSE has been removed in vsn 6, but BLOCK is still multi-threaded.
The graphics system is 100% compatible between the three OSs (Windows/Linux/OSX). The framebuffer-based multi-threaded graphics run an
acceptable GUI written in 100% Forth (Demo applications are fotoapp, fotobase and fJack Audio/MIDI). On Linux the xmini Forth graphics
subsystem is available.
A MIDI and WAV playing system -- vari-speed, stereo panning, MIDI-triggered audio samples integrated in the MANX music composing language.
A single MIDI/MANX source tree for all three OSs. MIDI/Audio uses fJack on all OSs, where Linux can additionally use ALSA, and on Windows
native MMI calls are possible.
Threaded timer pool.
Improved high-precision timer (TSC) and CPU identification support.
Gdb breakpoints on Linux.
The real-time performance is sufficient for real-time sound manipulation in high-level Forth (fJack). Software instruments (Karplus-Strong,
simple organ, frequency shifter, sound-processing tools) are coded in high-level Forth.
Pre-coded interfaces for many libraries: BLAS, LApack, FFTW, FreeImage, SDL, infinite precision floating-point (MPFR and MPC), Gnuplot,
syssim (SPICE), FFL 8.0.0. The dynamic library linker supports inherited typedefs. It is a superset of the SwiftForth interface and compatible
with VFX. Callbacks are supported. An extensive chaining mechanism enables safe turnkey applications and robust FORGETting.
A plotter that uses TeX for type-setting its text labels.
Operator Precedence Grammar (an extension of Wil Baden's ideas) that transparently supports integers, single-, double- and extended-precision
IEEE floats, complex double precision, infinite precision FP (real and complex), and matrices and arrays of all these types.
256 color support for the iForth console, both in text and graphics mode. Supported are BOLD, BRIGHT, UNDERLINE and
ITALICS, and any fixed-size font in graphics mode.
A high-level mouse driver in a separate thread.
Improved LOCATE tool that makes the HELP systems almost unnecessary.
Windows, Linux and OSX versions use the Intel MKL BLAS, LApack,and FFTW3 libraries. The matrix multiply benchmark peaks around 120 GFlops on Linux.
Support for MATLAB/Simulink and SciLab/XCOS, LTspice (as a co-routine) and NGSPICE (iForth runs as a callback in XSPICE, and you can use a shared
ngspice library shell).
A Matlab compatibe PLACE routine (robpole) in Forth.
The 6.0 release concentrated on bug fixes, highspeed graphics, improved threading and unified I/O. Coming releases will again focus on speed and
high level approaches to optimization.
iForth vsn 5.0
This is a 64bit-only release for Windows/Linux and OSX.
We have made the switch to 64bit -- there is no official 32bit iForth 5.0.
The open bug and bug/month counters for the kernel/optimizer are now lower than they were for 32bit iForth. A large number of flaws have been corrected, especially for the Windows version.
Knuth-type co-routines supported through PAUSE.
Both Windows and Linux now use the ACML BLAS and LApack libraries.
The 5.0 release concentrates on correct implementation, stability and feature completeness.
The last release of iForth32/64, vsn. 4.0.6, is ready. Shipping started January 2011.
There's a free evaluation version.
iForth64 for Windows, Linux and OSX (November 2009)
The final release of iForth32 (32-bits iForth), and the first release of iForth64 (64-bit) have been
combined in version 4.0. This release is available for Windows (XP32, XP64 and Windows 7), Linux x86_32
and x86_64, and Mac OSX (Intel hardware only, 32/64 bit).
Starting from November, delivery will be through a secured web-site, typically a few hours after
There is now also a free evaluation version available for download (See above for link).
iForth32 for Windows, Linux and OSX
The final release of iForth32 (32-bits iForth) had version number 3.0.
Because of the truly awesome contributions of two iForth users, very
significant improvements were implemented for the final 32-bit release
(all of them available for iForth64 also) ...
Hanno Schwalm has worked on the iForth meta source code (thought to
be humanly unreadable!) and succeeded to free up a CPU register,
without any degradation of execution speed. This free register is
used to cache the address of the iForth USER area.
The result is that iForth has now OS-level threads and callbacks
for each supported platform. There is no limit on what threads and
callbacks are allowed to do: floating-point arithmetic, execution
of complete SPICE jobs, multiple invocations of external programs,
even compilation of thread-local Forth code -- it will all work.
Threads and callbacks have private stacks (data, return,
floating-point, system, and locals), plus a private USER area and
dictionary. Semaphored I/O is supported for threads, and Forth-level
interactive debugging of parallel code (.S ABORT etc.) is possible.
The iForth parallel constructs (inherited from tForth) have been
extensively tested in a real-time application (Linux driver for the
AOR 7030 shortwave receiver) that uses the FPU extensively, talks
to the PC audio system and radio hardware, and supports a GUI written
in Forth. The AOR 7030 code is included as a user contribution (it
supports a "dummy" radio as fallback).
Hanno Schwalm rationalized the terminal control sequences used to
set attributes (e.g. INVERSE BOLD ITALICS) and colors (red blue etc.)
in both text and graphic mode.
Hanno also wrote a truly awesome iForth graphics driver for X-windows
that works under both Linux and Mac OSX. Apart from very fast graphics,
this driver supports multi-font text output and mouse control. The driver
is thread-safe and it is possible (although not necessarily useful ;-)
to run any number of iForth graphics programs in parallel.
iForth graphics run unmodified on all platforms (Windows, X, OSX)
Charles Turner has ported the Linux server "C" codes to Mac OSX and
in the process genericized them.
Yes, iForth32 now works not only on Windows and Linux, but also
on Intel Macs (under both Debian Linux and OSX)!
OpenGL driver bugs were removed. OpenGL code now works bugfree on Windows,
Linux, and OSX.
A blocking sound driver (OSS/ALSA) for Linux is available, as is an
experimental non-blocking sound/MIDI driver. The MANX program runs
unchanged on both Windows and Linux. Unfortunately, sound does not
work yet for OSX. However, for all platforms a uniform Jack interface
is in the design stage.
Extensive floating-point library support (GotoBLAS,
Atlas) is integrated on all platforms. Typical processing speed is around
8 GFLOPS (double precision) for matrix multiplication (1.6 GHz Core Duo).
All code follows the extended FSL conventions and Forth native memory layout.
Pre-compiled Linux and OSX binaries are available to save some hassle for
At this moment (May 2008) installation programs are being prepared for Windows,
Linux and Mac OSX. However, be warned that iForth is definitely not for beginners!
Shipping will start end of May. As always, recent users will receive free updates.
iForth32 now comes with 24,552 example and documentation files. Server
source code for Linux and OSX is included. The examples work on all platforms,
save for some Windows GUI demos, and with a few omissions on OSX because
of the still lacking sound driver.
Minor fixes: input of lower-case HEX is now possible and S\" and
PARSE-NAME have been added to the kernel. X:deferred, X:defined, X:ekeys,
X:extension-query, X:number-prefix, X:parse-name are also available
(but notX:required, X:structures, and X:throw-iors). iForth does have
NEEDS and structure packages, of course.
Added EKEY>FKEY and all key constants (ALT SHIFT and CONTROL masks
only for Windows).
iForth tries to reasonably track the Forth20x0 standard.
Path name support has been improved. It is now possible to trace the names
of files given only by their handle. iForth remembers the state of the command
line buffer and the current path in the user's home directory.
SWISSEPH (sweph, compute a celestial body or point position) support
A compiler for Tiny-C (compiles to a virtual machine)
Included the online version of Starting Forth, the original (TM :-).
As from today, main development will concentrate on iForth's 64-bit branch.
Support policy is unchanged. (It includes free meals for visitors :-)
The iForth development team
(Marcel Hendrix, Hanno Schwalm and Charles Turner)
iForth for Windows XP
The XP version has a user interface that makes full use of the WIN32 libraries. iForth has
three windows: the familiar console window (in a separate thread), the RTF-enhanced editor
(calm down, you don't have to use it) and the graphics terminal screen. The
graphics terminal does double duty as the application window. Look at the screenshot below
for a visual impression
(Screenshot created with iForth)
(Backdrop picture is the graphics window, full-size. On top of it you see the iForth console window, partly overlapped with the RTF editor. The editor has some
(Screenshot created with iForth)
(Backdrop picture is the graphics window, full-size. On top of it you see the iForth console window, partly overlapped with the RTF editor. The editor has some
iForth vsn 2.0 (June 2002)
The main new feature in this iForth release is a completely redesigned floating-point and integer optimizer.
All high-level stack operations, on all stacks, are completely optimized away. The instruction selection,
code generation and register assignment mechanism has improved. Also, the top of the FP stack is now cached
on the FPU stack, but this does not have any noticeable effect on the run-time speed. An interesting aside:
the compiler became much simpler and easier to retarget, and uses a minimum of direct machine code internally.
This means it should be trivial to experiment with reassigned stack pointers and variations on the number of
stackpointers kept in registers.
It was observed that on the 900 MHz Athlon and above VFX seems to disproportionally benefit from the
increased clockspeed. The new optimizer makes iForth again competitive with MPE's VFX on the faster chips.
For some integer benchmarks VFX can still be seen to be between 10% and 30% faster than iForth 2.0.
For floating-point there is no valid comparison possible with VFX (VFX doesn't optimize FP code). iForth
is (much) faster than VC++ 6.0 for the FLOPS benchmark. The remaining differences between iForth and
the competition have been identified as suboptimal stackpointer assignment and alignment problems
that will be fixed in the next release.
Systems tested with "MPEBench/benchm.frt"
iForth 1.12 run at 21:47:12, September 30, 2001
iForth 2.00 run at 16:39:57, May 19, 2002
Test time excluding overhead ms ms improvement
Eratosthenes sieve 1899 Primes 350 266 1.32
Fibonacci recursion ( 35 -> 9227465 ) 504 500 1.00
Hoare's quick sort (reverse order) 244 164 1.49
Generate random numbers (1024 kb array) 155 178 0.87
LZ77 Comp. (400 kb Random Data Mem>Mem) 774 288 2.69
Dhrystone (integer) 393 300 1.33
Total: 2420 1696 1.43
This is an AMD Athlon 900 MHz machine running Windows 2000.
The compilers are iForth 1.12.8351 versus MS VC++ 6.00. Both
have their settings customized for speed.
Because of the enormous amount of changes in the compiler all of iForth's examples were carefully
checked and double checked for problems. All bugs were fixed, and in most cases extra documentation
and help words were added. However, the installation procedures on Windows and Linux have not changed
much -- let alone improved.
The Linux iForth has been carefully reviewed on a SuSE 8.0 system. This means that you now can run iForth
on the Linux console and in X, or over a network with telnet or ssh. The X graphics driver is still
rudimentary, but it does work. There were changes in OpenGL since Linux 2.0 and I could not get this
to work for iForth 2.0. Postponed! Also, SVGALIB seems to have died, and the framebuffer people have
not filled in the gap completely. In the next iForth release the old SVGALIB functionality may have
been restored through use of libggi and libgii.
Release 2.0 does not yet fix the old problem with STATE. The next release will redefine the meaning
of the iForth xt, and there will be separate routines for interpretation and compilation (and ...)
iForth vsn 1.12 (August 2001)
The main new feature in this iForth release is substantially increased speed for both floating-point and integer
operations. The FP code generator has been rewritten with the AMD Athlon CPU in mind (this chip has an extra Load/Store
unit compared to Intel products). For some special FP benchmarks an Athlon will be almost 150% faster than a PIII.
Extensive tests show that for integer code Intel PIII and AMD Athlon chips get approximately the same speedup.
The x86 seems to be _extremely_ sensitive to aligned data. This was not a
problem in the past because the rest of ( FP ) iForth was not fast enough
to show it. With all the new optimizations it proves that extended FP is
about twice slower than double-precision (64-bit). Also because the 80-bit
format does not support optimization fully (you can't combine 80-bit fetch
and store with other instructions), I decided to make DP the standard
iForth FP format. Also tried a native single precision (as opposed to explicitly using SF@ etc.) iForth but it was only
marginally faster and there would be problems with NRC CLAPACK and GAUSSJ.
An x86 has severe stack-alignment problems . Here I found that unaligned stacks
slowed down the assembler BLAS by a factor of 2! (verified with the Linux executable). This is fixed for all OS's.
Another problem is accessing data that is in the same cache line as code. This has been fixed for all
standard Forth words (VARIABLE CONSTANT VALUE etc.), but user defined data (e.g. with DOES> ) can not
automatically be adjusted. When the programmer does not leave a sufficiently wide gap there will be a large
slowdown on some codes (factor of 4 was observed). For the Pentium a gap of 32 bytes (cacheline size) between
data and code is enough. For the Athlon this must be 64 bytes (worst case).
Unfortunately, optimal AMD alignment hurts older Pentia. For best results _calign_ and _align_ should be set up
by the user in the iForth.prf file.
iForth can now control and automate MATLAB 5.x.
Added the word PASCAL-CALLBACK so that iForth can now call Visual Basic. See the Neural
Net demo in ./examples/nn/nn51.frt for an example of use.
Improved the speed of ALLOCATE FREE and RESIZE . From now on, the
iForth memory manager will only be used in case there is no OS.
iForth now allows spaces in file names (using single or double quotes).
Installed a new and much faster READ-LINE library.
Again, I could not complete everything on my wishlist (some Linux X graphics and OpenGL code still isn't ready for
prime-time). I decided to release a version 1.12 because (1) I had promised too many people a (free) upgrade over too long
a period of time and (2) the current source tree performed decent with respect to current MPE
and Forth Inc. native-code products. The projected final version 2.0 will contain a nicely integrated symmetric
disassembler/assembler pair and a code generator with register coloring.
iForth for Windows XP (2006)
The new features in this iForth release are WIN32 multiprogramming using transputer-compatible threads,
and built-in support for spectacular OpenGL graphics. Look at the screenshots left and below for a visual impression.
To be honest, I did not complete everything on the wishlist for version 1.11. However, this release is stable, well-tested and has some
nice features, so I postponed a few under-the-hood rough edges to the next (final) release. (OpenGL object graphics)
What is iForth?
A full 32-bit Forth with a 4 GByte flat address space. It works with any machine having
a '386+'387 or better. iForth runs under MS-DOS as a protected mode program, using D.J.
Delorie's GO32 dos extender. A Linux 2.0 version is available since December 10, 1996, upgraded to Linux 2.2.12 on December 21, 1999.
The Windows NT 4.0 version became available as of April 23, 1997. A Windows 95 port will never
be released. A Windows 2000 version is available since November 2000.
iForth has been tried on many different PC's / CPU types without problems.
The DOS-iForth uses DPMI and VCPI and can run in a DOS-box under Windows 3.x,
Windows '95 or Windows NT (no graphics however). For all Windows related
programming the new Windows XP iForth is much better suited.
iForth uses subroutine-threading. The generated code is improved with a
combination of macro expansion, special-casing, and peephole optimizing. The programs
build with iForth are as fast as those generated with Borland Pascal 7.0 but become much faster
when special (i)Forth tricks are used. Out-of-the-box iForth programs are about 20%
slower than programs compiled with Tom Almy's FORTHCMP (FORTHCMP compiled programs are claimed
to be faster than C). Current benchmarks say iForth 1.12 programs are about 70% the speed
of "C" programs compiled with MSC 4.51, but with a single CODE word become twice faster
than "C" (PII-350 MHz machine, matrix-mult benchmark).
iForth is a multi-tasking Forth (uses threads on XP, pthreads on Linux).
iForth is an ANS Forth. Every word defined in the ANS Forth standard is available
in iForth. iForth also contains lots of words to interface to the PC hardware (directly
under MS-DOS, mostly through libraries in the iServer under Linux / XP). Operating system
commands and utility programs are only a single keypress away. There is a simple RTF built-in editor
for XP, but you are supposed to keep using the professional tools you have now.
iForth has full protected mode assemblers and disassemblers as loadable options.
iForth has lots of standard (but implementation dependent) utilities and can be used with
any DFW Forth (Dutch Forth Workshop). See the list below. Other DFW Forth's are tForth
(for parallel arrays of T800 transputers), dspForth (for TMS320C30), a Forth for the 8051
and a 16-bit 8088...80386 Forth (CHForth).
A large number of examples is available: see the listing below.
There are graphics examples, floating-point utilities (CHAOS, neural nets, circuit
simulators), language compilers and interpreters (AWK, Pascal, BASIC, Lisp, PL/1, Pilot),
code to play .WAV and .MID files, generate .WAV files from audio-CDs, access Net hardware,
output presentation quality graphics on the system printer, generate .WMF and .EMF files.
Latest additions: OpenGL toolbox, parallel extensions, a metacompiler (META) that will generate fast, platform-independent 32-bit
Forths. The example source code generates mxForth, an efficient Forth that is several times
faster than most other Forths.
Under Linux and XP there is support for (named) pipes, dynamic linking, Tcl/Tk, (X-)windows,
SVGA graphics and full digital sound. Under Linux MIDI-output is through a simple I/O-port
driver, not through OSS-Free (XP uses the system libraries). Under Linux and XP direct I/O
to virtual console screens is supported.
Comes with a 292 page (.pdf) manual on disk. The online help facilities use the ASCII residue of the
manual and an (iForth-generated) extensively cross-referenced HTML document.
Support is e-mail based.
A port of iForth to Linux 2.2.12 is available since December 21, 1999.
The Linux port was done using assembler. I/O functions are provided by a server program
written in C, the iServer (conceptually like tForth for the transputer). The full source code of this iServer is
supplied. The iServer is a setuid program that must be compiled by root. This server
adapts itself automatically to the X-window environment.
On May 9, 1997 the iServer came to the same revision level as the XP release (The Linux release
can't of course support DDE, system fonts and EMF/WMF files). After that, the Linux
iForth has not been updated until January 2001. Currently, an X-windows and MESA OpenGL graphics library are in the works (using pthreads).
(Screenshot created with Tcl/Tk driven from iForth)
The iForth port to Windows NT 4.0 is available since April 23, 1997. The NT port was
done using assembler and C. I/O functions are again provided by a server program written
in C, the iServer (see the Linux port above). The source code of this iServer is not
normally supplied (the tools needed to rebuild the iServer are five times more expensive
than iForth itself). In principle the Linux and Windows iServers are exactly alike, in
practice the Windows version has more functionality build in (printing, clipboard support, DDE ...).
Tcl/Tk 8.0 works spectacularly well together with iForth under Windows XP, as shown above.
A port to Windows 95/98/ME was attempted but in practice there were problems with the graphics
extensions and the lack of a real 32-bit shell.
iForth is not shareware or freeware and is not distributed under GPL, LGPL or whatever.
The rules are that once a developer pays for his or her copy of iForth he or she can do with it
whatever they want. This includes using the iForth interpreter inside distributed applications,
in fact, I strongly encourage this practice. The above licensing scheme holds for the Windows and
DOS iForth. With iForth for Linux the license scheme applies to the iForth binary (completely generated
by iForth tools) and also to the bare-bones iForth server. This server is written in 'C' and must be compiled
by the user from the supplied source code. I am told that use of gcc, gas etc. does not introduce
any GPL/LPGL restrictions. However, I will not take any responsibility for what dependencies are introduced
by linking a full-featured iServer. (Carefully note that I'm not saying that any such dependency
necessarily would be introduced, I simply don't know).
Now why is iForth not freeware?
It is not my intention to take away business from regular Forth vendors.
I really want to discourage people that play with Forth to build Yet Another Forth. Building
wonderful applications and libraries is a worthier goal. (If you are Dutch, mentally
insert the phrase "Als de vos de passie preekt.." at this spot.)
It means you will get support when you need it. It also means a certain level of quality is
guaranteed (this is not to say free software has no quality or no support!)
You can apply for a free copy of iForth if you are planning to use it for something beneficial
to the Forth community at large. But please be serious and don't waste my time. I've grown very
cynical in this respect.
Even at this moment the iForths for MS-DOS, Windows and Linux are exactly equal at the kernel level.
Almost everything you can do under MS-DOS you can do under Linux, only faster and better. The
Windows versions keep the middle-ground: they are "cleaner" than MS-DOS, but a bit slower for
graphics. Because the Windows and Linux versions use a server written in "C" and allow dynamic
linking, there is much more you can get accomplished than under MS-DOS.
That being said, I'm contemplating to drop support for MS-DOS. (In preparation to that
move I've reduced its price.) MS-DOS will go because I can't directly use that OS anymore
on my machines. I do plan to come back on Linux with a killer Forth when I grow tired of XP.
The MS-DOS iForth allows reading and writing to special memory locations to:
interface with MS-DOS
update the text screen
Under Linux and Windows XP,
the OS and hardware interface is handled in the iServer, so you just add the needed
functions to it and recompile (you'll need to learn C). At the moment IEEE instrument
interface bus support is available for Linux through a GPLed library.
Hardware that comes with precompiled DOS or Windows drivers and no source code is
out of the question.
The Windows C-server code is not distributed because the tool to compile it is several times
more expensive than iForth itself. However, very low-level extensions are possible by
simply using the dynamic link calls supplied by the C-server. Every system library can be
opened and its code experimented with straight from the iForth command line, interactively.
(Of course, iForth for Linux has these exact same possibilities).
Graphics are implemented through SVGALIB or WIN32 calls. This handles all hardware issues.
Under Linux and Windows many more graphic modes are supported, however the MS-DOS graphics are
a little faster. Because svgalib also supports accelerator cards, which GO32 can't do, the
future lies with Linux.
The Windows graphics are somewhat slower than the Linux graphics. However, XP allows truly
spectacular graphics printed output that can be output in .WMF and .EMF files and put on the
NEW How to order iForth for Windows, OSX and Linux
The set of three iForths for Windows, OSX and Linux costs 100 Euros.
Buy iForth with PayPal
Additional info on iForth for Windows XP
This version was officially released on April 23, 1997 (works for W2K too, official release will
be in 1.12). All examples and utilities were adjusted so that they run on all platforms. Still
not all of them have been tested (there's over 14 MBytes of examples).
iForth for XP comes in the form of a binary image file and the iServer executable. There is no
fancy install program (necessary :) Simply copy the files to a directory tree, setup an icon
for the iwserver executable, then add two environment variables. Done.
email : firstname.lastname@example.org
home : Marcel Hendrix
6024 CA Budel-Dorplein
phone : +31-495-541529