Both makes certain assumptions, but Darcy uses minimal abstractions and translates nearly 1:1 (does not support explicit traits though). Quiche is a tad bit slower than Rust (~80-85%) in performance but you win in terms of developer productivity and keep the same safety checks as Rust. Both are 100% safe.
Getting the LSP working for either of them has been more challenging than I imagined. Quiche affords me more choice because of the fantastic Ruff project. I am already heavily relying on their AST with Rust types latched on and an additional compiler pass for adding native support for discriminated enums.
Anyway, I think the space is particularly challenging for non-interpreted languages as they lack the real-time introspection necessary to do this. So additional infrastructure is required to basically, rebuild parts of the compiler to be more interpreter like. Just wanted to share some background on the complexities surrounding this stuff.
I think it sounds less odd when seen as a compound name, like "Steel Bank Common Lisp" instead of just "Lisp".
From https://mecrisp.sourceforge.net/
Mecrisp for MSP430: The name Mecrisp derives from French "écris" - I write, you write - and the letters MSP, as in MSP430. Think of it as "you write on the MSP430", as Mecrisp compiles directly into flash memory.
Mecrisp-Across for MSP430: Mecrisp-Across is an experimental cross compiler generating binaries for MSP430 microcontrollers as tiny as the MSP430F2012 and smaller. As a tethered Forth, it gives the illusion of interactively developing Forth code with hardware access to the real target by running the Forth environment on a suitably capable host microcontroller and transparently relaying all peripheral IO access through JTAG/SBW into the real target. As Mecrisp-Across itself has plenty of memory available in the host system, it performs global optimisation of the whole user Forth program, with constant folding, register allocation of both data and return stacks across control structures, automatic inlining and dead code elimination.
Mecrisp-Stellaris for ARM: Mecrisp-Stellaris runs on a wide selection of ARM Cortex M0, M3, M4 microcontrollers, also including targets running directly on Linux and FreeBSD. You can choose between two different compilers: The legacy compiler is capable of constant folding and needs 16 kb flash, whereas the "RA" compiler needs 20 kb flash, and also performs automatic inlining and a register allocation for the data stack. If your chip offers 32 kb flash or more, go with the "RA" one!
Mecrisp-Quintus for RISC-V and MIPS: Mecrisp-Quintus runs on 32 bit RISC-V (RV32I, RV32IM, RV32IMC) and MIPS (M4K) targets, also including variants running on Linux. Typical Forth core sizes are between 18 kb and 30 kb depending on the amount of necessary target specific code, processor architecture and the availability of compressed instructions. The Forth cores as-is perform constant folding. Stronger optimisations like automatic inlining and register allocation for both data and return stack are available as loadable "Acrobatics" compiler extension written in Forth.
Mecrisp-Ice for FPGA: Mecrisp-Ice is a 16 bit Forth running on a stack machine specifically developed for FPGAs, originally based on Swapforth and the J1a processor by James Bowman. Mecrisp-Ice requires initialised single-cycle dualport RAM blocks to run and is developed with excellent realtime capabilities and deterministic interrupt timing in mind. Due to instruction set design, the maximum (and recommended) amount of addressable executable memory is 16 kb, with an usable minimum of 8 kb.