ryanwold.net - Civic Tech, Bitcoin, and Open Government Innovation

Show

An entry

Get it down. Make it good. Share it.

Title

Text

via GPT o4-mini-high, August 6, 2025

> introduction to novel concepts and idioms in the Forth language.
> also consider how it may be used by developers in bitcoin

## Core Forth Concepts

* **Concatenative, stack-based**
  Forth programs are built by composing small “words” (functions) that consume and produce values on a data stack. There’s no named arguments—each word’s signature is documented in a *stack-effect comment*, e.g.:

```forth
  : + ( n₁ n₂ -- sum )  + ;
  ```
* **Threaded interpretation**
  Source text is tokenized into addresses of word definitions. Variations include *direct* (calls machine code), *indirect* (via pointers), and *subroutine* threading, trading space vs. speed.
* **The dictionary & vocabularies**
  Words live in a linked “dictionary.” You can create separate vocabularies (namespaces) to isolate extensions, e.g., a `BITCOIN` vocabulary for script helpers.

## Novel Forth Metaprogramming Idioms

1. **`CREATE … DOES>` for data-driven words**
   Define a new word plus a behavior attached to its “body” pointer. E.g., a simple key-value store entry:

```forth
   CREATE counter  0 ,  \ allocate a cell initialized to 0
   : counter++ ( -- n )  counter @ 1+ counter ! counter @ ;
   ```

2. **Compile-time execution with `IMMEDIATE`**
   Mark a word so it runs even during compilation. Useful for DSLs:

```forth
   : WHEN ( -- ) [compile] IF ; IMMEDIATE
   : ELSE ( -- ) [compile] ELSE ; IMMEDIATE
   : ENDIF ( -- ) [compile] THEN ; IMMEDIATE
   ```

3. **Factoring & small-word philosophy**
   Build complexity by composing tiny, single-purpose words. Instead of one big routine, factor into reusable primitives (e.g., `>R`, `R>`, `2SWAP`, `OVER`, etc.) and then layer control structures on top.

4. **Locals & stack-clean definitions**
   ANS Forth’s `LOCALS|` lets you name stack items without manual `>R R>` juggling:

```forth
   : compute ( a b c –– result )
     LOCALS| a b c |
     a b + c * ;
   ```

5. **Inline assembly & code overlays**
   In embedded Forths (e.g., eForth), you can embed raw machine code or patch words at runtime for maximal speed in hot paths.

## Common Stack-Manipulation Idioms

| Idiom          | Effect                                   |
| -------------- | ---------------------------------------- |
| `2DUP`         | Duplicate the top two items              |
| `>R … R>`      | Move data to/from the *return stack*     |
| `SWAP`         | Swap top two items                       |
| `ROT` / `-ROT` | Rotate top three items                   |
| `NIP` / `TUCK` | Drop or insert items deeper in the stack |
| `?DO … +LOOP`  | Conditional loops with dynamic steps     |

Use these to write concise, pipeline-style code:

```forth
: sum-squares ( n -- sum )
  0 SWAP 1 ?DO
    I DUP * +
  LOOP ;
```

## Forth-Style Control Structures

Because Forth’s basic vocabulary only includes `IF ... ELSE ... THEN` and loop words (`DO … LOOP`, `BEGIN … UNTIL`), developers often build richer constructs:

```forth
: for-each ( addr len xt -- )
  0 DO  I cells + @ EXECUTE  LOOP ;

: when ( flag -- ) IF ;
: unless ( flag -- ) 0= IF ;
: repeat ( -- ) BEGIN ;

: until ( -- ) WHILE REPEAT ;
```

Here, `xt` is an *execution token*—a reference to another word, enabling higher-order programming.

## Forth in Bitcoin Development

1. **Bitcoin Script as a Forth dialect**
   Bitcoin’s locking/unlocking language mirrors Forth: it’s a stack machine with opcodes (e.g., `OP_DUP`, `OP_HASH160`, `OP_EQUALVERIFY`, `OP_CHECKSIG`). Forth fluency helps when reading, writing, or simulating scripts.

2. **Solitaire and combinators**
   Nick Szabo’s **Solitaire** smart-contract pattern uses small stack combinators in a Forth-style to build complex scripts. Understanding how to factor script snippets into reusable “words” (or combinators) simplifies contract composition.

3. **Off-chain script simulation**
   Embedding a tiny Forth interpreter in your wallet backend lets you test and debug custom scripts before broadcasting. You can drop in definitions for opcodes, then load your spending policy as Forth code:

```forth
   : p2pkh-verify
     OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG ;
   ```

4. **Hardware wallets & embedded Forth**
   Low-resource devices (e.g., custom USB tokens) can embed a minimalist Forth core to interpret unlocking policies at signing time—compact, deterministic, and auditable.

5. **Building Forth-based DSLs for transaction builders**
   You might layer a Forth-like DSL atop your wallet API to script UTXO selection, fee calculations, and metadata—expressing workflows declaratively in stack-oriented words.

---

By mastering Forth’s **stack effects**, **threading models**, and **metaprogramming primitives**, Bitcoin developers gain powerful tools for both **on-chain script** design and **off-chain automation**, all within a terse, extensible language that maps naturally to Bitcoin’s own virtual machine.

Status

Series