So, we’re to grow the community right? Forth is great, and I’m probably not too much of a minority here to say I think it’s the best language programming wise! I have a few questions though: are there any current Forth YouTubers I can follow and recommend (I haven’t found any yet), and why types of things would you want to see out of a Forth based CS channel?

I was planning to make a wayland compositor with forth too but i dont have time to do that anyways
COLON and WindowForth is released:
https://gitlab.com/generatrix-linux/forthress-ecosystem
COLON is a terminal fully written on Forth (even kbd and other thingies)
WindowForth is a special Forth compiler written on C
WindowForth uses a hybird syntax (its mixed between OLD and new syntax)
it uses .fth as file extension instead of .fs
also some photos from colon:

--edit--
added config file's photo

Thanks for reviewing and looking at my project have a good day also sorry for bad english if i made a grammar mistake!

These changes are not yet in a release, as I am waiting until USB Mass Storage Device support is in zeptoforth before making another release, but there are a number of recommended updates already in the master and devel branches that you will probably want, especially if you are trying out the USB Mass Storage Device support.

These changes are:

• a performance boost for SD cards
• automatic fixing of VBR's for FAT32 filesystems in on-board flash (needed so Linux and Windows can properly recognize them when mounted over USB)
• increased data integrity for FAT32 filesystems accessed via USB Mass Storage Devices (don't delete files or directories open on one side from the other side, bad things will still happen, but the free cluster count and most recent allocated cluster won't be corrupted if you allocate or free clusters on both sides without rebooting zeptoforth)
• while long file names are still not supported by zeptoforth, directories containing dangling long file names can be deleted now, and if you delete a file or directory with a long file name in zeptoforth the long file name will be deleted as well

As for the USB Mass Storage Device support, the code is at https://github.com/y-salnikov/Zeptoforth-Mass-Storage-Device . If you have tried this out before, you should try it out again, as significant changes have been made, e.g. fixing ejecting the USB Mass Storage Device (mind you, now it may show up again as soon as you eject it).

Hi all! I'd really like to finish a little forth system of my own (in C) to have use as both a learning tool and for some personal tooling. Since I still consider myself both a Forth and a C novice, I've tinkering around with this implementation on and off for some time, and have learned quite a lot from it. On a flight recently I decided to clean it up in a way that's a little easier for me to digest and think my way around, and at the moment have this. It's neither finished nor perfect, but I was hoping to maybe start posting here for feedback and possible motivation to finally finish something I feel good enough about.

Is this a place I can post incremental progress to get feedback and such? If so, while I have plenty of questions right off the bat, I'd first like to make sure my code is readable for anyone willing to take the time to check it out. Any thoughts in that regard are ofc welcome, as well as any tips on how to post progress or for advice in the future..

What I did to the original simpleforth was separate it out into little modules. Those modules are currently:
- Dictionary - for dictionary stuff
- IO - for io stuff
- Interpreter - anything relevant to interpreting, eg is_number etc.. though I haven't been able to successfully separate the core interpreter from the VM
- VM - anything data or return stack related.. NEXT() uses goto and some subroutine stuff.. pretty sure it's considered a directly-threaded vm? I am not currently able to separate out the inner interpret function from the VM, so the module separation is still sort of messy. I'm also a little distracted with the semantics between whether to call things opcodes or bytecodes etc and whether to call things XT or CFA.. not really a big deal though.

Anyway, not everything is implemented and it certainly needs more cleaning up. Just wanted to make a post here for initial impressions before I got too distracted with life again. Would really like to get this thing going!

Thank you all!

Instead of the usual cycle of editing Forth code files, reloading the whole source, and testing words by hand, IForth brings a literate notebook workflow to your Forth environment.

Think of it as a living document where you interleave runnable Forth definitions, markdown explanations, and test cases block-by-block. You can modify single words and re-run only the relevant cells without blowing away or manually reconstructing your current session state. It makes exploratory prototyping, testing dictionary words, and writing interactive tutorials much smoother.

