SICL VS vox

This is a very approachable paper from 1990 on one way to do it with a C kernel bootstrapping to Common Lisp: https://www.softwarepreservation.org/projects/LISP/kcl/paper... Kyoto Common Lisp (KCL) is the ancestor of today's Embeddable Common Lisp (ECL).

SICL is probably the best modern version of CL written in CL from a design standpoint, even if it's not taking over SBCL's role anytime soon: https://github.com/robert-strandh/SICL It uses some fancy bootstrapping to have the whole language available early, e.g. their definition of class 'symbol is:

    (defclass symbol (t)

That's pretty much the objective of SICL, which is "intentionally divided into many implementation-independent modules that are written in a totally or near-totally portable way, so as to allow other implementations to incorporate these modules from SICL, rather than having to maintain their own, perhaps implementation-specific versions".

   https://github.com/robert-strandh/SICL

Gladly!

https://github.com/robert-strandh/SICL (which I wrote a decent chunk of the compiler backend of.)

I applaud your curiosity and initiative to explore. Are you aware of https://github.com/robert-strandh/SICL?

I mean this Klein and this SICL. Self and Common Lisp are memory-safe, though the implementations need capabilities to manipulate memory; SICL encapsulates them using first-class global environments.

There is significant overlap with SICL and its associated pieces which supply many of the other parts needed to make a Common Lisp. Some of these are Cluster which provides a portable and extensible assembler, Eclector which supplies a portable and extensible reader, Concrete-Syntax-Tree that supports source code tracking during compilation, ctype that implements the Common Lisp type system, and Clostrum that provides first-class environments for e.g. run-time, evaluation, and compilation. The SICL project has as one of its goals the creation of portable infrastructure for implementing Common Lisp, and these pieces are novel building blocks that were created as part of the project.

Not really; you can do it with primitive operations e.g. here is the list in the Cleavir compiler and a paper on "magic" in Jikes RVM. SBCL also has a "virtual op"/vop language for code generation, and vops are written to manipulate objects with assembly snippets.

Both work. I basically never have to touch C or even FFI (cl+ssl being the main use of FFI for me), unless I am poking at SBCL guts in my spare time, and that isn't necessary either. I am sure many Haskell hackers are happy with their IO monad too.

It's used in operating systems, compilers and CLIs.

The Cleavir Common Lisp compiler uses three-address instructions in a control-flow graph, though it is intended more for production use than educational use.

I chase the same goal with Vox, although it is written in D.

Just somewhere to point me, because while I do understand SSA a bit though I can't seem to make progress learning about it (dont know where from). I found https://github.com/MrSmith33/vox/blob/master/internals.md which kinda feeds me information but probably not enough.

Looking for contributors to Vox programming language/compiler: Statically typed, compiled and embeddable language, primarily focused on gamedev. It uses custom backend to keep low compile-times and small size. Written in D language.

https://github.com/MrSmith33/vox

Because it is easier to have a free-list in a dedicated array arena, so you could reuse memory when you free it (and you need to grow arrays when you fill them). I was lazy and did 13 array arenas each dedicated to allocating fixed size chunks, from 16 bytes to 64k bytes. Bigger sizes currently go to malloc/free. And I restrict arrays to PoT sizes, so they only request PoT sized chunks from array arenas.

I use this approach in Vox compiler. Everything is stored in arenas including AST nodes and IR. I'm in the process of documenting the design, but I added a bit of description on memory management and IR storage

Tip: Should probably use the Github permalink https://github.com/MrSmith33/vox/blob/35ec440d0c9a475cd4add6093d122cd249b03be9/source/be/reg_alloc/linear_scan.d#L891-L918 so later readers do not go to some random line after you change that file :)

Here is a CI build