## Description
-Mal is a Clojure inspired Lisp interpreter.
-
-Mal is implemented in 69 languages:
-
-* Ada
-* GNU awk
-* Bash shell
-* BASIC (C64 and QBasic)
-* C
-* C++
-* C#
-* ChucK
-* Common Lisp
-* Clojure (Clojure and ClojureScript)
-* CoffeeScript
-* Crystal
-* D
-* Dart
-* Elixir
-* Elm
-* Emacs Lisp
-* Erlang
-* ES6 (ECMAScript 6 / ECMAScript 2015)
-* F#
-* Factor
-* Forth
-* Go
-* Groovy
-* GNU Guile
-* GNU Smalltalk
-* Haskell
-* Haxe (Neko, Python, C++ and JavaScript)
-* Io
-* Java
-* JavaScript ([Online Demo](http://kanaka.github.io/mal))
-* Julia
-* Kotlin
-* LiveScript
-* Logo
-* Lua
-* GNU Make
-* mal itself
-* Matlab (GNU Octave and MATLAB)
-* [miniMAL](https://github.com/kanaka/miniMAL)
-* Nim
-* Object Pascal
-* Objective C
-* OCaml
-* Perl
-* Perl 6
-* PHP
-* Picolisp
-* PL/pgSQL (Postgres)
-* PL/SQL (Oracle)
-* Postscript
-* PowerShell
-* Python (2.X and 3.X)
-* RPython
-* R
-* Racket
-* Rexx
-* Ruby
-* Rust
-* Scala
-* Scheme (R7RS)
-* Skew
-* Swift
-* Swift 3
-* Tcl
-* TypeScript
-* VHDL
-* Vimscript
-* Visual Basic.NET
-
-
-Mal is a learning tool. See the [make-a-lisp process
-guide](process/guide.md). Each implementation of mal is separated into
+**1. Mal is a Clojure inspired Lisp interpreter**
+
+**2. Mal is implemented in 76 languages (77 different implementations and 98 runtime modes)**
+
+| Language | Creator |
+| -------- | ------- |
+| [Ada](#ada) | [Chris Moore](https://github.com/zmower) |
+| [Ada #2](#ada2) | [Nicolas Boulenguez](https://github.com/asarhaddon) |
+| [GNU Awk](#gnu-awk) | [Miutsuru Kariya](https://github.com/kariya-mitsuru) |
+| [Bash 4](#bash-4) | [Joel Martin](https://github.com/kanaka) |
+| [BASIC](#basic-c64-and-qbasic) (C64 & QBasic) | [Joel Martin](https://github.com/kanaka) |
+| [C](#c) | [Joel Martin](https://github.com/kanaka) |
+| [C++](#c-1) | [Stephen Thirlwall](https://github.com/sdt) |
+| [C#](#c-2) | [Joel Martin](https://github.com/kanaka) |
+| [ChucK](#chuck) | [Vasilij Schneidermann](https://github.com/wasamasa) |
+| [Clojure](#clojure) (Clojure & ClojureScript) | [Joel Martin](https://github.com/kanaka) |
+| [CoffeeScript](#coffeescript) | [Joel Martin](https://github.com/kanaka) |
+| [Common Lisp](#common-lisp) | [Iqbal Ansari](https://github.com/iqbalansari) |
+| [Crystal](#crystal) | [Linda_pp](https://github.com/rhysd) |
+| [D](#d) | [Dov Murik](https://github.com/dubek) |
+| [Dart](#dart) | [Harry Terkelsen](https://github.com/hterkelsen) |
+| [Elixir](#elixir) | [Martin Ek](https://github.com/ekmartin) |
+| [Elm](#elm) | [Jos van Bakel](https://github.com/c0deaddict) |
+| [Emacs Lisp](#emacs-lisp) | [Vasilij Schneidermann](https://github.com/wasamasa) |
+| [Erlang](#erlang) | [Nathan Fiedler](https://github.com/nlfiedler) |
+| [ES6](#es6-ecmascript-2015) (ECMAScript 2015) | [Joel Martin](https://github.com/kanaka) |
+| [F#](#f) | [Peter Stephens](https://github.com/pstephens) |
+| [Factor](#factor) | [Jordan Lewis](https://github.com/jordanlewis) |
+| [Fantom](#fantom) | [Dov Murik](https://github.com/dubek) |
+| [Forth](#forth) | [Chris Houser](https://github.com/chouser) |
+| [GNU Guile](#gnu-guile-21) | [Mu Lei](https://github.com/NalaGinrut) |
+| [GNU Smalltalk](#gnu-smalltalk) | [Vasilij Schneidermann](https://github.com/wasamasa) |
+| [Go](#go) | [Joel Martin](https://github.com/kanaka) |
+| [Groovy](#groovy) | [Joel Martin](https://github.com/kanaka) |
+| [Haskell](#haskell) | [Joel Martin](https://github.com/kanaka) |
+| [Haxe](#haxe-neko-python-c-and-javascript) (Neko, Python, C++, & JS) | [Joel Martin](https://github.com/kanaka) |
+| [Hy](#hy) | [Joel Martin](https://github.com/kanaka) |
+| [Io](#io) | [Dov Murik](https://github.com/dubek) |
+| [Java](#java-17) | [Joel Martin](https://github.com/kanaka) |
+| [JavaScript](#javascriptnode) ([Demo](http://kanaka.github.io/mal)) | [Joel Martin](https://github.com/kanaka) |
+| [Julia](#julia) | [Joel Martin](https://github.com/kanaka) |
+| [Kotlin](#kotlin) | [Javier Fernandez-Ivern](https://github.com/ivern) |
+| [LiveScript](#livescript) | [Jos van Bakel](https://github.com/c0deaddict) |
+| [Logo](#logo) | [Dov Murik](https://github.com/dubek) |
+| [Lua](#lua) | [Joel Martin](https://github.com/kanaka) |
+| [GNU Make](#gnu-make-381) | [Joel Martin](https://github.com/kanaka) |
+| [mal itself](#mal) | [Joel Martin](https://github.com/kanaka) |
+| [MATLAB](#matlab-gnu-octave-and-matlab) (GNU Octave & MATLAB) | [Joel Martin](https://github.com/kanaka) |
+| [miniMAL](#minimal) ([Repo](https://github.com/kanaka/miniMAL), [Demo](https://kanaka.github.io/miniMAL/)) | [Joel Martin](https://github.com/kanaka) |
+| [NASM](#nasm) | [Ben Dudson](https://github.com/bendudson) |
+| [Nim](#nim-0170) | [Dennis Felsing](https://github.com/def-) |
+| [Object Pascal](#object-pascal) | [Joel Martin](https://github.com/kanaka) |
+| [Objective C](#objective-c) | [Joel Martin](https://github.com/kanaka) |
+| [OCaml](#ocaml-4010) | [Chris Houser](https://github.com/chouser) |
+| [Perl](#perl-58) | [Joel Martin](https://github.com/kanaka) |
+| [Perl 6](#perl-6) | [Hinrik Örn Sigurðsson](https://github.com/hinrik) |
+| [PHP](#php-53) | [Joel Martin](https://github.com/kanaka) |
+| [Picolisp](#picolisp) | [Vasilij Schneidermann](https://github.com/wasamasa) |
+| [PL/pgSQL](#plpgsql-postgres-sql-procedural-language) (Postgres) | [Joel Martin](https://github.com/kanaka) |
+| [PL/SQL](#plsql-oracle-sql-procedural-language) (Oracle) | [Joel Martin](https://github.com/kanaka) |
+| [PostScript](#postscript-level-23) | [Joel Martin](https://github.com/kanaka) |
+| [PowerShell](#powershell) | [Joel Martin](https://github.com/kanaka) |
+| [Python](#python-2x-and-3x) (2.X & 3.X) | [Joel Martin](https://github.com/kanaka) |
+| [RPython](#rpython) | [Joel Martin](https://github.com/kanaka) |
+| [R](#r) | [Joel Martin](https://github.com/kanaka) |
+| [Racket](#racket-53) | [Joel Martin](https://github.com/kanaka) |
+| [Rexx](#rexx) | [Dov Murik](https://github.com/dubek) |
+| [Ruby](#ruby-19) | [Joel Martin](https://github.com/kanaka) |
+| [Rust](#rust-100-nightly) | [Joel Martin](https://github.com/kanaka) |
+| [Scala](#scala) | [Joel Martin](https://github.com/kanaka) |
+| [Scheme (R7RS)](#scheme-r7rs) | [Vasilij Schneidermann](https://github.com/wasamasa) |
+| [Skew](#skew) | [Dov Murik](https://github.com/dubek) |
+| [Swift 2](#swift) | [Keith Rollin](https://github.com/keith-rollin) |
+| [Swift 3](#swift-3) | [Joel Martin](https://github.com/kanaka) |
+| [Swift 4](#swift-4) | [陆遥](https://github.com/LispLY) |
+| [Tcl](#tcl-86) | [Dov Murik](https://github.com/dubek) |
+| [TypeScript](#typescript) | [Masahiro Wakame](https://github.com/vvakame) |
+| [Vala](#vala) | [Simon Tatham](https://github.com/sgtatham) |
+| [VHDL](#vhdl) | [Dov Murik](https://github.com/dubek) |
+| [Vimscript](#vimscript) | [Dov Murik](https://github.com/dubek) |
+| [Visual Basic.NET](#visual-basicnet) | [Joel Martin](https://github.com/kanaka) |
+| [WebAssembly](#webassembly-wasm) (wasm) | [Joel Martin](https://github.com/kanaka) |
+| [Yorick](#yorick) | [Dov Murik](https://github.com/dubek) |
+
+
+**3. 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).
+(running the mal implementation of mal). See the [make-a-lisp process
+guide](process/guide.md).
-The mal (make a lisp) steps are:
+The make-a-lisp steps are:
* [step0_repl](process/guide.md#step0)
* [step1_read_print](process/guide.md#step1)
* [step9_try](process/guide.md#step9)
* [stepA_mal](process/guide.md#stepA)
+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 diagram for [step A](process/guide.md#stepA):
-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](https://www.youtube.com/watch?v=lgyOAiRtZGw),
-[Slides](http://kanaka.github.io/midwest.io.mal/). More recently
-Joel gave a presentation on "Make Your Own Lisp Interpreter in
-10 Incremental Steps" at LambdaConf 2016: [Part
-1](https://www.youtube.com/watch?v=jVhupfthTEk), [Part
-2](https://www.youtube.com/watch?v=X5OQBMGpaTU),
-[Slides](http://kanaka.github.io/lambdaconf/).
+
If you are interesting in creating a mal implementation (or just
interested in using mal for something), please drop by the #mal
guide](process/guide.md) there is also a [mal/make-a-lisp
FAQ](docs/FAQ.md) where I attempt to answer some common questions.
+
+## 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](https://www.youtube.com/watch?v=lgyOAiRtZGw),
+[Slides](http://kanaka.github.io/midwest.io.mal/).
+
+More recently Joel gave a presentation on "Make Your Own Lisp Interpreter
+in 10 Incremental Steps" at LambdaConf 2016:
+[Part 1](https://www.youtube.com/watch?v=jVhupfthTEk),
+[Part 2](https://www.youtube.com/watch?v=X5OQBMGpaTU),
+[Part 3](https://www.youtube.com/watch?v=6mARZzGgX4U),
+[Part 4](https://www.youtube.com/watch?v=dCO1SYR5kDU),
+[Slides](http://kanaka.github.io/lambdaconf/).
+
## 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 convenience
+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"
```
+## External Implementations
-### Ada
+The following implementations are maintained as separate projects:
+
+### HolyC
+
+* [by Alexander Bagnalla](https://github.com/bagnalla/holyc_mal)
+
+### Rust
+
+* [by Tim Morgan](https://github.com/seven1m/mal-rust)
+* [by vi](https://github.com/vi/mal-rust-vi) - using [Pest](https://pest.rs/) grammar, not using typical Mal infrastructure (cargo-ized steps and built-in converted tests).
+
+
+## Other mal Projects
+
+ * [malc](https://github.com/dubek/malc) - Mal (Make A Lisp) compiler. Compiles a Mal program to LLVM assembly language, then binary.
+ * [malcc](https://git.sr.ht/~tim/malcc) (@seven1m) - 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"](https://mpov.timmorgan.org/i-built-a-lisp-compiler/) post about the process.
+ * [frock](https://github.com/chr15m/frock) - Clojure-flavoured PHP. Uses mal/php to run programs.
-*The Ada implementation was created by [Chris Moore](https://github.com/zmower)*
+
+## 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,
./stepX_YYY
```
-### GNU awk
+### Ada.2
-*The GNU awk implementation was created by [Miutsuru kariya](https://github.com/kariya-mitsuru)*
+The second Ada implementation was developed with GNAT 8 and links with
+the GNU readline library.
+
+```
+cd ada
+make
+./stepX_YYY
+```
+
+### GNU awk
The GNU awk implementation of mal has been tested with GNU awk 4.1.1.
### C++
-*The C++ implementation was created by [Stephen Thirlwall (sdt)](https://github.com/sdt)*
-
The C++ implementation of mal requires g++-4.9 or clang++-3.5 and
a readline compatible library to build. See the `cpp/README.md` for
more details:
### ChucK
-*The ChucK implementation was created by [Vasilij Schneidermann](https://github.com/wasamasa)*
-
The ChucK implementation has been tested with ChucK 1.3.5.2.
```
./run
```
-### Common Lisp
-
-*The Common Lisp implementation was created by [Iqbal Ansari](https://github.com/iqbalansari)*
-
-The implementation has been tested with SBCL, CCL, CMUCL, GNU CLISP, ECL and
-Allegro CL on Ubuntu 16.04 and Ubuntu 12.04, see
-the [README][common-lisp/README.org] for more details. Provided you have the
-dependencies mentioned installed, do the following to run the implementation
-
-```
-cd common-lisp
-make
-./run
-```
-
### Clojure
For the most part the Clojure implementation requires Clojure 1.5,
coffee ./stepX_YYY
```
-### Crystal
+### Common Lisp
+
+The implementation has been tested with SBCL, CCL, CMUCL, GNU CLISP, ECL and
+Allegro CL on Ubuntu 16.04 and Ubuntu 12.04, see
+the [README](common-lisp/README.org) for more details. Provided you have the
+dependencies mentioned installed, do the following to run the implementation
-*The Crystal implementation of mal was created by [Linda_pp](https://github.com/rhysd)*
+```
+cd common-lisp
+make
+./run
+```
-The Crystal implementation of mal has been tested with Crystal 0.18.4.
+### Crystal
+
+The Crystal implementation of mal has been tested with Crystal 0.26.1.
```
cd crystal
### D
-*The D implementation was created by [Dov Murik](https://github.com/dubek)*
-
The D implementation of mal was tested with GDC 4.8. It requires the GNU
readline library.
### Dart
-*The Dart implementation was created by [Harry Terkelsen](https://github.com/hterkelsen)*
-
The Dart implementation has been tested with Dart 1.20.
```
### Emacs Lisp
-*The Emacs Lisp implementation was created by [Vasilij Schneidermann](https://github.com/wasamasa)*
-
The Emacs Lisp implementation of mal has been tested with Emacs 24.3
and 24.5. While there is very basic readline editing (`<backspace>`
and `C-d` work, `C-c` cancels the process), it is recommended to use
### Elixir
-*The Elixir implementation was created by [Martin Ek (ekmartin)](https://github.com/ekmartin)*
-
The Elixir implementation of mal has been tested with Elixir 1.0.5.
```
### Elm
-*The Elm implementation was created by [Jos van Bakel](https://github.com/c0deaddict)*
-
The Elm implementation of mal has been tested with Elm 0.18.0
```
### Erlang
-*The Erlang implementation was created by [Nathan Fiedler (nlfiedler)](https://github.com/nlfiedler)*
-
The Erlang implementation of mal requires [Erlang/OTP R17](http://www.erlang.org/download.html)
and [rebar](https://github.com/rebar/rebar) to build.
./stepX_YYY
```
-### ES6 (ECMAScript 6 / ECMAScript 2015)
+### ES6 (ECMAScript 2015)
-The ES6 implementation uses the [babel](https://babeljs.io) compiler
-to generate ES5 compatible JavaScript. The generated code has been
-tested with Node 0.12.4.
+The ES6 / ECMAScript 2015 implementation uses the
+[babel](https://babeljs.io) compiler to generate ES5 compatible
+JavaScript. The generated code has been tested with Node 0.12.4.
```
cd es6
### F# ###
-*The F# implementation was created by [Peter Stephens (pstephens)](https://github.com/pstephens)*
-
The F# implementation of mal has been tested on Linux using the Mono
F# compiler (fsharpc) and the Mono runtime (version 3.12.1). The mono C#
compiler (mcs) is also necessary to compile the readline dependency. All are
### Factor
-*The Factor implementation was created by [Jordan Lewis (jordanlewis)](https://github.com/jordanlewis)*
-
The Factor implementation of mal has been tested with Factor 0.97
([factorcode.org](http://factorcode.org)).
FACTOR_ROOTS=. factor -run=stepX_YYY
```
-### Forth
+### Fantom
-*The Forth implementation was created by [Chris Houser (chouser)](https://github.com/chouser)*
+The Fantom implementation of mal has been tested with Fantom 1.0.70.
+
+```
+cd fantom
+make lib/fan/stepX_YYY.pod
+STEP=stepX_YYY ./run
+```
+
+### Forth
```
cd forth
gforth stepX_YYY.fs
```
+### GNU Guile 2.1+
+
+```
+cd guile
+guile -L ./ stepX_YYY.scm
+```
+
+### GNU Smalltalk
+
+The Smalltalk implementation of mal has been tested with GNU Smalltalk 3.2.91.
+
+```
+cd gnu-smalltalk
+./run
+```
+
### Go
The Go implementation of mal requires that go is installed on on the
groovy ./stepX_YYY.groovy
```
-### GNU Guile 2.1+
-
-*The Guile implementation was created by [Mu Lei (NalaGinrut)](https://github.com/NalaGinrut).*
-
-```
-cd guile
-guile -L ./ stepX_YYY.scm
-```
-
-### GNU Smalltalk
-
-*The Smalltalk implementation was created by [Vasilij Schneidermann](https://github.com/wasamasa)*
-
-The Smalltalk implementation of mal has been tested with GNU Smalltalk 3.2.91.
-
-```
-cd gst
-./run
-```
-
### Haskell
The Haskell implementation requires the ghc compiler version 7.10.1 or
node ./stepX_YYY.js
```
-### Io
+### Hy
+
+The Hy implementation of mal has been tested with Hy 0.13.0.
-*The Io implementation was created by [Dov Murik](https://github.com/dubek)*
+```
+cd hy
+./stepX_YYY.hy
+```
+
+### Io
The Io implementation of mal has been tested with Io version 20110905.
### Kotlin
-*The Kotlin implementation was created by [Javier Fernandez-Ivern](https://github.com/ivern)*
-
The Kotlin implementation of mal has been tested with Kotlin 1.0.
```
### LiveScript
-*The LiveScript implementation was created by [Jos van Bakel](https://github.com/c0deaddict)*
-
The LiveScript implementation of mal has been tested with LiveScript 1.5.
```
### Logo
-*The Logo implementation was created by [Dov Murik](https://github.com/dubek)*
-
The Logo implementation of mal has been tested with UCBLogo 6.0.
```
### Lua
-Running the Lua implementation of mal requires lua 5.1 or later,
-luarocks and the lua-rex-pcre library installed.
+The Lua implementation of mal has been tested with Lua 5.2. The
+implementation requires that luarocks and the lua-rex-pcre library
+are installed.
```
cd lua
make -f stepX_YYY.mk
```
-### Nim 0.17.0
+### NASM
-*The Nim implementation was created by [Dennis Felsing (def-)](https://github.com/def-)*
+The NASM implementation of mal is written for x86-64 Linux, and has been tested
+with Linux 3.16.0-4-amd64 and NASM version 2.11.05.
+
+```
+cd nasm
+make
+./stepX_YYY
+```
+
+### Nim 0.17.0
The Nim implementation of mal has been tested with Nim 0.17.0.
### OCaml 4.01.0
-*The OCaml implementation was created by [Chris Houser (chouser)](https://github.com/chouser)*
-
```
cd ocaml
make
./stepX_YYY
```
-### MatLab (GNU Octave and MATLAB)
+### MATLAB (GNU Octave and MATLAB)
The MatLab implementation has been tested with GNU Octave 4.2.1.
It has also been tested with MATLAB version R2014a on Linux. Note that
### Perl 6
-*The Perl 6 implementation was created by [Hinrik Örn Sigurðsson](https://github.com/hinrik)*
-
The Perl 6 implementation was tested on Rakudo Perl 6 2016.04.
```
### Picolisp
-*The Picolisp implementation was created by [Vasilij Schneidermann](https://github.com/wasamasa)*
-
The Picolisp implementation requires libreadline and Picolisp 3.1.11
or later.
```
-cd pil
+cd picolisp
./run
```
### Rexx
-*The Rexx implementation was created by [Dov Murik](https://github.com/dubek)*
-
The Rexx implementation of mal has been tested with Regina Rexx 3.6.
```
### Scheme (R7RS) ###
-*The Scheme implementation was created by [Vasilij Schneidermann](https://github.com/wasamasa)*
-
The Scheme implementation of mal has been tested with Chibi-Scheme
0.7.3, Kawa 2.4, Gauche 0.9.5, CHICKEN 4.11.0, Sagittarius 0.8.3,
Cyclone 0.6.3 (Git version) and Foment 0.4 (Git version). You should
### Skew ###
-*The Skew implementation was created by [Dov Murik](https://github.com/dubek)*
-
The Skew implementation of mal has been tested with Skew 0.7.42.
```
### Swift
-*The Swift implementation was created by [Keith Rollin](https://github.com/keith-rollin)*
-
The Swift implementation of mal requires the Swift 2.0 compiler (XCode
7.0) to build. Older versions will not work due to changes in the
language and standard library.
./stepX_YYY
```
-### Tcl 8.6
+### Swift 4
-*The Tcl implementation was created by [Dov Murik](https://github.com/dubek)*
+The Swift 4 implementation of mal requires the Swift 4.0 compiler. It
+has been tested with Swift 4.2.3 release.
+
+```
+cd swift4
+make
+./stepX_YYY
+```
+
+### Tcl 8.6
The Tcl implementation of mal requires Tcl 8.6 to run. For readline line
editing support, install tclreadline.
### TypeScript
-*The TypeScript implementation was created by [vvakame](https://github.com/vvakame)*
-
The TypeScript implementation of mal requires the TypeScript 2.2 compiler.
It has been tested with Node.js v6.
node ./stepX_YYY.js
```
-### VHDL
+### Vala
+
+The Vala implementation of mal has been tested with the Vala 0.40.8
+compiler. You will need to install `valac` and `libreadline-dev` or
+equivalent.
+
+```
+cd vala
+make
+./stepX_YYY
+```
-*The VHDL implementation was created by [Dov Murik](https://github.com/dubek)*
+### VHDL
The VHDL implementation of mal has been tested with GHDL 0.29.
### Vimscript
-*The Vimscript implementation was created by [Dov Murik](https://github.com/dubek)*
-
The Vimscript implementation of mal requires Vim 8.0 to run.
```
mono ./stepX_YYY.exe
```
+### WebAssembly (wasm) ###
+
+The WebAssembly implementation is written in
+[Wam](https://github.com/kanaka/wam) (WebAssembly Macro language) and
+runs under several different non-web embeddings (runtimes):
+node,
+[wasmtime](https://github.com/CraneStation/wasmtime),
+[wax](https://github.com/kanaka/wac),
+[wace](https://github.com/kanaka/wac),
+[warpy](https://github.com/kanaka/warpy).
+
+```
+cd wasm
+# node
+make wasm_MODE=node
+./run.js ./stepX_YYY.wasm
+# wasmtime
+make wasm_MODE=wasmtime
+wasmtime --dir=./ --dir=../ --dir=/ ./stepX_YYY.wasm
+# wax
+make wasm_MODE=wax
+wace ./stepX_YYY.wasm
+# wace
+make wasm_MODE=wace_libc
+wace ./stepX_YYY.wasm
+# warpy
+make wasm_MODE=warpy
+warpy --argv --memory-pages 256 ./stepX_YYY.wasm
+```
+
+### Yorick
+
+The Yorick implementation of mal was tested on Yorick 2.2.04.
+
+```
+cd yorick
+yorick -batch ./stepX_YYY.i
+```
+
## Running tests
+The top level Makefile has a number of useful targets to assist with
+implementation development and testing. The `help` target provides
+a list of the targets and options:
+
+```
+make help
+```
+
### Functional tests
The are over 600 generic functional tests (for all implementations)
a time to the implementation and compares the output/return value to
the expected output/return value.
-To simplify the process of running tests, a top level Makefile is
-provided with convenient test targets.
-
* To run all the tests across all implementations (be prepared to wait):
```
make "stats^js"
```
-* To report line and bytes statistics for general Lisp code (env, core
- and stepA):
-```
-make "stats-lisp^IMPL"
-
-# e.g.
-make "stats-lisp^js"
-```
-
## Dockerized testing
Every implementation directory contains a Dockerfile to create
**Notes**:
* Docker images are named *"kanaka/mal-test-IMPL"*
* JVM-based language implementations (Groovy, Java, Clojure, Scala):
- you will probably need to run these implementations once manually
- first (make DOCKERIZE=1 "repl^IMPL")before you can run tests because
+ you will probably need to run this command once manually
+ first `make DOCKERIZE=1 "repl^IMPL"` before you can run tests because
runtime dependencies need to be downloaded to avoid the tests timing
- out. These dependencies are download to dot-files in the /mal
+ out. These dependencies are downloaded to dot-files in the /mal
directory so they will persist between runs.
HCoop / jackhill / mal.git / blobdiff