> The comptime feature is probably the most exciting thing I've seen in a while

Just please do not make the mistake of believing that it is unique to Zig. Factor brings the best of Forth and Lisp together, so meta-programming or extending the language is possible quite easily, for example. You could extend the syntax or add constructs pretty easily, and so forth. Anyways, an example can be found here: https://rosettacode.org/wiki/Compile-time_calculation#Factor but this barely scratches the surface. It does not mention `<< ... >>` which evaluates some code at parse time. You can execute code before the words in a source file are compiled.

https://docs.factorcode.org/content/article-literals.html

https://docs.factorcode.org/content/article-syntax-literals....

https://docs.factorcode.org/content/article-syntax-immediate...

https://docs.factorcode.org/content/word-flags{,literals.htm...

I remember when I did something like:

  SYMBOL: aligned-16-char

  <<
  : 16-byte-alignment ( c-type -- c-type )
      16 >>align 16 >>align-first ;

  char lookup-c-type clone 16-byte-alignment \ aligned-16-char typedef
  >>

when I was working on some binding.

You could use it in a struct like:

  STRUCT: foo
    { bar aligned-16-char[16] } ;

Or something like this is pretty typical (when writing bindings/ffi):

  << "libotr" {
      { [ os windows? ] [ "libotr.dll" ] }
      { [ os macosx? ] [ "libotr.dylib" ] }
      { [ os unix? ] [ "libotr.so" ] }
  } cond cdecl add-library >>

Those are just some examples, but it is pretty powerful. It supports (and encourages) interactive development. Profiling and debugging is a breeze and highly detailed and useful, you can easily disassemble words (functions), you can get a list of how many times malloc has been called in some circumstances, there is runtime code reloading (a vocabulary that implements automatic reloading of changed source files[1]), and so on. And on top of all this, you can compile your stuff to an executable that is less than 4 MB!

And of course you do not have to do stack shuffling at all, you can easily use locals which is useful for math equations and whatnot. Plus did you know that the Factor compiler supports advanced compiler optimizations that take advantage of the type information it can glean from source code? The typed vocabulary (yes, it is not part of the language, but implemented as a vocab) provides syntax that allows words to provide checked type information about their inputs and outputs and improve the performance of compiled code.

I would like to repeat because if this was not the case, I would have never bothered with it: you can create a single executable file that is less than 4 MB of size if you wish so! Of course it encourages interactive development, but still, it is great to have an optimizing compiler that can do all this easily. And mind you, this part is also written in Factor itself and is available as a vocabulary (vocab).

[1] There is a vocabulary named io.monitors and loaded source files across all vocabulary roots are monitored for changes. You can read more about it here: https://docs.factorcode.org/content/article-vocabs.refresh.h...

---

So all in all, I think Factor is great. I was shocked at how modern (and how many) libraries it has, especially considering only a handful of people have been working on it. Slava Pestov created the language, and some people joined him later on. If you want to learn more about it, start here: https://concatenative.org/wiki/view/Factor. There are videos, there are papers, there are lots of resources to get started. :) The language misses a couple of things, but it is being worked on.