I think I would get a Forth up and running ASAP, and write the assembler, if one still is needed, in that Forth.
looking at https://github.com/nornagon/jonesforth/blob/master/jonesfort... for a simple example, that needs assembler labels and macros, but I think a few batch files can give you rough approximations of those (example of rough approximation: assume every function is 64 bytes long, and every jump needs a 2-byte offset. That makes address calculations a bit easier. Wasteful, but that can be fixed later, once you have a better assembler written in your Forth.
In BATAS: 8086 assembler written in MSDOS batchnornagon
jonesforth
Assembly2015–2026
nornagon / jonesforth
jonesforth
Mirror of JONESFORTH
45Distinct people
57Mentions
5Explicit recommenders
1.1KGitHub stars
What to know before exploring
What it is
Mirror of JONESFORTH
GitHub
Where it is used
- jonesforth_riscv32 (Hans Baier) — Hans Baier's jonesforth_riscv32 repo copies and bases its RISC-V port on the x86 jonesforth source from the nornagon mirror; the repository explicitly states it used that mirror as the x86 source and that the RISC-V code was rewritten from that material. Source
What people are saying
Cool. Here are some other resources that I've encountered along the way of learning Forth: - JonesForth: https://github.com/nornagon/jonesforth/blob/master/jonesfort... This is…
xelxebar used a recommendation phrase. 5 indexed comments match. This is a phrase match, not a verdict.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 8–Nov 15 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/15/2026, 9:01:12 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year57 dated mentions
Observed mentions: 2015-05-26 20:38:14 UTC to 2026-07-12 17:09:31 UTC.
* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 3 | 1 | 2 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 4 | 0 | 4 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 7 | 1 | 6 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 10 | 1 | 9 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 12 | 2 | 10 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 8 | 1 | 7 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 4 | 0 | 4 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 5 | 1 | 4 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 2 | 2 | 0 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
This is a mirror of Richard WM Jones's excellent literate x86 assembly
implementation of Forth, more on which here:
http://rwmj.wordpress.com/2010/08/07/jonesforth-git-repository/
Read the full README on GitHubWhat Hacker News says
4 sourcesIt would be my pleasure :)
I'll refer to jonesforth [1], but I think the lessons apply to the other Forth's I've seen.
The main core of a Forth is generally written in assembly to bridge the specifics of a processing unit and the canonical Forth words. For instance, most control flow words are defined in Forth, but a couple critical ones are implemented in assembly and "exported" up to the higher level words. [2]
The main task of the core is to bootstrap to a sufficiently powerful yet abstract dictionary of words that will allow a full Forth to flourish. But to get there, you'll have to make a lot of choices that will be constrained by your chip (Intel x86, x86_64, ARM, Z80, etc). The big one is type of interpreter (direct threaded, indirect threaded, etc).
In jonesforth, check out the docs and implementation of NEXT [3]. The choice was g
Read the rest
uided by a quirk of the Intel instruction set that allowed loading the memory pointed by esi into eax and incrementing esi all in one step; further, Intel x86 allows an indirect jump to the address stored in a register (eax). Not all instruction sets support this pattern, you'll have to experiment and investigate for various chips.
That choice is a critical one, but it's one of many. Where do you store the dictionary of words? How do you implement DOCOL? What registers will you preserve? Why? What instructions will you expose? Which ones will you hide? Will you allow new words to be created with machine code?
In C, much of this has been decided by others decades ago (existing operating system ABI choices, mainly). In Forth, you can try things out and only be restricted by the chips, which is what all of us are ultimately constrained by, even fancy-pants languages like Rust and Go :)
Once you get past the core into Forth, some of the computer details recede, but you usually have to be somewhat aware of how you are using the system, far more than modern programming languages. Forth is the ultimate deep-dive "language" [4], but that is as much a curse as a blessing.
Basically, use Forth for the understanding it provides, then go back to making good software in typical languages aided by the enlightenment you've attained :)
[1] https://github.com/nornagon/jonesforth/blob/master/jonesfort...
[2] https://github.com/nornagon/jonesforth/blob/master/jonesfort...
[3] https://github.com/nornagon/jonesforth/blob/master/jonesfort...
[4] I've actually stopped calling Forth a programming language; programming system captures the idea a little better, I find.
The real special sauce for Forth is that it's small and it's knowable. Anyone who wants to learn about how elegant a computer system can be should take a look at jonesforth[0], a Forth implemented in x86 assembly language. It really is possible for a programmer to easily understand everything a Forth does, which is wonderful when writing a bootloader or low-level OS.
In a lot of ways, it's a more-structured assembly language.
TCL could be cool for a low-level system too, as could be a Lisp (also: how can anyone hate Lisp with a passion‽‽‽), as of course could be Forth. Perl & Python are too big and not minimal enough.
0: https://github.com/nornagon/jonesforth/blob/master/jonesfort...
In The Oforth Programming LanguageIf you want to take the plunge, jhbadger's recommendations of starting FORTH and thinking FORTH are both great. Starting FORTH covers the language itself, whereas thinking FORTH deals more with the philosophy of FORTH and programming in general.
If you really want to get serious, writing your own FORTH, which is a kind of right of passage in the FORTH community, is a good way to learn. While somewhat controversial among FORTH purists (for reasons I don't entirely understand), I would recommend Richard Jones' jonesforth as reference for this: https://github.com/nornagon/jonesforth/blob/master/jonesfort...
In Historical recreation/restoration of original Forth on the IBM 1130