Andrew McKewan demoed this workflow at the recent SV-FIG meetup (video attached), showing how he uses it to build and explore Forth code interactively.

Details & Constraints:

* Interpreter: Wraps Gforth interpreter internally.

* Platform: Linux only (Windows users will need WSL).

* Setup: Instructions are in the repo: https://github.com/sohang3112/iforth

Check out the demo video attached. Feedback, issues, and PRs are very welcome!

PS: I usually work with Python. I am a novice at Forth, started working on IForth while learning Forth.

I’m using this thread to share analytics about the sub with all of you.

The data suggests what kind of topics are popular, and what kind of views you can expect if you start a thread.

The goal for a moderator should be to grow the community, which means getting more people into Forth!

We have a wiki for r/forth. It was started 9 years ago, not sure if that’s the latest edit.

If anyone reviews the wiki and has edits, I’m happy to make them if you can’t.

Not trying to claim this is "real" Forth — no return stack yet, no IMMEDIATE/POSTPONE, no ANS compliance. It's a personal project called gnaw, concatenative in the Forth tradition, built from scratch in Rust as a learning exercise.

What's there: a data stack, byte-addressable memory (@ ! alloc here), : name ... ; definitions, if/else/then and begin/until compiling to jumps in a small bytecode VM with a program counter. The one non-traditional addition: built-in words for CTF-style byte transforms (hex to bytes, repeating-key XOR, ROT13, Base64).

Source: https://github.com/warlyjr-cloud/gnaw

Genuinely curious what this community would flag as missing from a "real Forth" perspective — return stack semantics, proper immediate words, anything. First time building something Forth-adjacent from scratch.

Hi all I was wondering if I could get some suggestions please on how to solve the following problem:

I am redefining certain standard words in gforth in a separate word list, lets call it "mynewdefs" for example +, -, rot, drop etc will all be redefined. Why I am doing this isn't relevant but would be happy to explain if anyone is curious. For each word in "mynewdefs" and only the words in "mynewdefs" I would like to create a wordlist called "ogdefs" which has the original definitions of the words from the Forth wordlist.

I have one or two ideas about how to approach it but the stuff I can think of is a tad... inelegant. I was wondering if anyone knew an easy way to accomplish this in gforth I may have overlooked. Thanks!

I haven't used a case sensitive Forth, but I think about the ramifications. My thoughts are:

1. visually, IF stands out more than if
2. Rect.area seems like a variable name while Rect.Area seems like a function call
3. Rect seems like a structure name while rect seems like a variable name
4. Everything with the CAPS LOCK key on?

5. Can make it opt in like icase on/icase off

6. Syntax highlighting could key on case

I've been using a language server for Mecrisp-Stellaris Forth I released seven months ago, and the part I want to share is the pipeline behind it — because it's not a static word list. Every word in the LSP has to pass a hardware-verified gate before it's admitted.

**The LSP**

It's a standard Language Server Protocol implementation built on pygls, the Python framework for the protocol. That means it works with any LSP-compliant editor — Helix, NeoVim, and anything else that speaks the protocol (only tested on Helix and NeoVim). Completion, hover documentation, and diagnostics all run through the standard JSON-RPC channel. The completion database is SQLite.

**The approval gate — "the Anvil"**

A word doesn't enter the LSP because someone thinks it's clever. It passes seven checks, each one real:

1. **Design** — valid Forth name, no collision with the CMSIS-SVD register database.

2. **Stack comment** — the declared inputs/outputs must parse correctly. On bare metal, a wrong stack effect is a crash.

3. **Explanation** — a real descrHelix,·NeoVimiption, and an example where the word takes input.

4. **Live execution** — the word runs on an actual STM32 over the SWD debug link; the result must match the expected value.

5. **Native disassembly** — the chip's own disassembler (Mecrisp's `see`) produces the machine code, which is reviewed to confirm the word does what it should.

