ForthSpace

ForthSpace is an opinionated development environment that resurrects FORTH—a language so lean it once fit in 2KB of RAM—for today's microcontroller landscape. Embedded development is stuck in the 1980s: edit, compile, flash, wait. FORTH, by contrast, lets you type code directly onto a running device, test it immediately, and iterate at the speed of thought. But its tooling has barely evolved since the days of teletypes.

ForthSpace brings that interactive magic to modern IDEs. You get a real-time stack visualization, inline debugging, and a REPL that talks to your board over serial or WiFi. The compiler is written in Rust for safety and speed, cross-compiling FORTH to AVR, ARM Cortex-M, and ESP32. A built-in package manager (yes, for FORTH) and a unit testing framework make it not just retro, but practical.

This is not a toy. It's a serious attempt to revive the productivity of FORTH's interactive development while wrapping it in a toolchain that 2024 developers expect. The ultimate goal: cut the iteration cycle from minutes to seconds for embedded projects.

Embedded developers are chained to C/C++ with slow edit-compile-flash cycles. Debugging often requires extra hardware (JTAG) and complex setups. Meanwhile, FORTH offers a REPL-driven workflow where you can change code on a live system, explore memory interactively, and build incrementally. But the existing FORTH tools (Win32Forth, gforth) are cryptic, lack modern IDE integration, and have no package management or cross-compilation to popular MCUs. The gap between FORTH's potential and its accessibility leaves this powerful paradigm abandoned.

• Provide a modern IDE with syntax highlighting, real-time stack visualization, and integrated serial terminal.
• Cross-compile FORTH source to AVR, ARM Cortex-M, and ESP32 targets.
• Enable live REPL over serial or WiFi (no USB disconnect to flash).
• Include a built-in unit testing framework with assertions and coverage reports.
• Ship a package manager ('spool') for sharing FORTH libraries.
• Offer a real-time debugger with hardware breakpoints, step-over, and watch windows.
• Support direct GPIO reads/writes and peripheral interaction from the REPL.

• Not a general-purpose language; FORTH remains niche for embedded and systems programming.
• Not a replacement for C's performance or library ecosystem; we interop with C via FFI.
• Not support all FORTH dialects; only eForth and ANS Forth (subset).
• No graphical UI builder; console and terminal are first-class citizens.
• Not target x86 desktop applications; focus on microcontrollers.

Rust (core compiler, runtime, cross-compiler), WebAssembly (in-browser REPL demo), C (low-level embedded glue), YAML (project configuration), Electron/Tauri (desktop IDE), Monaco Editor (code editor), custom serial/websocket protocol for device communication.

ForthSpace's architecture is layered. At the base is a Rust-native FORTH compiler that parses source into an intermediate representation (IR), then emits native code or threaded code for the target. The runtime (a small FORTH kernel) runs on the device. Communication between IDE and device uses a lightweight packet protocol over serial or WebSocket: the IDE sends FORTH words to be executed, the device returns stack state and output. On the desktop side, Electron/Tauri hosts a Monaco editor with a plugin that visualizes the stack and call frames. A cross-compile pipeline replaces the REPL with offline compilation for production deployment. The package manager 'spool' pulls libraries from a central registry (hosted on GitHub) and vendors them into the project.

FORTH's use of RPN and stack operations can be off-putting to modern developers; adoption may be low. The myriad of microcontroller architectures makes cross-compilation hard to maintain. Real-time constraints (e.g., interrupt latency) require careful integration with the FORTH kernel. Community fragmentation—many tiny FORTH dialects—could dilute efforts. Performance may not match hand-tuned C for critical loops.

Should we implement a cooperative multitasking scheduler in FORTH for concurrent tasks? How to handle floating-point support on small MCUs? What licensing model: open-source core with optional commercial extensions? How to fund ongoing hardware support (ESP32, STM32, etc.)? Is a visual debugger worth the complexity over a terminal-based one?

We prototyped the core compiler and got a REPL working on an Arduino Uno, but then the team scattered—one member got into grad school, another joined a startup. The sheer breadth of hardware targets and the maintenance burden of a full IDE made it too ambitious for a side project. The plan sits on a shelf, still beautiful, waiting for time or a patron.

Inspired by Chuck Moore's minimalism and the joy of instant feedback. The name 'ForthSpace' evokes both the language and the workspace. Early tests showed that even a 16MHz AVR could run an interactive FORTH kernel with <10KB RAM.