HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
kanaka
mal
Assembly2015–2026
REPOSITORY AT A GLANCE

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 9–Nov 16 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/16/2026, 4:59:52 AM 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.

051015202015-01-01 00:00:00 UTC to 2016-01-01 00:00:00 UTC (exclusive): 18 mentions; 1 submissions, 17 comments20152016-01-01 00:00:00 UTC to 2017-01-01 00:00:00 UTC (exclusive): 7 mentions; 2 submissions, 5 comments2017-01-01 00:00:00 UTC to 2018-01-01 00:00:00 UTC (exclusive): 19 mentions; 2 submissions, 17 comments2018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 6 mentions; 2 submissions, 4 comments2019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 11 mentions; 2 submissions, 9 comments2020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 15 mentions; 0 submissions, 15 comments20202021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 17 mentions; 2 submissions, 15 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 15 mentions; 0 submissions, 15 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 7 mentions; 0 submissions, 7 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 7 mentions; 1 submissions, 6 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 3 mentions; 0 submissions, 3 comments2026-01-01 00:00:00 UTC to 2027-01-01 00:00:00 UTC (exclusive): 3 mentions; 1 submissions, 2 comments. Incomplete calendar period.2026*

* 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
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20152015-01-01 00:00:00 UTC2016-01-01 00:00:00 UTC18117
20162016-01-01 00:00:00 UTC2017-01-01 00:00:00 UTC725
20172017-01-01 00:00:00 UTC2018-01-01 00:00:00 UTC19217
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC624
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC1129
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC15015
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC17215
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC15015
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC707
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC716
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC303
2026 (partial)2026-01-01 00:00:00 UTC2027-01-01 00:00:00 UTC312

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 GitHub

What Hacker News says

15 sources
For me it was the "Make a Lisp" project. Reading the architectural diagram of a Lisp interpreter, and browsing its implementation in many (~87) programming languages. https://github.com/kanaka/mal Especially where the guide explains how tail-call optimization works, my mind was blown. https://github.com/kanaka/mal/blob/master/process/guide.md#s... Studying the project changed the way I understand code. Since then I've created my own little Lisps in about three or four versions/languages. Next I'd like to write one in WebAssembly Text format, which is already in a Lisp-shaped syntax.
In Ask HN: What piece of code/codebase blew your mind when you saw it?
In a similar line as the posted project TinyLisp, I'd like to mention uLisp. Lisp for microcontrollers - Arduino, Adafruit M0/M4, Micro:bit, ESP8266/32, RISC-V, and Teensy 4.x boards - http://www.ulisp.com/ In particular, its smallest variant (~800 LoC). > uLisp Zero is a pared-down version of uLisp, capable of running in 8 Kbytes of program memory with 1 Kbyte of RAM https://github.com/technoblogy/ulisp-zero/blob/master/uLispZ... --- And I can't help but mention Make-a-Lisp and its C implementation (~350 lines). https://github.com/kanaka/mal/blob/master/impls/c/stepA_mal....
In Lisp in 99 lines of C and how to write one yourself [pdf]
Here's how I did it, I would say it's solid, approachable, and enjoyable: Go through the first half of Crafting Interpreters [0]. And then try to complete mal - Make a Lisp [1]. That's it. You'll only need these two. P.S. People also say good things about Build Your Own Lisp [2], but I didn't finish it because I find spending quite some time writing C doesn't make me feel I'm enjoying something elegant. [0]: https://craftinginterpreters.com/ [1]: https://github.com/kanaka/mal [2]: https://buildyourownlisp.com/
In Ask HN: What does a developer need to know to build their own Lisp from scratch?
Also see Make a Lisp - a build a lisp project that has a specific section on tail recursion [0]. When I went through the MAL process, TCO was actually one of the more straight forward sections (compared with say macros). The basic idea is quite simple - take your eval function and wrap it's body in a loop. For several of the special forms, instead of recursing into eval, rebind eval's arguments and go back round the loop. Forms where something is done after the call to eval still have to recurse, but they are actually in the minority. [0] https://github.com/kanaka/mal/blob/master/process/guide.md#s...
In Llisp: Lisp in Lisp
Writing a Lisp interpreter in C/C++ is cheating. You get readable code and a standard library for free. Don't get me wrong, it's surely fun, but if you really wanna learn about things, you need to write a Lisp interpreter in Assembly. It's a much more satisfying experience. Jokes aside, I'm hoping the author continues to feel free to spend their time implementing whatever idea they come across that is interesting. Sure, it's not as advanced as implementing something in C/C++, but maybe the authors goal was just to understand their preferred lisp (Clojure) better, rather than trying to understand C/C++ better? > Bonus points if you get to optimize tail recursion. (I didn't, but I didn't try to, so I don't consider it a failure.) Is this as complicated as people put it? I've never implemented my own lisp, but MAL (https://github.com/kanaka/
Read the rest
mal) makes it seem like a relatively easy step in the process.
In Llisp: Lisp in Lisp
No questions (yet) but I found this a really good post. I'm a Rust newbie and I've coincidentally just started working through 'Crafting Interpreters' using Rust as my implementation language. Some of your code has helped clarify things in my mind. My actual long-term goal is to build a VM in Rust and then use this to re-do the Make A Lisp project [0]. I completed this a couple of years ago using C# but felt vaguely uneasy that I was using C# to do the heavy lifting associated with garbage collection, etc. [0] https://github.com/kanaka/mal
In Writing a minimal Lua implementation with a virtual machine from scratch in Rust

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.