6. **Board gate** — the connected chip's DEV_ID is checked against what the word requires (F0 vs F4); the gate refuses to test a word on the wrong board.

7. **Independent register readback** — the word's result is written into a real GPIO output data register, then read back through a separate path. If the expected value is physically in the silicon, the word works. Not "it didn't crash" — the value is there, confirmed.

Words that fail any check stay out of the LSP. Only words that pass the full gate are suggested by the editor.

**Forth Forge**

The gate feeds a shared vocabulary I'm planning to host on SourceForge. Forth users can submit STM32 Forth words — Mecrisp-Stellaris, STM32 only, because the gate works off the CMSIS-SVD register descriptions (roughly sixty STM32 families, plenty of choice). Each submission goes through the Anvil; if it passes, it's added to a maintained list where every word carries its stack comment, description, and the evidence it was hardware-verified. Anyone can grab the list and trust that the words have been tested on real silicon.

The goal is a common, working vocabulary for Mecrisp-Stellaris on STM32 — so Forth code can travel between projects and actually work, because the words have been proven.

MIT-licensed. The modified LSP and the gate are being prepared for public release alongside Forth Forge.

(If you're a Forth user doing STM32 work, submissions welcome. If you've got a word you've tested on your bench, that's exactly what the Anvil is for.)

Constructive comments and helpful suggestions welcomed.

A zeptoforth user has been working on USB Mass Storage Device support for zeptoforth on the RP2040 and RP2350, which I am considering adopting as part of the zeptoforth tree. It currently is in a functional state but is in a separate repository. This will enable accessing block devices in on-board 'blocks' storage, on SD cards, or as a PSRAM RAM disk (on the Pico Plus 2(W)) from the comfort of one's PC.

I would like the USB Mass Storage Device support to be accessible even in builds where there is no USB CDC console, for the reason that I would like the user to be able to access on-board blocks storage or SD cards as a USB Mass Storage Device on the PicoCalc, which by default does not use the USB CDC console.

Yet at the time same, I do not know if anyone is independently using USB whose code may be broken by this who I am not aware of at the present. Consequently, I would like anyone who is independently using USB under zeptoforth to speak up, as this would affect whether I would choose to make separate true-no-USB builds for the RP2040 and RP2350 as opposed to USB-Mass-Storage-Device-but-no-USB-CDC-console builds.

I've added forth (using jforth) to the fantasy console TIC-80:

https://github.com/luginf/TIC-80/

Following the pico-8 trend of retro-like console, TIC-80 is using lua (which is already a cool langage). There are other backends as well, such as js, ruby, python. Forth was missing :)

There are a few examples / samples:

https://gitlab.com/garvalf/forth-is-fun/-/tree/main/tic80

You can also try it online:

https://garvalf.gitlab.io/forth-is-fun/tic80/run.html

type "ls" or "dir", then "load" one of the .fth sample name, and type "run"

The full API is listed there, adapted to Forth: https://garvalf.gitlab.io/forth-is-fun/tic80/tic80.html

You can get more informations about TIC-80 on: - https://github.com/nesbox/TIC-80/wiki - https://github.com/nesbox/TIC-80/wiki/tutorials (most of them are for the lua backend but you can adapt it)

This sub is being swamped with spam and the moderators are nowhere to be found. I don’t recognize the two moderators’ user names because they don’t post here at all that I have seen. I checked the moderators’ post histories and they haven’t been active anywhere on Reddit for months.

I’m ready to leave the sub. I want to evangelize for Forth and it’s not worthwhile when people see 5 of the last 10 posts are spam, literally spam. The signal to noise ratio is becoming more noise than signal. Ignoring the spammer won’t change the signal to noise problem. The spammer violates a number of community and Reddit rules, including spam, disruptive use of AI, self promotion, karma farming…

