#PDF #paper from Anton #Ertl about Portable Assembly #Forth. #toread #asm
on 02026-09-19elements of #colorForth. #Forth
on 02026-09-11The #GForth implementation of #Forth has #reproducible-builds working on #Debian.
on 02026-09-02tpbsd (Terry Porter) just posted this “register monitor for ARM microcontrollers with an AI assistant” to comp.lang.forth. #forth
on 02026-08-28Anton Ertl’s comments on getting tail-call optimization out of GCC in #C for the GForth #Forth implementation — Python got there first, he said, and congratulations.
on 02026-08-10Concatenative languages Wiki (#Forth, etc.)
on 02026-07-20Bernd Paysan has assumed responsibility for maintaining the #Debian GForth package, and it will return. #Forth
on 02026-06-23"Lina": a LInux NAtive #Forth for {Intel,ARM,RISC-V}
on 02026-06-23#PDF #paper by Mitch Bradley providing a #Forth implementation in #PostScript
on 02026-06-16my comments on #Forth and local variables vs. the stack
on 02026-05-23#Forth/#Lisp hybrid by Xorvoid. “Recently I’ve discovered a very interesting language / realization of the Lambda Calculus. I was unable to find any other language like it, which I find quite surprising. In hindsight, the language seems obvious and natural.”
on 02026-05-20#DuskOS author vdupras’s #Forth #tutorial blog.
on 02026-05-20#DuskOS author vdupras’s thoughts on #Forth. “Forth is a fine and capable language, but I tend to agree with those who say that it tends to produce write-only programs. Most of the books on Forth are very old and compare Forth's elegance to Fortran’s or COBOL’s. I’m of the opinion that C is more expressive and generally produces more elegant and maintainable code. (...) I wrote this page, what, 4 years ago? I’m irked by me writing that C is more expressive than Forth. The thing is that generally, when you write Forth, you write your own language. So it’s as expressive as you make it. (...) Today, whenever I write C code, I find the language underpowered. Sure, you can, kind of, build your own language through macros, but seriously, textual-based macros? How blunt! Forth can take you to the next level, macro-wise.”
on 02026-05-20#video #toread of #Forth, Inc.’s Elizabeth Rather from 01984 on “Computer Chronicles”.
on 02026-05-17"zeptoforth" is a Cortex-M #Forth, currently targeted at #RP2040 boards such as the #Raspberry-Pi Pico. Its kernel has versions written in Thumb-1 assembly, for the RP2040, and Thumb-2 assembly, for the #RP2350.
on 02026-04-21#Mecrisp puppeting #MSP430 #microcontrollers over #JTAG to test your #Forth with access to peripherals without installing Forth on them, then cross-compiling and installing firmware on it that doesn't include the interactive Forth REPL. #hardware #electronics
on 02026-04-12#Mecrisp Stellaris #Forth apparently has pretty good support for #STM32 #microcontrollers #electronics #hardware
on 02026-04-12Discussion of Jack #Rusher’s “Stop Writing Dead Programs”; I got onto discussing #Forth.
on 02026-04-09Really good article about what practical advantages and eternal usefulness #Forth may or may not possess
on 02025-12-14arguments about the complexity or simplicity of #Forth control structures
on 02025-11-11#GForth #Forth #tutorial #documentation on reading and writing files or grepping them
on 02025-11-11#PDF #ebook eForth Overview by C.H. Ting #toread #Forth
on 02025-11-11Ulrich Hoffmann’s "stringstack" package for #Forth, “based on a string stack implementation by Klaus Schliesiek from 1986”
on 02025-11-11the code to generate tokenized #OpenFirmware #Forth boot sectors for #NetBSD, with the token table etc.
on 02025-11-11#Lukego on how #OpenFirmware is his favorite firmware. #Forth
on 02025-10-21#Bluepill #microcontrollers #electronics #hardware diagnostic guide for use with #Mecrisp #Forth.
on 02025-09-30#Forth and the foundations of functional programming
on 02025-09-05Xlib bindings for #GForth in include unix/x.fs. #Forth #X-Windows
#screencast of #Veltas’s ZX Spectrum block editor in simulation #Forth #retrocomputing
on 02025-08-29#veltas (Christopher Leonard) #screencast #video of 40 minutes of #Forth programming of a “script” command which appends a line of interaction to a file before interpreting it, reading the docs in mupdf. 41'. Interesting to see some REPL hacking in GForth.
on 02025-08-29Mecrisp-Stellaris #Forth for #MSP430 #microcontrollers now has #LSP support for your IDE.
on 02025-08-06Brad Rodriguez explains how multitasking works in #Forth. #operating-systems
on 02025-05-28a simulator for the GreenArrays F18A #Forth #hardware
on 02025-05-20#Forth for #RISC-V: comparison operator implementations
on 02025-05-20Dennis Kuschel’s My4th Light #Forth #CPU #hardware
on 02024-12-10a game in #Forth for the original Macintosh and Commodore 64 under #CC BY-SA. #retrocomputing
on 02024-11-20#Veltas’s #Forth checker for expression nesting: decimal create braces here , 64 cells allot : >braces 1 cells braces +! braces @ ! ; : braces> braces @ @ -1 cells braces +! ; : { depth >braces ; : } depth braces> 1+ <> abort" Unbalanced expression" ;
the #Forth #standards process, with meeting notes, etc.
on 02024-11-03#Mastodon of @meithecatte who wrote a 512-byte #Forth.
on 02024-11-03a #Forth in 512 bytes. Lots of syntax-highlighted #asm, I think the full literate program. By @meithecatte. #toread #small-is-beautiful
on 02024-11-03Virgil Dupras’s #Lisp in #Forth for #DuskOS
on 02024-11-03#Forth 2012 in Common #Lisp, MIT-licensed
on 02024-10-11Frank Sergeant’s 01991 paper, “A 3-Instruction #Forth for Embedded Systems Work: Illustrated on the Motorola MC68HC11” #microcontrollers
on 02024-09-10"Ilo" is a simple MISC stack machine with an environment called "Konilo" built on top of it. This implementation is 150 lines of C. 65,536 32-bit cells of memory, no bytes, keyboard input, serial display, Forth-like block storage of 1024 cells per block, 30 instructions. There’s an implementation of it on PJRC’s 1MiB-RAM #Teensy 4.1 devboard. #virtual-machines #Forth #small-is-beautiful
on 02024-09-10the #Forth 83 standard (ASCII, 89 pages)
on 02024-09-04#PDF #ebook from 01988 by C.H. Ting, about the #Forth Novix #NC4000 #hardware design by Chuck Moore, a gate-array design from the 80s.
on 02024-08-31#Kartik’s #video visualizing postfix notation similar to #Forth #UX
on 02024-08-27#video showing #Forth #retrocomputing with #F83, #F-PC, CHForth, and volksForth running under MS-DOG in DOSBox on a Raspberry Pi
on 02024-08-27#F83 #Forth for #8080 #CPM #retrocomputing
on 02024-08-27#PDF from 02019 by James Brakefield listing mostly open-source #microcontrollers #gateware on #OpenCores, including a bunch of #6502 designs, an RCA 1802 or two, some Motorola 6801 clones, a bunch of #8051 clones, several #8080 designs (including one by C.H. Ting!), several #68000 designs, several #68HC11 designs, several ARMs (which are not all proprietary), some #AVR designs, a lot of #Forth chips, a PDP-1, a bunch of MIPS designs, an MMIX, various #OpenRISC 1000 designs, a PDP-10, a bunch of PDP-8s, a lot of PIC16s, a lot of #RISC-V designs, Cray-1 and Cray-2 clones, several Z80s, the #Reduceron, etc. There’s a table specifying how many LUTs each one achieves, how many KIPS per LUT (!), what they’re written in, how big their address spaces are, year started, year of last revision, etc.
on 02024-08-25#Forth webring as of 02016
on 02024-08-25original #Forth for IBM 1130 from the Mohasco carpet company. OPERATION SWAP 0 LS XCH FF LS 0 SS XCH FF SS RETURN OPERATION + 0 LS FF MS 0 ADD FS 0 SS RETURN #retrocomputing #history
in 01980 the Panasonic "HHC" (handheld computer) designed by Friends-Amis had 4K of RAM and supported #BASIC and #Forth with a 26-character one-line LCD display and a shitty QWERTY keyboard, MSRP US$500 (equivalent to US$1800 today) #history
on 02024-08-25#PDF scan of Phil Koopman’s article (01986? #FORTH Dimensions Volume VIII, No. 6) giving #Bresenham’s line-drawing algorithm in Forth. 23 lines of code provide a driver for 4-color CGA with comments explaining how to patch it for EGA or 2-color CGA. He got the algorithm from p. 435 of “Foley and Van Dam, Fundamentals of ICAD”, maybe actually “Fundamentals of Interactive Computer Graphics”, where p. 435 gives an implementation in Pascal. 2D #graphics #retrocomputing
on 02024-01-28"MFORTH" is a #Forth for the TRS-80 #Model-100 whose NEXT is only four instructions thanks to an undocumented #8085 instruction called LHLX. It includes an 8085 assembler.
on 02023-12-12"Curto" is an Argentine #Forth for #uxn in #español, translation of #UF
on 02023-10-08This is Charles Eric LaForest’s page about CPU design using #FPGA #hardware, mostly focused on #stack-machines and #Forth; he did his BIS at Waterloo, and his thesis contains the best explanation I’ve seen of why stack machines went out of favor.
on 02023-08-09a real-mode #FORTH that fits in a 512-byte boot sector #smallisbeautiful
on 02021-06-05#interview by Daniel Temkin about the #Orca #esolang, a two-dimensional ASCII language for #livecoding #music, by #100-Rabbits Devine Lu Linvega and Rekka Bell(um?), who live on a solar-powered sailboat called Pino and created a conworld called the Neauismetica. Talks a lot about #Fractran. “#Lisp is a slippery slope that leads inevitably to #Forth.”. #bootstrapping #cc by
on 02021-02-09Planckforth is a #smallisbeautiful #bootstrapping #Forth bootstrapped from a handwritten 1KB ELF binary. #source-code
on 02021-01-15A 16-bit 8086 (?) #Forth in a 512-byte boot sector. #smallisbeautiful
on 02020-11-12"Idel" is Darius Bacon’s secure #Forth #virtual-machine from 1997–2003; “a RISC approach to memory protection”. No native-code JIT (yet!).
on 02020-06-20Lennart Benschop defined, implemented, and GPLed the "SOD32" two-stack machine, similar to #MISC processors like the MuP21, and wrote a #Forth for it, in 1994.
on 02020-06-20A web framework in #Forth.
on 02019-02-12“I guess now is as good a time as any to explain "Mirth". Mirth is a strongly-typed #concatenative functional programming language. Mirth draws a lot of inspiration from monoidal category theory, as well as the languages Haskell, Idris, Rust, Lisp, #Forth, and its namesake, Joy.” #cs
on 02019-02-01#Scheme written in #Forth in Julia. #interpreters
on 02018-10-18a #Forth that includes a #Lisp interpreter: a Lisp-2 with 2-bit fixnum tags, a recursive-descent S-expression parser, shallow binding, and a Cheney collector. Too bad it uses dynamic scoping
on 02018-09-24The #J1(a) #Forth processor on the Nandland #hardware, which has the ICE40HX1K #FPGA among those supported by #IceStorm.
on 02017-10-01More on #Chuck-Moore, #Forth, and #hardware, up to #GreenArrays (as of 2013). Especially in the comment thread. #stack-machines #architecture
on 02017-08-06Biography of #Chuck-Moore, touching on #Forth and stack #hardware
on 02017-08-06how to run the #J1 #Forth simulator on MacOS under gforth
on 02017-07-20"SIMPL", a stripped-down #Forth interpreter, is now running within 780 bytes (on I think the MSP430 #microcontroller). #smallisbeautiful
on 02017-07-11#PDF #paper by Anton Ertl about “Portable #asm #Forth” as an UNCOL
on 02017-04-30Mark VandeWettering’s overview of the #J1 #Forth #hardware
on 02017-04-14on the #J1 #Forth CPU, optimized for FPGAs (rather than #hardware as such). 200 lines of #Verilog. “Originally designed to run the six WGE100 Ethernet cameras in the Willow Garage PR2 robot.” Amazing: “J1 runs at about 100 Forth MIPS on a typical FPGA. This compares with about 0.1 Forth MIPS for a traditional threaded Forth running on an embedded 8-bit CPU.”
on 02017-03-22#Chuck-Moore talks about his philosophy of #software-design in #Forth, interviewed by Jeff Fox, who is now dead.
on 02016-07-24Apparently the #OpenFirmware #Forth on the #OLPC hardware had words called struct and field to define records.
J1a SwapForth #video by jamesb beckman101, demonstrating synthesizing the CPU from #Verilog with #IceStorm. Looks like an IceStick. Demonstrates programming it interactively in a tiny #Forth with only 227 words (and a filesystem!) and generating a nice stable 1MHz square wave in software, displayed on his digital oscilloscope. #J1 #hardware
on 02016-06-22#PDF about the #GreenArrays F18A #hardware used in the GA144, documenting its instruction set. #stack #ISA #Forth
on 02016-05-24A free-software #Forth operating system running on the J1a open-source CPU running on a Lattice #FPGA thanks to Project #IceStorm’s reverse engineering and the resulting free-software #synthesis and programming toolchain, running on the Lattice iCEstick evaluation board with 8K of RAM. #J1 #hardware
on 02015-08-28a #Forth with nested words, state-smart control structures, simplified block structures, string literals, and POSIX regexps
on 02015-08-05a #Forth for #Raspberry-Pi
on 02015-08-05Some guy wants to inline his #Forth on his #Raspberry-Pi to speed it up
on 02015-08-05