Jonesforth – A sometimes minimal Forth compiler and tutorial (2007)
6 points · Open discussionnornagon
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 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 3:56:07 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
57 sourcesFor those who haven’t seen it before, Jones Forth is a wonderful implementation written in literate programming style.
It’s well worth reading through, even if you don’t know any assembly.
[1] https://github.com/nornagon/jonesforth/blob/master/jonesfort...
In Easy Forth (2015)Even just reading through an existing implementation can be very enlightening. E.g. JonesForth (where like 90% of the assembly source is comments explaining everything in detail): https://github.com/nornagon/jonesforth/blob/master/jonesfort...
In The FORTH code for Chipwits is released in the game's 40th anniversaryJonesforth – A sometimes minimal FORTH compiler and tutorial for Linux / i386
4 points · Open discussionI think jonesforth is the most popular implementation teaching implementation: https://github.com/nornagon/jonesforth/blob/master/jonesfort...
Factor might be a counterexample if one considers it a Forth, the VM is in part implemented in C++: https://github.com/factor/factor
I think it's portability and ease of development rather than CPU architecture complexity that makes someone pick C/C++ over assembly when implementing a Forth system. Because the Forth won't need much of the assembly language or obscure CPU instructions, the complexity of the architecture won't really matter to whoever is implementing it.
In As you learn Forth, it learns from you (1981)Not any sources/overview as such, I just looked at the VM code.
So for Mako: https://github.com/JohnEarnest/Mako/blob/master/src/MakoVM.j...
Freeforth: https://github.com/dan4thewin/FreeForth2/blob/master/ff.asm
Jonesforth: https://github.com/nornagon/jonesforth/blob/master/jonesfort...
Stoneknife: https://github.com/kragen/stoneknifeforth/blob/master/tinybo...
Retro/Ilo: http://ilo.retroforth.org/ilo.txt
Sectorforth:https://github.com/cesarblum/sectorforth/blob/master/sectorf...
but see: https://github.com/cesarblum/sectorforth/issues/6
and: https://github.com/cesarblum/sectorforth/issues/8
In Konilo: A personal computing system in ForthCool. 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 legit a text that goes the an x86 Forth implementation. Actually, it's just an implementation with really extensive comments. That said, including whitespace and comments, it's just 2000 lines and the pedagogy is excellent. Highly recommended for anyone who would rather see behind the curtain before picking up a larger text.
- SmithForth: https://dacvs.neocities.org/SF/
So, Smith decided to hand-write a Forth directly in x86-64 opcodes (well, the corresponding ascii hex bytes). It's incredibly slim and enlightening how you can bootstrap a language in just a couple hundred bytes or so.
This project actually inspired me to really learn the x86-64 architecture, so I e
Read the rest
nded up hand-decompiling the SmithForth binary instead of going through his commented implementation. Hand-decompilation is an absolutely fascinating exercise. You learn all about ELF structure, opcode encodings, and actually start to see the gaps where microarchitectural details shine through. Highly recommended for any hacker that really wants to grok low level details.
- Mecrisp: https://mecrisp.sourceforge.net/
An amazingly fast Forth implementation for MSP430, ARM, RISC-V, MIPS, and some FPGAs. This gave me one really nice understanding of Forth as
A REPL into your hardware!
- ##forth on libera.chat
Really active and helpful members there. Definitely worth dropping by.
Is there any particular language you're looking for? I've found some languages hideous until I understood them and could appreciate their respective graces. Off the top of my head the I can think of a couple of projects you and others may be interested in.
The first is Jones Forth (https://github.com/nornagon/jonesforth), start with jonesforth.S and move into jonesforth.f. I really enjoyed following along with it and trying my hand at making my own stack based language.
The other is Xv6, a teaching operating system from MIT (https://pdos.csail.mit.edu/6.828/2021/xv6.html), not all the code or implementations are top notch but it shows you non-optimized versions (just because they're simple and more readable) of different concepts used in OS design.
If you're interested in the embedded world, there is a really neat project I've been follow
Read the rest
ing that feels a more structured and safe (as in fault-tolerant) while still staying pretty simple (both conceptually and in the code itself): Hubris and Humility (https://hubris.oxide.computer/).
Very low hardware requirements, so basic industrial control at the level where you'd otherwise use an Arduino or so but on scavenged hardware. Forth is ridiculously simple to get an implementation running.
https://github.com/nornagon/jonesforth/blob/master/jonesfort...
Is a nice starting point. It's obviously not as compact as say 'Brainfuck' but it is far more versatile.
In Dusk OS: 32-bit Forth OS. Useful during first stage of civilizational collapseIn case it's new to anyone, I recommend going through the jones forth "literate program" - even if you don't understand assembly. You can try porting it to a language you know, it gives a good understanding of how forth works
https://github.com/nornagon/jonesforth/blob/master/jonesfort...
In Forth: The programming language that writes itselfI believe that any programmer should at least know a little about Forth. It's like Lisp. Just knowing about them is extremely enlightening, even if you don't use them in your daily life.
Obligatory link:
https://github.com/nornagon/jonesforth/blob/master/jonesfort...
This well-written tutorial will have you implement a Forth in 500 lines of assembly and another 500 lines of Forth.
You will feel like a different person after having done this. People will like you more. Food will taste better. You'll never be alone again, always knowing that you can re-create a fully-functional programming language from assembly within half an hour, if you needed to. It is said that people who know Forth die happy.
In What the hell is Forth? (2019)To me, the Zen of Forth is JONESFORTH.
https://github.com/nornagon/jonesforth/blob/master/jonesfort...
In The Zen of ForthJones Forth[0] is a good literate programming implementation that explains the internals as he goes.
[0]https://github.com/nornagon/jonesforth/blob/master/jonesfort...
In Thinking Forth (1984)Two things, plus their combination:
1. Productivity system. I’m trying out different methods of todo lists. When I start a new method I think I’ve finally found the right one, but I end up not sticking with it and starting over with a new approach after a while. My current system is something I started yesterday after coalescing a few different ideas from the last week or so. I have a list of categories in a text file (on my phone) ordered by priority such that at any time I can start at the top of the list and think if there’s anything I should do in that category. If so, I work on that. The order is determined by what would be best to do in SUPPORT of things further down the list. That way you can stay on top of things without waiting until they are urgent, and it seems to align my actions with my overall goals better.
2. Hardware/softw
Read the rest
are. I’ve noticed that software at every layer of the stack is written and changed/updated based on the desires of the creator of that software, not you. This might sound crazy, but if you really want to have control of your software you should write it yourself. Ever since I ran across Forth (jonesforth in particular) and realized you could create your entire software environment (drivers, OS, editor/compiler/debugger, application) from scratch because lets you start with nothing and quickly move up the layers of abstraction focusing only on what us needed for your particular application. (See also: http://collapseos.org/forth.html and https://github.com/nornagon/jonesforth/blob/master/jonesfort... )
The combination of 1+2 would be building a device with a hardware keyboard, simple display, and a microcontroller where I could have a todo list. (I could potentially just use an old PC with a BIOS as well to start with.) I could have it let me have reminders that I could snooze for a desired amount of time for instance, or have recur at specific times until dismissed (daily checklists). If I didn’t want the screen to go into sleep mode, or the OS to force me to update, reboot, or do anything at all that I didn’t want it to (like have unwanted notifications or ads or algorithmically driven distractions or security holes from the network/Internet), it wouldn’t. It would have zero dependencies.
Showing the 15 most recent of 57 sources. Enable JavaScript to search and browse every indexed mention.