That's cool. Did you compare performance with the PUC Lua VM versions (which are register based as well)? Personally, I find the Are-we-fast-yet suite very useful and usually migrate the suite to my languages to compare the implementations (see e.g. https://github.com/rochus-keller/are-we-fast-yet/).
Sounds like English film and television series music from the seventies (e.g. "All Creatures Great and Small"). It's nice and surprising (in that Suno was able to create it). But not "more beautiful than any song I have ever heard in my life, ever" ;-)
Lisp made the compiler’s internal tree representation directly writable by programmers. That is powerful, but it is not the same as giving programmers the best notation for expressing and maintaining large systems.
The tiny self-interpreter is a fine pedagogical artifact, but calling it software’s Maxwell equations oversells it. S-expressions are a convenient printable AST: lists whose meaning is supplied largely by the head symbol and argument positions. Excellent for macros and language experimentation; not necessarily a good human-level notation for large programs. A decent surface syntax provides useful "molecular" structure rather than exposing the "atoms".
That's a really cool project. Alex already managed to compile the Lisa sources published by the CHM in 2025 using the original Lisa tools run on Ray Arachelian's emulator (see https://github.com/alexthecat123/LisaSourceCompilation).
There seem to be a growing number of Rust based microkernel systems (Redox, Robigalia, Tock, Xous, etc.). Anyone knows what's the core benefit of LiberSystem in comparison? The contact address is funny:
I wouldn't worry about that. Tiobe simply measures how many search queries are made for some terms supposed to represent a programming language, and even that process is still inaccurate (e.g. because of ambiguity with other uses of the same terms). The result says nothing about how widely the language in question is actually used. There is no reason to assume a correlation between effective prevalence and the number of searches. Experienced developers are unlikely to enter the terms used by Tiobe into a search engine, and since most people are now working with LLMs, this measurement method is obsolete even more.
I’ve been working on a project to celebrate the anniversary of MUMPS and its first standard.
For those unfamiliar, MUMPS is an imperative language famously born at Mass General Hospital in 1966. Its defining characteristic is that the language and the database are deeply integrated. There is no impedance mismatch: hierarchical, persistent sparse arrays (called globals) are a first-class part of the language syntax, acting as an early NoSQL database decades before the term existed.
Implementing this was a lot of fun, but the lexer was a real challenge. MUMPS has highly unusual whitespace semantics, and nearly all commands can be abbreviated to one or two characters. This is probably the most complex lexer in my collection. The parser was originally generated using my EbnfStudio.
There are pre-compiled versions and a MUMPS 76 Primer with modern terminology in case you want to play with it.
To celebrate its 50th anniversary, I built a faithful implementation of the 1976 MUMPS standard.
For those unfamiliar, MUMPS was born at Mass General Hospital in 1966 and ran heavily on PDP-8s and PDP-11s. It was incredibly far ahead of its time: it had a built-in hierarchical database decades before we called it 'NoSQL', allowing hospitals to do concurrent, multi-user data storage on machines with just 8K of memory.
I wanted to build an interpreter just for the original 1976 standard to preserve how it felt and worked. It includes the database, a REPL, and it's capable of running historical software from the era (like the original STARTREK application shown in the screenshot: https://github.com/rochus-keller/MUMPS/blob/main/docs/imgs/m...).
If you want to play with it, I've provided pre-compiled binaries for Windows, Mac, and Linux, along with a modern Primer to help you learn the syntax.
> minikotlin is written from scratch in C and emits WebAssembly GC bytecode by hand — no JVM, no LLVM, no Binaryen, no Gradle
That's amazing. What an achievement! I would like to learn more about it, particularly have a look at the source code, but I didn't find a link. Any ideas?
I find it strange that they deleted the article. The topic is relevant and of sufficient interest. I think there is a deeper bureaucratic pattern behind it. In every once-useful organization, there comes a point where the rules stop being instruments and become relics: nobody asks whether they still serve the original purpose, because the bureaucracy now exists mainly to defend its own procedures. That is basically Parkinson territory, and also the classic drift into cargo cult administration.
The result is predictable: genuinely useful things get removed, while irrelevant but procedurally compliant nonsense survives. Lenz’s “die Freuden der Pflicht” comes to mind, the self-satisfied worship of duty detached from reason or outcome. And in modern internet terms, that is just another form of enshittification: the institution keeps its forms, its process, and its moral self-image, while the actual value quietly rots away.
That said, with the advent of systems like Perplexity I barely ever go to Wikipedia anymore. And nowadays I spend more money to archive.org than Wikipedia.
I recently added a Ninja backend and a users guide and thought this might be helpful for a lot of people. It was pretty stable over the years. I have a few features on my todo list which I will implement as needed, and I recently completed my LeanDoc document language and migrated most of my specifications, which sparked further activities.
I use it instead of qmake and cmake for all my projects since four years. It is most beneficial when used with large, standalone systems that must be built from the ground up for different platforms, and where it is a good idea to possibly even integrate the build system directly.
Static typing is important when you have a large project. I spent much time with the Chromium source tree and its GN build system which is dynamically typed (like most build systems) and thus you have to actually run it (with every possible combination of parameters) to fully understand it and find bugs. I was looking for a build system for my LeanQt and LeanCreator projects (> 1 MSLOC) and eventually built my own, which was quite a natural thing given my experience with the implementation of statically typed languages.
I'm in central Switzerland and I have 15 Mbps internet (just measured with https://www.speedtest.ch/, the cables to the nearest exchange can't handle any more traffic), and I don't know why I would need more.
> I think the actor model comes closest to Kay's objects.
It's rather the other way round. There is no pre-Hewitt implemented semantics matching Kay's later 2001 claims; Smalltalk-72 was a synchronous token-stream interpreter rather than a system of independently active message-driven agents; FLEX shows processes, scheduling and quasi-parallel control, not objects, not messaging, not actor-style autonomous entities.
“I wanted a scripting language that was more powerful than Perl, and more object-oriented than Python" and "Ruby's class library is an object-oriented reorganization of Perl functionality--plus some Smalltalk and Lisp stuff" (see "An Interview with the Creator of Ruby", 2001, https://web.archive.org/web/20041220041220/http://www.linuxd...).
