Mal – Make a Lisp, implemented in 89 Languages
3 points · Open discussionkanaka
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 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 3:03:16 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
128 sourcesI've always found MAL ("Make-A-Lisp" https://github.com/kanaka/mal) a bit more approachable, probably because I was out after creating my own programming language before I've written much Python. It's language agnostic, and really easy to follow along with most programming languages out there, explaining everything as you progress.
That it's language agnostic and somehow matters feels weird now a lot of time (and experience I suppose) afterwards, but back when I only knew 1-2 languages by heart, also having to face understanding Python at the same time from Norvigs guide/reference made it slightly more complicated for me.
I use this as a litmus test now when coming across new languages (implementing MAL in the new language), as it's such an easy approach to practically test large parts of the new language, and there is always host-languag
Read the rest
e-specific tricks you can learn along the way.
Well there's Make a Lisp [0]. And Lispy [1] and Lispy2 and Lisp.py [3].
[0] https://github.com/kanaka/mal
[1] https://norvig.com/lispy.html
[2] https://norvig.com/lispy2.html
[3] https://khamidou.com/compilers/lisp.py
In Don't Build Your Own LispMAL is pretty good, albeit less hand-holding: https://github.com/kanaka/mal
Writing a Lisp in Ocaml: https://bernsteinbear.com/blog/lisp/00_fundamentals/
Not Lisp-specific but Crafting Interpreters is also great: https://craftinginterpreters.com/
In Build Your Own LispMAL, the original "make a lisp", is a bit terse on details but gives you freedom to use different languages, and yet still provide a rough blueprint:
https://github.com/kanaka/mal
Discussed here, a few times:
https://news.ycombinator.com/from?site=github.com/kanaka
In Build Your Own LispI think the best way to learn Lisp is to make a Lisp.
Two routes, I would recommend both.
https://github.com/kanaka/mal
https://t3x.org/
In Coding as Craft: Going Back to the Old GymThis is why the Lisp syntax is a great candidate for an exercise in making your own language. For example, Make a Lisp. https://github.com/kanaka/mal
It's simple to lex and parse into an abstract syntax tree, so you can get on with exploring more interesting aspects of programming beyond the mere syntax. (Not to say that there aren't interesting aspects of grammar and innovative syntax, but those can probably be explored later on as macros.)
Last time I created a toy language, I implemented a C-like infix syntax but still used a Lisp evaluator at its core from a previous project.
In What you learn by making a new programming languageThere's also Make-A-Lisp and, unlike most write-you-a-lisp/scheme-s out there, that one also covers TCO interpretation, quasiquotation/unquote for macros and their expansion, and goes up to self-hosting: https://github.com/kanaka/mal/
I just went through it over 2-3 days, great practice IMHO to do once in your life from start to finish: https://github.com/metaleap/go-lisp
In Show HN: Lisp in C#How does this compare with Make A Lisp [0]? Is it just that it's in C?
[0] https://github.com/kanaka/mal
In Build Your Own Lisp (2014)I’m not really sure how you would be able to write an interpreter without a parser, since you need to know what the user is trying to do. For a more complete tutorial there is Make-A-Lisp (mal) [0] that has steps for making a lisp in various (including JavaScript) and has a process guide [1] to get started.
[0] https://github.com/kanaka/mal
[1] https://github.com/kanaka/mal/blob/master/process/guide.md
In Roll A Lisp In C – Reading (2020)Make a Lisp: https://github.com/kanaka/mal
Make a Lisp is more Clojure-flavored than Common Lisp, but it might still be nice to examine because of how many different implementation languages it has been done in by various authors.
It also breaks down the implementation process into 11 distinct steps which are easy to understand.
In Ask HN: Guide for Implementing Common LispOne great way to learn Lisp is to write your own:
> The goal of the Make-A-Lisp project is to make it easy to write your own Lisp interpreter without sacrificing those many "Aha!" moments that come from ascending the McCarthy mountain. When you reach the peak of this particular mountain, you will have an interpreter for the mal Lisp language that is powerful enough to be self-hosting, meaning it will be able to run a mal interpreter written in mal itself.
~ https://github.com/kanaka/mal/blob/master/process/guide.md
https://github.com/kanaka/mal
In I accidentally a scheme>Would be interesting to see how the interpreter works actually...
It's quite easy to see, there are interpeters for Lisp in like 20 lines or so.
Here's a good one:
https://norvig.com/lispy.html
(It has the full code in a link towards the bottom)
There's also this:
https://github.com/kanaka/mal
> I would guess it checks what `defun` is, which is a macro...then expands it, and the expansion should ultimately result in an s-expression, which is then parses? Is this right?
Yes, but macros (like special forms, but macros can be user implementable) have some "special" powers regarding controlling the evaluation of the code they produce.
Here's some more discussion with examples:
https://stackoverflow.com/questions/42470940/how-is-the-defu...
In Ask HN: Is Lisp Simple?Showing the 15 most recent of 128 sources. Enable JavaScript to search and browse every indexed mention.