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, 1:56:48 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

11 sources
A few things I did in the past I would definitely recommend: * Make a Lisp https://github.com/kanaka/mal — tutorial on how to make a lisp language interpreter. * Make an 8 bit computer https://eater.net/8bit — tutorial on making a simple 8 bit computer out of a bunch of AND, OR, NAND chips. Really helps you understand how computers work, what microcode is, etc. Honestly, building it wasn't quite as much fun as I thought it would be, but just learning how to build one was very useful.
In Challenging projects every programmer should try
Not a book, but an interesting self-guided course and apparently a great way to pick up a new language: Make A Lisp [0],[1],[2] Basically, work through building a lisp interpreter in any given language (C, Java,...bash, vimscript) in 10 steps. Each step is backed by tests, and these tests help to guide you through the process. Very cool. [0]http://kanaka.github.io/lambdaconf/ [1]https://github.com/kanaka/mal [2]https://www.youtube.com/watch?v=jVhupfthTEk
In Writing An Interpreter In Go (2016)
I ran into “Make Your Own Lisp Interpreter in 10 Steps”[0] recently, and I’ve enjoyed walking through it. It works through a basic repl to macros, tail recursion, and finally self hosting! (I haven’t made it that far yet) The guide [1] has been interesting to follow, and I appreciate the author’s approach to building a Lisp interpreter as a way to pick up a new language. For example, his interpreter, mal, has implementations in every thing from ada, nasm, and bash, to C, Ruby, rust, python and everything between. Videos walking through the guide are available too [2], [3] [0] https://github.com/kanaka/mal [1] https://github.com/kanaka/mal/blob/master/process/guide.md [2] https://www.youtube.com/watch?v=jVhupfthTEk [3] https://www.youtube.com/watch?v=X5OQBMGpaTU
In Building a Parser
nnadams·Oct 30, 2019Recommendation phrase
I used Nim for my implementation of Make A Lisp[1]. I use Python every day and the jump was pretty straightforward. Almost copy and paste from some things. I don't have to think about static types much, but it was a welcome change. I loved having macros to play with, too. I spent a lot of time with docs which aren't bad. As for the "mental capacity" I felt the same about finally getting into Rust. Spending some time with Nim actually helped me bridge the gap from Python to Rust. [1] https://github.com/kanaka/mal
In Nim: Scripting Ease in a Compiled Language
I'm currently working through the implementation of my own personal Lisp, following the awesome MAL process [0]. It's instructive to compare the result with the language as defined in the early 60s and available to programmers then (e.g. as defined by the Lisp manual referenced in the video). One thing that immediately stood out was the use of GOTO ('GO' actually) in the early Lisp rather than some sort of loop or tail recursion. Incidentally, I've been wondering what app I should write to test my Lisp. The obvious end-state mentioned in the MAL guide is to self-host a Lisp, but I'm thinking it would be more appropriate (and fun) to re-implement one of the early chatbots like ELIZA [1]. [0] https://github.com/kanaka/mal/blob/master/process/guide.md [1] https://en.wikipedia.org/wiki/ELIZA
In Let’s LISP like it’s 1959 [video]
I'm almost 60. I trained as a s/w engineer / coder in the 1980s and then transitioned in the 90s into a customer-facing consultancy role with good domain knowledge. Here are some specific observations on cognitive / corporate skills and how mine have varied, YMMV I definitely have more work 'wisdom' and can often spot problems that are not obvious to younger colleagues and even offer workable solutions, albeit not usually in the low level technologies. I have massively improved self-confidence that sometimes gets me through situations where my own knowledge / competencies are lacking. I can still learn, e.g. picking up C# and Visual Studio as a hobbyist to implement a Lisp interpreter [0] (I started six weeks ago and am on step 8 of 9 now, working on it in the evenings and rainy weekends). However, I think that it takes me longer to learn
Read the rest
than it would have done once. I am definitely slower at navigating user interfaces, especially jumping immediately to a specific but not often used menu item. Younger me would have gone straight there. Improved search tools / repositories of online information make up for poorer memory of language syntax and APIs. I don't now have access to the code I first wrote to check it's complexity. Looking at documents I wrote several years ago, I don't think my vocabulary and writing skills have declined significantly. I have to continually remind myself not to be too dogmatic, especially where my knowledge is potentially out of date, or where I realise that my improved self confidence is masking the fact that I am actually wrong. [0] https://github.com/kanaka/mal/blob/master/process/guide.md
In Our physiological processes become increasingly simple as we age

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.