Another one https://github.com/kanaka/mal (quite famous AFAIK)
In The Idea of Lispkanaka
mal
Assembly2015–2026
kanaka / mal
mal
mal - Make a Lisp
Command LineWeb DevelopmentSystems & InfrastructureLanguages & CompilersLearning & ReferenceDevOps & Cloud
80Distinct people
128Mentions
4Explicit recommenders
10.8KGitHub stars
What to know before exploring
What it is
mal - Make a Lisp
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
A few weeks ago, I went through "Make a Lisp" [1] using C#. It only took a few days to get to a pretty useful implementation. I "cheated" quite a bit using the existing C#…
kgwxd used a recommendation phrase. 5 indexed comments match. This is a phrase match, not a verdict.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 8–Nov 15 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/15/2026, 12:45:45 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year128 dated mentions
Observed mentions: 2015-02-27 21:23:48 UTC to 2026-07-17 16:20:25 UTC.
* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 18 | 1 | 17 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 7 | 2 | 5 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 19 | 2 | 17 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 6 | 2 | 4 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 11 | 2 | 9 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 15 | 0 | 15 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 17 | 2 | 15 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 15 | 0 | 15 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 7 | 0 | 7 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 7 | 1 | 6 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 3 | 0 | 3 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 3 | 1 | 2 |
From the project README
An excerpt from the repository, fetched Nov 12, 2026.
Read the project’s introduction
mal - Make a Lisp
Description
1. Mal is a Clojure inspired Lisp interpreter
2. Mal is a learning tool
Each implementation of mal is separated into
11 incremental, self-contained (and testable) steps that demonstrate
core concepts of Lisp. The last step is capable of self-hosting
(running the mal implementation of mal). See the make-a-lisp process
guide.
The make-a-lisp steps are:
step0_repl
step1_read_print
step2_eval
step3_env
step4_if_fn_do
step5_tco
step6_file
step7_quote
step8_macros
step9_try
stepA_mal
Each make-a-lisp step has an associated architectural diagram. That elements
that are new for that step are highlighted in red.
Here is the final architecture once step A
is complete:
If you are interested in creating a mal implementation (or just
interested in using mal for something) you are welcome to to join our
Discord. In addition to the make-a-lisp
process guide there is also a mal/make-a-lisp
FAQ where I attempt to answer some common questions.
3. Mal is implemented in 89 languages (95 different implementations and 118 runtime modes)
Language
Creator
Ada
Chris Moore
Ada #2
Nicolas Boulenguez
GNU Awk
Mitsuru Kariya
Bash 4
Joel Martin
BASIC (C64 & QBasic)
Joel Martin
BBC BASIC V
Ben Harris
C
Joel Martin
C #2
Duncan Watts
C++
Stephen Thirlwall
C#
Joel Martin
ChucK
Vasilij Schneidermann
Clojure (Clojure & ClojureScript)
Joel Martin
CoffeeScript
Joel Martin
Common Lisp
Iqbal Ansari
Crystal
Linda_pp
D
Dov Murik
Dart
Harry Terkelsen
Elixir
Martin Ek
Elm
Jos van Bakel
Emacs Lisp
Vasilij Schneidermann
Erlang
Nathan Fiedler
ES6 (ECMAScript 2015)
Joel Martin
F#
Peter Stephens
Factor
Jordan Lewis
Fantom
Dov Murik
Fennel
sogaiu
Forth
Chris Houser
GNU Guile
Mu Lei
GNU Smalltalk
Vasilij Schneidermann
Go
Joel Martin
Groovy
Joel Martin
Hare
Lou Woell
Haskell
Joel Martin
Haxe (Neko, Python, C++, & JS)
Joel Martin
Hy
Joel Martin
Io
Dov Murik
Janet
sogaiu
Java
Joel Martin
Java Truffle (Truffle/GraalVM)
Matt McGill
JavaScript (Demo)
Joel Martin
jq
Ali MohammadPur
Julia
Joel Martin
Kotlin
Javier Fernandez-Ivern
LaTeX3
Nicolas Boulenguez
LiveScript
Jos van Bakel
Logo
Dov Murik
Lua
Joel Martin
GNU Make
Joel Martin
mal itself
Joel Martin
MATLAB (GNU Octave & MATLAB)
Joel Martin
miniMAL (Repo, Demo)
Joel Martin
NASM
Ben Dudson
Nim
Dennis Felsing
Object Pascal
Joel Martin
Objective C
Joel Martin
OCaml
Chris Houser
Perl
Joel Martin
Perl 6
Hinrik Örn Sigurðsson
PHP
Joel Martin
Picolisp
Vasilij Schneidermann
Pike
Dov Murik
PL/pgSQL (PostgreSQL)
Joel Martin
PL/SQL (Oracle)
Joel Martin
PostScript
Joel Martin
PowerShell
Joel Martin
Prolog
Nicolas Boulenguez
PureScript
mrsekut
Python2
Joel Martin
Python3
Gavin Lewis
RPython
Joel Martin
R
Joel Martin
Racket
Joel Martin
Rexx
Dov Murik
Ruby
Joel Martin
Ruby #2
Ryan Cook
Rust
Joel Martin
Scala
Joel Martin
Scheme (R7RS)
Vasilij Schneidermann
Skew
Dov Murik
Standard ML
Fabian Bergström
Swift 3
Joel Martin
Swift 4
陆遥
Swift 6
Oleg Montak
Tcl
Dov Murik
TypeScript
Masahiro Wakame
Vala
Simon Tatham
VHDL
Dov Murik
Vimscript
Dov Murik
Visual Basic.NET
Joel Martin
Visual Basic Script
刘百超
WebAssembly (wasm)
Joel Martin
Wren
Dov Murik
XSLT
Ali MohammadPur
Yorick
Dov Murik
Zig
Josh Tobin
Presentations
Mal was presented publicly for the first time in a lightning talk at
Clojure West 2014 (unfortunately there is no video). See
examples/clojurewest2014.mal for the presentation that was given at the
conference (yes, the presentation is a mal program).
At Midwest.io 2015, Joel Martin gave a presentation on Mal titled
"Achievement Unlocked: A Better Path to Language Learning".
Video,
Slides.
More recently Joel gave a presentation on "Make Your Own Lisp Interpreter
in 10 Incremental Steps" at LambdaConf 2016:
Part 1,
Part 2,
Part 3,
Part 4,
Slides.
Building/running implementations
The simplest way to run any given implementation is to use docker.
Every implementation has a docker image pre-built with language
dependencies installed. You can launch the REPL using a convenient
target in the top level Makefile (where IMPL is the implementation
directory name and stepX is the step to run):
make DOCKERIZE=1 "repl^IMPL^stepX"
# OR stepA is the default step:
make DOCKERIZE=1 "repl^IMPL"
External / Alternate Implementations
The following implementations are maintained as separate projects:
HolyC
by Alexander Bagnalla
Rust
by Tim Morgan
by vi - using Pest grammar, not using typical Mal infrastructure (cargo-ized steps and built-in converted tests).
Swift 2
by Keith Rollin - This implementation used to be in the repo. However, Swift 2 is no longer easily buildable/testable.
Q
by Ali Mohammad Pur - The Q implementation works fine but it requires a proprietary manual download that can't be Dockerized (or integrated into the mal CI pipeline) so for now it remains a separate project.
Other mal Projects
malc - Mal (Make A Lisp) compiler. Compiles a Mal program to LLVM assembly language, then binary.
malcc - malcc is an incremental compiler implementation for the Mal language. It uses the Tiny C Compiler as the compiler backend and has full support for the Mal language, including macros, tail-call elimination, and even run-time eval. "I Built a Lisp Compiler" post about the process.
frock - Clojure-flavoured PHP. Uses mal/php to run programs.
flk - A LISP that runs wherever Bash is
glisp - Self-bootstrapping graphic design tool on Lisp. Live Demo
mal2py-compiler - MAL-to-Python. A fork of the python3 implementation that compiles mal to python with a 16x performance improvement on the perf3 synthetic benchmark.
Implementation Details
Ada
The Ada implementation was developed with GNAT 4.9 on debian. It also
compiles unchanged on windows if you have windows versions of git,
GNAT and (optionally) make. There are no external dependencies
(readline not implemented).
cd impls/ada
make
./stepX
Read the full README on GitHubWhat Hacker News says
7 sources> This is a property of System F, the core itself, which is quite well established.
So when I repeatedly asked for the aspect of the language design that guaranteed this safety, and you responded with "the design guarantees it", you meant polymorphic lambda calculus, that, as it lacks infinite terms, preventing the creation of recursion through unfolding.
Clearly stating the reliance of System F would go some way towards generating trust in the definition of the language.
> There is no scientific debate to be had about this, anymore than there is a scientific "debate" about what temperature water boils at.
A language is considered to be Turing complete if it can calculate any computable value that a Turing machine can.
Brainfuck was proven to be Turing complete by Muller, and languages such as Piet have proven their own completeness by em
Read the rest
ulating or translating arbitrary Brainfuck programs.
So, I'm afraid the question in regards to the CPP, is only is limited recursion acceptable for Turing completeness?
The Turing-Church thesis specifically states that it should ignore resource limitations, which leads to the question of whether the limited recursion is a result of available resource or the language at hand.
There are active debates on this topic, and it cannot be so readily dismissed.
However, the point I raised with this, is the claimed safety of Dhall, in that it doesn't guarantee timely normalisation of its terms.
Which I believe you may have also noticed. [0]
> much like you're unlikely to write a Dhall configuration which takes 10 years to reduce when evaluated.
True, however the guarantee of evaluation safety is false.
There is no safety there when you can run out the available resource, such as time.
And people do insane, unlikely things with a language, such as breaching the type safety of Scala, and in response, they developed DOT calculus, so that they might give those guarantees.
Trusting a programmer not to do something stupid, is often the wrong thing to do. [1]
There is a line which must be drawn, but you can't make guarantees that mislead the programmer to feel safe.
[0] https://github.com/Gabriel439/Haskell-Dhall-Library/issues/6
[1] https://github.com/kanaka/mal/tree/master/awk
For anyone wanting to try something similar yourself, I highly recommend MAL. It's a Lisp dialect designed to be a learning tool: there's a nice guide for implementing the interpreter. It doesn't take much away from the learning, but it really lessens the possible frustration a lot.
https://github.com/kanaka/mal/blob/master/process/guide.md
Just in case anyone is interested, here's my implementation in Python 3.5+. I'm guessing it took me about 15 hours to write.
https://github.com/dancek/mal/tree/python3-dancek/python3-da...
Of course, Peter Norvig's followup to the linked article may also interest anyone who read this far:
http://norvig.com/lispy2.html
In How to Write a Lisp Interpreter in Python (2010)I highly recommend Make-a-lisp for anyone interested in a superficial understanding of writing a compiler. It's a very guided tour, but touches on a lot of very interesting parts of parsing, code generation, and optimization.
https://github.com/kanaka/mal/blob/master/process/guide.md
In Rich Programmer Food (2007)Useful for getting started: https://github.com/kanaka/mal
In Ask HN: What are some rite-of-passage style projects for programmers?