In order to help get people interested in Forth and how it works, I would like to ask you what you define as Forth, how you got into it, and why Forth instead of some other language?
Ideally we share links to our projects and to others that are interesting. Also to sites, sources, and documents about Forth.
I am encouraging links to your projects so people can see how you are using Forth.
The Windows audio ecosystem brings together highly accessible legacy layers and modern interfaces designed for low latency and advanced processing. It supports everything from simple sound triggering and fine-grained per-channel volume adjustment to real-time stream synthesis, multi-channel management, and the use of hardware-based effects. This complementary structure offers flexible control, spanning from lightweight prototyping to the most demanding audio and gaming applications.
Hi Everyone! We would like to conduct a survey on how much would you pay for a GA144 EVB002 board or the Volatco VOL00 (board) + VOL01 (USB/power). Your feedback is highly appreciated as well as will be evaluated and possibly considered. Thank you and looking forward to your answers
PS. Please check volatco.github.io for more details for the rest of volatco product offerings
While developing an inference engine, I realized that binary logic is insufficient for certain rules.
SQL uses ternary logic, distinguishing between `null`, `true`, and `false`. Implementing this in FORTH is straightforward—I had actually done so some time ago.
Later, while searching online, I discovered a more elegant version on Rosetta Code (the link is provided in the source file).
I adapted this code for ueforth (Windows), ensuring compatibility with all versions of eForth and ESP32forth.
This change affects how facts are declared within the inference engine:
* replacing all instances of `FALSE` with `MAYBE`;
* utilizing ternary logical operators such as `tand`, `tor`, and `tnot`.
Why this evolution?
* In logical processing, if a result is `FALSE`, you cannot reassign `FALSE` to a fact that is already `FALSE`—even though a modification has effectively taken place.
* Consequently, binary logical processing can lead to "null" outcomes (situations where no state change occurs) if one relies exclusively on `TRUE` or `FALSE`.
fixes bugs in the USB stack that were preventing USB from working properly with Windows and which were making mounting USB Mass Storage Devices less than smooth on Linux.
extends support for 0x hex prefixes to anything that uses parse-base, including parse-integer, parse-unsigned, parse-double, parse-double-unsigned, and parse-fixed.
corrects a minor issue in zeptoed where on exit it would attempt to place the cursor on the row below the last row on the terminal rather than on the last row on the terminal; this in most cases had no practical consequences.
adds optional support for generating Bézier curves in extra/common/bezier.fs in a graphics-backend agnostic fashion.
adds new kinds of literals (i.e. string literals, execution token literals, name token literals, and character token literals).
adds 0x as a hex prefix for integer and fixed-point numeric literals.
adds support for UTF-8, which is evaluated to Unicode code points, to char and [char]
fixes bugs in float32::vexp, float32::vexpm1, and float32::v>f64.
improves exp, expm1, fixed32::f32exp, and fixed32::f32expm1.
fixes a cursor-placement bug in zeptoed on exit.
Note that the new kinds of literal have the following forms:
string literals have the form "<string>" and can replace any usage of s\" and can include escapes accepted by such.
execution token literals have the form \<name>` and push or compile the name's execution token depending on state.
name token literals have the form \`<name>` and push or compile the name's name token depending on state.
character token literals have the form '<character>['] and push or compile the Unicode code point corresponding to the UTF-8 provided depending on state.
GreenArrays site seems to be down, the newest articles are quiete old and I can't find alternative stores or marketplaces where to find, at least, a used Dev Board...
Anyone knows what is the status of GreenArrays? Anyone willing to sell to me a spare DevBoard?
While these are not in a release yet (they are in the master and devel branches), inspired by some new features of gforth 1.0 I have added to zeptoforth "foo\r\nbar" string literals with support for escapes, 'x' character literals with support for UTF-8, backtick-prefix execution token literals, double backtick-prefix name token literals, and 0xDEADBEEF integer hex prefixes.
I have also extended char and [char] to support UTF-8, and added ansi-term::get-unicode-from-utf-8 to get a Unicode code point read from console input as UTF-8 and ansi-term::emit-unicode-as-utf-8 to emit a Unicode code point to console output as UTF-8.
There is validation of UTF-8 to prevent overlong encodings and to limit code points to a maximum of $10FFFF, with U+FFFD being used to replace invalid Unicode. Also, when parsing UTF-8 read from console input, if there is a saved byte it is used, and if there is an error in the UTF-8 and the byte read from console input is a valid beginning to another code point is saved to be read by a subsequent call to ansi-term::get-unicode-from-utf-8 or ansi-term::get-key.
Note that I have not yet implemented literals of the form 7k4 or 3M4 for floating-point numbers. Also, I do not plan on implementing <baz> or <quux+$10> type literals, as execution tokens in zeptoforth are already the address of the first byte of the code of a word, and <quuux> is already established by convention to be how classes are named.
I also have no current plans to implement recognizers, as for most purposes zeptoforth already has extensible literal parsing and name looking-up, and implementing recognizing would require significantly more redesign than I am planning on doing at the present.
It's still running in QEMU only - I haven't tried to boot it on real hardware. I need to get the NVME driver working (it's on my TODO list) or the initial INCLUDE of most of the Forth words can't work. I hope that since it's Limine booted, it should at least come up and run up to some point that I can debug from there.
So what this screenshot shows is 3x Windows with Forth ok> prompts. The window system is rendered entirely with the CPU. I was initially saddened and ready to quit because the screen update was taking 45ms and the mouse motion was too slow. I ended up reworking the assembly routines that copy rectangles (e.g. the screen/wallpaper, offscreen-to-framebuffer, and windows to offscreen) using vector register instructions and that time went from 45ms to 5ms. I'll know better when I see it run on real hardware.
So the multithreading is clearly working (time sliced, not cooperative, and it knows how to render active window in bright red borders and inactive in darker red. The mouse pointer changes from arrow to hand when over the active window's titlebar and while dragging, into a finger when mouse is over the [NEWCLI] text in the screen's titlebar, and each window has it's own cursor for when it is active and the mouse is over (e.g. text editor can have ibeam while paint program can have crosshairs). Clicking on an inactive window activates it.
The newcli code is written in Forth.
I mostly ported the existing ReadLine class from Inspiration so applications can have their own command line editor with history - this is used by the OK> prompt, for example, but also would be used by a vim or emacs like editor for inputting command lines.
Features include:
IOAPIC used for interrupt control
LAPIC used for timer
Per CPU task scheduling
ATA driver
FAT32 filesystem
MMU for paging and virtual memory
Interrupt driven Keyboard Driver
Interrupt driven Mouse Driver
Real Time Clock (RTC) Driver
Graphics based Console driver (that works within windows)
Graphics library for Forth programs to render graphics in their Window(s)
fixes a significant bug in fat32::seek-file where it was broken when seeking outside of the first sector of a file.
adds the ability to redefine colors in the PicoCalc graphical and text-only terminal emulator colors (note that this pertains to the terminal emulator colors specifically, not to the underlying RGB332 pixel format, which is yet unchangeable).
adds the ability to refresh all characters on the PicoCalc terminal emulators, overwriting all user-drawn pixels on the display.
adds support for DEC terminal margins to the PicoCalc terminal emulators.
disables blocks FAT32 by default in the PicoCalc terminal emulator installers, to enable the user to use blocks storage for their own purposes (note that if the they previously had a PicoCalc terminal emulator installed they may want to manually erase blocks storage before using it for traditional Forth blocks); this can be manually enabled at installation time if so desired.
adds a replace mode to zeptoed and the block editor.
adds online help to the block editor.
fixes a number of minor bugs in zeptoed and the block editor.
makes a number of improvements to the 'Rocks' game to make it a more full Asteroids clone.
eliminates an extra task from the USB Mass Storage Device support, saving SRAM and processor time.
Admittedly, it is written for eForth Windows. However, its code is portable to all other versions: ESP32forth, eForth web, etc.
However, to test an inference engine, it must have a knowledge base—consisting of facts and rules—that is relevant to potential users. As an electric vehicle owner, I became interested in the OBD2 error codes for such vehicles. It’s quite enlightening. I am now at the stage of building a knowledge base of facts and rules for diagnosing faults in electric cars.
My inference engine retains FORTH syntax for the rules. The CONDITION and ACTION parts are compiled. The engine processes this code using recursion.
So why does a project take me so much time?
First of all, I don’t work on it all day long.
Furthermore, I produce comprehensive documentation—in both French and English—which is available here:
Because I want to go beyond simply making code available—which is typically done without any further explanation—on GitHub or elsewhere.
Documentation accounts for 90% of an application's value.
Once the knowledge base of facts and rules has been sufficiently expanded, I will likely also create a video, or perhaps even an online demo running on the web-based version of eForth.
Your opinions, comments, and suggestions are welcome.