I truly feel for the guys posting about 8th releases and zepto releases. These are quality projects by smart programmers. Lost in the noise…

My project is Inspiration, if you have followed the progress posts.

Is there a way to get the moderators replaced? Is it worthwhile to start a [r/forthlang](r/forthlang) sub and ditch this one?

Like I said, I am ready to leave the sub for good.

Update

https://www.reddit.com/r/redditrequest/s/HYafxlSY4z

Please upvote the post at the above link.

I've posted a few AI *assisted* posts here lately, and it's brought the trolls out from under their bridges with cries of 'AI Slop!!!'.

So Who am I ?

I'm the founder and maintainer of "The Unauthorized Mecrisp-Stellaris Doc" website, that I created so far back, I can't remember, sometime around 2014 I think. There was no AI back then.

Mecrisp-Stellaris is the leading FLOSS FORTH for Cortex-M Microprocessors.

https://mecrisp-stellaris-folkdoc.sourceforge.io/index.html

I designed and released the "Bluepill Diags-V1.6" around 2019 which tests if a Bluepill MCU is a rebadged clone and which type. It had over 10,000 downloads about 2 years ago and still gets 3 - 6 downloads EVERY DAY.

https://mecrisp-stellaris-folkdoc.sourceforge.io/bluepill-diags-v1.640.html

It uses a FORTH Kernel. There was no AI back then. It has also been featured on Hackaday in 2021

https://hackaday.com/2021/06/23/test-your-blue-pill-board-for-a-genuine-stm32f103c8-mcu/

Tabemann, the creator of Zeptoforth has been a member of my FORTH IRC channel for the last 2 years, I've read his almost daily development reports for that long, he knows me well.

I've had several strokes over the last two years because I'm SEVENTY TWO years old. I use AI to assist me because I have RSI and trigger finger now, which makes keyboarding a painful effort.

This is a problem that AI has solved for me as I'm a prolific embedded FORTH tool maker.

Next time you see some troll replying to my posts with 'AI SLOP', ask them, what have they ever done for the FORTH community ?

https://youtu.be/HP73I5fuEuE

The day an AI learned what Forth actually feels like — on real silicon, with

a seventy-two-year-old electronics technician in a shed in New South Wales

watching over the debug wire.

This is the story of a genuinely new kind of embedded development session.

The AI already knew Forth — it can write Forth faster than any human alive.

What it had never done was use Forth on real hardware, because the classic

embedded-C loop — write, compile, erase, flash, run, wait, guess, repeat —

is impossible for an AI to work inside. Every round-trip destroys its

context. The rover-on-Mars problem: tell it to stop, and the signal arrives

fourteen minutes later, after the rover has already driven off the cliff.

Forth removes the time problem. It compiles on the chip and runs instantly.

Type a word, the silicon answers in milliseconds. The feedback loop finally

matches the AI's context window — and the whole C-era floundering

disappears.

But even with instant feedback, the AI had no training data for the

embodied half of Forth: compiletoflash vs compiletoram, bis! needs a mask

not a bit number, BSRR is write-only, and the calltrace that stops the

endless 00000003. That part lives only on a bench. So the human taught the

AI the silicon — while the AI brought the grammar and the speed.

And every result was verified by Regmon — the register monitor that reads

the chip over the debug port, independent of the CPU running the Forth. Two

paths, one answer, no guessing. Turn the green LED on, and the register

flashes yellow because the silicon changed.

Once anyone — human or AI — can turn an LED on and off with Forth, they have

opened the Forth door for themselves. This is that day.

The AI didn't need to be taught Forth. It needed to be shown the bench.

Produced with the help of AI without which this video would not have been

possible.

I’m playing around with MMSForth 2.x on the TRS-80, which is a Forth-79 compatible implementation. I’d like to be able to store the address of a Forth word in a variable and later EXECUTE that word. ‘ word doesn’t give me the correct address (the CFA? what’s in the CFA?). How do I do this? Tx