I really like to play around with FORTH. It’s a “weird” programming language compared to all the other ones I’ve learned over time. There are already many articles out there about why you should give it a try, the best probably being this one at Hackaday.

One little program that is often demonstrate on old computers is a BASIC program to compute the Mandelbrot Set in the console. I thought I’d try my hand in “converting” the program to FORTH.

Here’s my version, taken from a gist I wrote earlier this year.

```
\ from proposal http://www.forth200x.org/fvalue.html
variable %var
: to 1 %var ! ;
: fvalue create f, does> %var @ if f! else f@ then 0 %var ! ;
0e0 fvalue i3
0e0 fvalue r3
59 value x1
21 value y1
-1e0 fvalue i1
1e0 fvalue i2
-2e0 fvalue r1
1e0 fvalue r2
r2 r1 f- x1 s>f f/ fvalue s1 \ L30
i2 i1 f- y1 s>f f/ fvalue s2 \ L31
0e0 fvalue a
0e0 fvalue b
: single_iter { F: z1 F: z2 } ( F: z1 F: z2 -- F: z1' F: z2' F: mag )
z1 fdup f* to a \ L90
z2 fdup f* to b \ L91
a b f- r3 f+ \ z1 \ L111
2e0 z1 z2 f* f* i3 f+ \ z2 L110
a b f+ \ mag \ line 100
;
: print_char ( F: x F: y -- )
30 \ push the max in case we don't exit early
30 0 do \ L80
single_iter
4e0 f> if drop i leave then
loop \ L120
fdrop fdrop \ clean z1 and z2
62 swap - emit \ L130
;
: calc_i3 { y }
i1 s2 y s>f f* f+ to i3 \ L50
;
: calc_r3 { x }
r1 s1 x s>f f* f+ to r3 \ L70
;
: mandel
cr \ always start on a fresh clean line
y1 0 do \ L40
i calc_i3
x1 0 do \ L60
i calc_r3
r3 i3 print_char
loop \ L140
cr \ L150
loop \ L160
;
mandel
```

That prints out something like the screenshot at the top of this post.

The “L##” comments roughly refer to the lines in the BASIC version, if you’d like to compare the two. I tried to keep the memory usage and general complexity as equal as possible – that’s why there are so many `value`

and `fvalue`

variables. I’ve seen some examples that use the stack more but are harder to read and have to recompute a lot of things that the BASIC version doesn’t.

Here’s the original BASIC version:

```
10 x1=59
11 y1=21
20 i1=-1.0
21 i2=1.0
22 r1=-2.0
23 r2=1.0
30 s1=(r2-r1)/x1
31 s2=(i2-i1)/y1
40 for y=0 to y1
50 i3=i1+s2*y
60 for x=0 to x1
70 r3=r1+s1*x
71 z1=r3
72 z2=i3
80 for n=0 to 29
90 a=z1*z1
91 b=z2*z2
100 if a+b>4.0 goto 130
110 z2=2*z1*z2+i3
111 z1=a-b+r3
120 next n
130 print chr$(62-n);
140 next x
150 print
160 next y
170 end
```

I’m consistently intrigued by FORTH, so I’ll probably be sharing more programs and thoughts. I wrote a short explanation of the “polyfill” in the first four lines of the FORTH version is actually a great dive into the language’s extensibility.