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
Thanks to the author for an enjoyable intellectual journey, it's a wonderful series of articles. Having tried my hand at following the Make a Lisp project ¹, implementing an interpreter in a couple of languages, it's fascinating to see the process of designing the language and compiler from the ground up, discussing various tradeoffs for simplicity, reasons for internal data structure, etc. In fact, I think I'm learning more about C99 than Lisp - there's something about creating a language (or just following along like me), by necessity it leads to the foundations of computing/programming, the concepts that make up the basis of all languages. It's a perfect (meta)subject for an educational project. ¹ https://github.com/kanaka/mal
In Compiling a Lisp to x86-64: Let expressions
A few that come to mind: - Implementing small languages, and how it inevitably leads one to a deeper understanding of all the layers that make computing and programming possible - The Make-a-Lisp project and the language-agnostic conceptual design at the heart of it - https://github.com/kanaka/mal/blob/master/process/guide.md - Declarative nature of React (the view as function of state); using centralized unidirectional state management and actions - Test-driven (and, similarly, type-driven) development - TypeScript - Benefits and costs of type definitions, dynamic/gradual and structural typing; power of a language integrated with the editor environment - Virtual machines, QEMU, and later Docker - Commoditized, reproducible builds for applications and their environments - Build pipeline scripts
In Ask HN: As a developer what are your aha moments?
I approached this wondering if it would be somewhat like 'Make a Lisp' or similar [0], that as a competent programmer you could start within minutes of starting to read the instructions. It doesn't seem like that. I think this is because * it has comprehensive background for newbies (e.g. the idea of setting breakpoints in a debugger) * it is the accompaniment for a separate book * it has some serious background assumptions (e.g. you know calculus) * graphics programming is much, much harder than making a lisp. [0] https://github.com/kanaka/mal [Edit: formatting]
In Graphics Programming Projects
MAL - Make a Lisp [0]. This one has been discussed on HN before - its where I found it. I completed it last year (from Jan to May 2019) and ended up with Lisp-a-like interpreter written in C# that is sophisticated enough to self-host (i.e. it can interpret and run itself). I picked it up again when the lockdown started and I am now using it to re-implement some of the classic AI systems described in Paradigms of AI Programming [1]. I almost have Eliza (the first chatbot, from 1966!) running, which has necessitated some thinking because MAL is closer to Clojure than the Common Lisp used in PAIP. I'm also implementing what is in effect a standard library of useful MAL functions. What I got from MAL was much better knowledge of C#, better insights into the power of lisp-like languages, some intense satisfaction when I managed some of the mor
Read the rest
e complex stages, etc. MAL is progressive, supported by 100s of tests, and an amazing array of reference implementations in a huge number of different programming languages. [Edit] My side-project before MAL involved downloading the Unity game engine and using it to explore the different aspects of game development. I discovered that I really enjoyed asset creation and in particular lighting and shader design, and (long story short - totally bizarre trajectory) ended up creating a tutorial for the Octane render engine that has had actual sales! If I was going to look at games again I'd probably start with a simpler engine such as Godot [2] [0] https://github.com/kanaka/mal/blob/master/process/guide.md [1] https://github.com/norvig/paip-lisp [2] https://godotengine.org/
In Ask HN: Looking for side project ideas
I was speaking generally in terms of self learning in compilers. Your criticism was that the article focused too heavily on the front end and that the magic or the needed focus is on back end issues (scheduling, selection). I think there are a couple things in play here. Folks working with text, semi-structured data, synthesizing from disparate sources, etc will be front end heavy. Tokenization, lexing, is important outside of more than compilers, like loading binary formats from network or disk into memory. For backend work, being able to extend or modify existing backends is important for languages targeting different runtimes (Spark, Beam, Impala). This can be in targeting new architectures or for predicate pushdown into data processing pipelines. Lots of different applications to use those skills. Compilers and Database systems are an
Read the rest
incredible microcosm of many areas of CS. Areas of self study I think are nice are MAL - Make a Lisp https://github.com/kanaka/mal Nand2Tetris, project 11 https://www.nand2tetris.org/project11 (one should start from zero and make your way here, it is journey not a destination) An educational software system of a tiny self-compiling C compiler, a tiny self-executing RISC-V emulator, and a tiny self-hosting RISC-V hypervisor. http://selfie.cs.uni-salzburg.at LLVM is a huge system, libFirm is a much smaller, simpler system that includes a c front end. From their site > libFirm is a C library that provides a graph-based intermediate representation, optimizations, and assembly code generation suitable for use in compilers. https://pp.ipd.kit.edu/firm/
In So you want to be a compiler wizard (2016)
Maybe there was a clear separation 30 years ago, but there no longer is. The shortcut for the posts below is that you can write a Lisp in all of shell, awk, and make (and sed too) [1] I won't get to this in Oil (without help) but I still think it's valid. The languages have so much overlap that they should just be combined. Of course that's what Perl was (leaving out Make), but Raku and Python 3 seem to have left a hole in that design space. Shell, Awk, and Make Should Be Combined http://www.oilshell.org/blog/2016/11/13.html Example Code in Shell, Awk, and Make http://www.oilshell.org/blog/2016/11/14.html [1] https://github.com/kanaka/mal/tree/master/impls
In The growth of command-line options, 1979-Present
I couldn't agree more with this, it's very frustrating. I recently worked through most of the "make a lisp" guide [0], and it was excellent introduction to a simple lisp interpreter. But now I want to try my hand at a compiler (either producing machine code or maybe custom VM bytecode) and the lack of resources for that is bewildering. Just as you say, I've found that most online texts on compilers seem to spend most of their time on parsing, which is something I already feel relatively comfortable with. Does anyone know of a good resource on how to transform an AST to machine code? I've skimmed Crafting Interpreters and the Bytecode VM section seems to spend an inexplicable amount of time on not only parsing, but minutia having nothing to do with compilers (e.g. writing a custom dynamic array implementation in C). [0] https://github.com/
Read the rest
In C Compiler from Scratch

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.