template: sort first table by interpreted lang

[skip ci]

README.md

@@ -5,246 +5,246 @@ The following is a list of reasonably mature open source [embedded scripting lan
 ## Contents
 
 - [Embedded scripting languages](#embedded-scripting-languages)
-  * [Sorted alphabetically](#sorted-alphabetically)
+  * [Sorted by interpreted language](#sorted-by-interpreted-language)
   * [Sorted by implementation language](#sorted-by-implementation-language)
   * [See also](#see-also)
   * [Contributing](#contributing)
   * [License](#license)
   * [Disclosure](#disclosure)
 
-## Sorted alphabetically
+## Sorted by interpreted language
 
-| Project name/link | Implementation language | GC | License | Notes |
-|-------------------|-------------------------|----|---------|-------|
-| [AbcDatalog](http://abcdatalog.seas.harvard.edu/) | Java | JVM's GC | 3-clause BSD | Implements Datalog. |
-| [AngelScript](http://www.angelcode.com/angelscript/) | C++ | Ref. counting + cycle-detecting tracing GC | zlib | A statically typed curly brace language resembling C++ itself. |
-| [Animula](https://gitlab.com/hardenedlinux/animula) | C | Tracing | Compiler **GPL 3+** while VM is LGPL 3+ | An optimizing compiler and VM for embedded systems. R7RS. |
-| [Anko](https://github.com/mattn/anko/) | Go | Go's GC | MIT | Scriptable interpreter with syntax similar to Go. |
-| [ArkScript](https://github.com/SuperFola/Ark) | C++ | None (resource release is destruction + optional manual MM) | MPL 2.0 | A small functional Lisp-like programming language. Separate bytecode compiler and VM. |
-| [Atlast](https://www.fourmilab.ch/atlast/) | C | None (manual MM) | Public domain | A dialect of Forth originally developed at Autodesk. |
-| [BeanShell](https://github.com/beanshell/beanshell/) | Java | JVM's GC | Apache License 2.0 | An small, embeddable Java source code interpreter. Understands Java code with certain extensions like method closures. |
-| [Boron](http://urlan.sourceforge.net/boron/) | C | Tracing | LGPL 3+ | An embeddable scripting language similar to Rebol. |
-| [Cascalog](https://github.com/nathanmarz/cascalog) | Clojure | JVM's GC | Apache License 2.0 | Implements Datalog. |
-| [ChaiScript](http://chaiscript.com/) | C++ | Ref. counting | 3-clause BSD | A header-only C++14 interpreter library. |
-| [Chibi Scheme](https://github.com/ashinn/chibi-scheme) | C | Tracing | 3-clause BSD | Implements R7RS small. |
-| [CHICKEN Scheme](https://call-cc.org/) | C | Tracing | 3-clause BSD | Implements R5RS (with some [changes](http://wiki.call-cc.org/man/4/Supported%20language)). R7RS support is a work in progress. [Examples of embedding CHICKEN](https://wiki.call-cc.org/embedding). |
-| [CircuitPython](https://github.com/adafruit/circuitpython) | C | Tracing | MIT | A fork of MicroPython, designed for API uniformity across many microcontrollers. |
-| [Clasp](https://github.com/drmeister/clasp) | Common Lisp, C++ | MPS GC (Boehm-Weiser also supported) | LGPL 2+ | Full Common Lisp implementation well integrated with C++, using LLVM for the code generation, to integrate closely with C++ applications or libraries. |
-| [daScript](https://dascript.org/) | C++ | None (region-based + manual MM?) | 3-clause BSD | A statically-typed [performance-oriented](https://dascript.org/#performance) scripting language. |
-| [Datalog (c-cube)](https://github.com/c-cube/datalog) | OCaml | OCaml's GC | 2-clause BSD | Implements Datalog. |
-| [Datalog (fogfish)](https://github.com/fogfish/datalog) | Erlang | None (no collection inside interpreter state) | Apache License 2.0 | Implements Datalog. |
-| [Datalog (MITRE Corporation)](http://datalog.sourceforge.net/) | C | Tracing (Lua's GC) | LGPL 2+ | Implements Datalog. It is implemented on top of Lua 5.3 and can be extended with Lua functions. |
-| [Dhall](https://dhall-lang.org/) | Haskell | Haskell's GC | 3-clause BSD | A statically-typed functional configuration language. Not Turing-complete. Untrusted code: can't access the file system, can fetch Dhall libraries over HTTP(S) from static URLs (but libraries aren't allowed to access your data), can use up memory and CPU time for a DoS attack. Has a work-in-progress Clojure and Ruby implementation. |
-| [Duktape](http://duktape.org/) | C | Ref. counting + cycle-detecting tracing GC | MIT | Implements JavaScript E5/E5.1. |
-| [DWScript](https://bitbucket.org/egrange/dwscript/) | Object Pascal (Delphi 2009 or later) | Ref. counting + cycle-detecting tracing GC | MPL 1.1, GPL 3 (JavaScript code generator) | [Description](https://www.delphitools.info/dwscript). A statically typed Delphi/Free Pascal-like language. Can compile to JavaScript. |
-| [Dyon](https://github.com/pistondevelopers/dyon) | Rust | None (Rust-style [lifetimes](http://www.piston.rs/dyon-tutorial/lifetimes.html)) | Apache License 2.0 or MIT | Has optional, optimistic (succeed-by-default) static type checking. |
-| [Embeddable Common Lisp](https://gitlab.com/embeddable-common-lisp/ecl) | Common Lisp, C | Boehm-Weiser GC | LGPL 2+ | Full Common Lisp implementation, available as a shared library `libecl.so` embeddable in any C, C++ or other application. |
-| [ephp](https://github.com/bragful/ephp) | Erlang | None (no collection inside interpreter state) | LGPL 2.1 | Implements a subset of PHP 5.5. |
-| [Erlog](https://github.com/rvirding/erlog) | Erlang | None () | Apache License 2.0 | Interprets a subset of standard Prolog. |
-| [Espruino](https://github.com/espruino/Espruino) | C | Tracing | MPL 2.0 | Implements a subset of JavaScript ES5 in a way suitable for embedded hardware with 8+ KiB RAM. |
-| [Expr](https://github.com/antonmedv/expr) | Go | Go's GC | MIT | Compiles and evaluates statically-typed expressions. |
-| [Falcon](http://falconpl.org/) | C++ | Tracing | **GPL 2** or custom | The GC is pluggable. |
-| [FTH](http://fth.sourceforge.net) | C | Tracing | 2-clause BSD | A dialect of Forth with objects, hashes, regular expressions, and other extensions. |
-| [GameMonkey Script](http://www.gmscript.com/) | C++ | Tracing | MIT | Comes with C bindings. Similar to Lua, multithreaded. |
-| [Gentee](https://github.com/gentee/gentee/) | Go | Go's GC | MIT | Statically typed. |
-| [gluon](https://github.com/gluon-lang/gluon) | Rust | Tracing | MIT | Statically typed. Inspired by Lua, Haskell, and OCaml. Each executing gluon thread gets a separate heap. |
-| [gmqcc/qcvm](https://github.com/graphitemaster/gmqcc) | C++ | None (no dynamic memory allocation) | MIT | A QuakeC compiler and VM. |
-| [GNU Guile](https://www.gnu.org/software/guile/) | C | [Boehm](https://www.gnu.org/software/guile/manual/html_node/Conservative-GC.html) | LGPL 3+ | ["Guile mostly implements R6RS."](https://www.gnu.org/software/guile/manual/guile.html#R6RS-Support) |
-| [Goja](https://github.com/dop251/goja) | Go | Go's GC | MIT | Implements ECMAScript 5.1. Better standard compliance and performance than otto. |
-| [Golog](https://github.com/mndrix/golog) | Go | Go's GC | MIT | Implements a subset of standard Prolog. |
-| [Go-Lua](https://github.com/Shopify/go-lua) | Go | Go's GC | MIT | Implements a subset of Lua 5.2. |
-| [GopherLua](https://github.com/yuin/gopher-lua) | Go | Go's GC | MIT | Implements Lua 5.1 with the added support for Go's channels. Lacks the debug hooks and several functions from the C version. |
-| [Gravity](https://github.com/marcobambini/gravity) | C | Tracing | MIT | A class-based concurrent scripting language with a Swift-like syntax. |
-| [Groovy](http://groovy-lang.org/) | Java | JVM's GC | Apache License 2.0 | A scripting language for the JVM. A large subset of Java is valid Groovy. [Integrating Groovy into applications](http://groovy-lang.org/integrating.html). |
-| [HAC](https://hacadacompiler.sourceforge.io/) | Ada | None (stack only) | MIT | HAC implements a subset of the Ada language. Thus, it can share sources with the embedding application. |
-| [HashLink](https://hashlink.haxe.org/) | C | Tracing (lazy sweep) | MIT | A bytecode interpreter and a baseline JIT compiler (x86/x86\_64 only) for [Haxe](https://haxe.org/). |
-| [Io](https://github.com/stevedekorte/io) | C | Tracing | 3-clause BSD | A prototype-based OO language. |
-| [Janet](https://janet-lang.org/) | C | Tracing | MIT | A functional and imperative language with a Lisp syntax. |
-| [JerryScript](https://github.com/jerryscript-project/jerryscript) | C | Tracing | Apache License 2.0 | A full ECMAScript 5.1 interpreter written in C99 and optimized for low memory consumption. Uses CMake. |
-| [Jim Tcl](http://jim.tcl-lang.org/) | C | Tracing | 2-clause BSD | Largely compatible with Tcl 8.5 with its own additions. |
-| [Jinx](https://jamesboer.github.io/Jinx/) | C++17 | Ref. counting | MIT | Designed for use in realtime applications such as video games. |
-| [JRuby](http://www.jruby.org/) | Java | JVM's GC | Choice of EPL, GPL, and LGPL | An implementation of Ruby on the JVM. |
-| [jsish](http://jsish.org/) | C | Ref. counting | MIT | A JavaScript ES 5.2+ interpreter. Internally structured after Tcl with an extensive C API. Features include subinterpreters, introspection, SQLite bindings, and a web framework with WebSocket support. The code is valid C and C++. |
-| [Jsonnet](https://jsonnet.org/) | C++ | Tracing | Apache License 2.0 | A functional configuration language that extends JSON. Untrusted code: can't access the file system or network, can use up memory and CPU time for a DoS attack. Has [bindings](https://jsonnet.org/ref/bindings.html) for C, C++, Go, Python, and other languages, as well as a separate native Go implementation. |
-| [JTcl](https://github.com/jtcl-project/jtcl) | Java | Ref. counting | Various BSD-like | Tcl 8.4 with some 8.5 features for the JVM. |
-| [Jython](http://www.jython.org/) | Java | JVM's GC | PSFL (BSD-like) | An implementation of Python on the JVM. |
-| [Kawa](https://www.gnu.org/software/kawa/) | Java | JVM's GC | MIT | R7RS. Supports the javax.script API. [Evaluating Scheme expressions from Java](https://www.gnu.org/software/kawa/Evaluating-Scheme-expressions-from-Java.html). |
-| [Ketos](https://github.com/murarth/ketos) | Rust | None (no heap allocation)? | Apache License 2.0 | A functional Lisp. |
-| [Libfawk](http://repo.hu/projects/libfawk/) | C | Ref. counting | 3-clause BSD | A multi-language VM. Includes compilers for three languages: Fawk (Awk dialect), Fbas (Basic dialect), and Fpas (Pascal dialect). |
-| [Libmawk](http://repo.hu/projects/libmawk/) | C | Ref. counting | **GPL 2** | Implements Awk. A fork of mawk 1.3 restructured for embedding. |
-| [LIL](http://runtimeterror.com/tech/lil/) | C, Object Pascal (separate implementations) | None (no reference support) | zlib | A Tcl-like language incompatible with mainline Tcl. |
-| [Lily](https://github.com/FascinatedBox/lily/) | C | Ref. counting + GC | MIT | A language focusing on expressiveness and safety. |
-| [ljs](https://github.com/mingodad/ljs) | C | Tracing | MIT | Lua 5.3, Lua 5.1, and LuaJIT with a C/C++/Java/JavaScript syntax. Can convert Lua source code to ljs. |
-| [Lua](http://lua.org/) | C | Tracing | MIT | The reference implementation of what is likely the world's most popular embedded scripting language. Allows you to precompile scripts to bytecode. Versions 5.1-5.3, which are the ones used today, are not fully compatible with each other. |
-| [LuaJ](https://sourceforge.net/projects/luaj/) | Java | JVM's GC | MIT | A Lua 5.2 spec-compliant interpreter written in Java for JME and JSE. Complies Lua directly to JVM bytecode. |
-| [LuaJIT](http://luajit.org/) | C | Tracing | MIT | Fully compatible with Lua 5.1. Has a built-in C FFI library. [Performance comparison](https://luajit.org/performance.html). |
-| [Lua-ML](https://github.com/lindig/lua-ml) | OCaml | OCaml's GC | 2-clause BSD | Embeddable Lua 2.5 reimplementation that integrates with OCaml type and module system. It's possible to extend or even replace the standard library with your own modules. |
-| [Luau](https://luau-lang.org/) | C | Tracing | MIT | Roblox [fork of Lua 5.1](https://luau-lang.org/why) as a scripting language for games to support a gradual type system as well as limiting the set of standard libraries exposed to the users and implements extra sandboxing features to be able to run unprivileged code. Whenever possible, Luau aims to be backwards-compatible with Lua 5.1 and at the same time to incorporate features from later revisions of Lua. |
-| [luerl](https://github.com/rvirding/luerl) | Erlang | Tracing | Apache License 2.0 | An implementation of Lua 5.2 in pure Erlang with some features like `goto` absent. |
-| [MicroPython](https://github.com/micropython/micropython) | C | Tracing | MIT | Implements the Python 3.4 syntax and some of the core datatypes. |
-| [Molt](https://github.com/wduquette/molt) | Rust | Ref. counting | 3-clause BSD | A minimal Tcl implementation for Rust applications and libraries. |
-| [Mond](https://github.com/Rohansi/Mond/) | C# | CLR's GC | MIT | A dynamically typed scripting language with generators, async, remote debugging, and a binding API. |
-| [Mono](http://www.mono-project.com/docs/advanced/embedding/scripting/) | C | Tracing | MIT and other | Implements the [CLR](https://en.wikipedia.org/wiki/Common_Language_Runtime). |
-| [MoonSharp](https://www.moonsharp.org/) | C# | CLR's GC | 3-clause BSD and other | CLR Based Lua implementation that is 99% compatible with Lua 5.2 |
-| [mruby](https://github.com/mruby/mruby) | C | Tracing | MIT | A lightweight implementation of Ruby. Has a compile-time package manager. |
-| [mruby/c](https://github.com/mrubyc/mrubyc) | C | Ref. counting | 3-clause BSD | An even smaller implementation of Ruby for microcontrollers with limited memory. |
-| [MuJS](https://mujs.com/) | C | Tracing | ISC | Implements JavaScript (ES5). Has a similar C interface to Lua. |
-| [MY-BASIC](https://github.com/paladin-t/my_basic) | C | Ref. counting + cycle-detecting tracing GC | MIT | A Basic dialect with prototype-based OOP. |
-| [Neko](http://nekovm.org/) | C | Boehm | MIT | The NekoVM is a target for several compilers, including [Haxe](http://haxe.org/). |
-| [NetRexx](http://www.netrexx.org/) | Java | JVM's GC | ICU (BSD-like) |  |
-| [Never](https://github.com/never-lang/never) | C | Tracing | MIT | A statically typed functional programming language. |
-| [njs](https://nginx.org/en/docs/njs/) | C | None (no collection performed) | 2-clause BSD | Implements a subset of ES5.1 with some ES6 extensions. |
-| [ooRexx](http://www.oorexx.org/) | C++ | Tracing | CPL | Implements Rexx extended with objects. |
-| [otto](https://github.com/robertkrimen/otto) | Go | Go's GC | MIT | Implements ES5 with [some limitations](https://github.com/robertkrimen/otto#caveat-emptor). |
-| [Pascal Script](http://www.remobjects.com/ps.aspx) | Object Pascal | None (manual MM) | modified zlib/libpng-License with mandatory attribution | Statically typed. Implements "most of Object Pascal". Can't define new classes. |
-| [Pawn](http://www.compuphase.com/pawn/pawn.htm) | C | None (no heap allocation) | Apache License 2.0 with a clause to explicitly permit static linking | A curly-brace language with a small-footprint VM. Represents data as 4/8-byte "cells". Compiles to CPU-specific bytecode. [More](https://wiki.alliedmods.net/Pawn_Tutorial#Language_Paradigms). |
-| [Perl](https://www.perl.org/) | C | Ref. counting | Artistic License or GPL 3 | [Embedding Perl in Another Application](https://perldoc.perl.org/perlembed) |
-| [pForth](http://www.softsynth.com/pforth/) | C | None (manual MM) | Public domain | A dialect of Forth. |
-| [PH7](https://github.com/symisc/PH7) | C | Ref. counting | **SPL** or proprietary | Implements a subset of PHP 5.3 with some changes like native UTF-8 support. |
-| [PicoC](https://github.com/zsaleeba/picoc) | C | None (manual MM) | 3-clause BSD | Statically typed. Interprets a subset of C. |
-| [Picol](https://chiselapp.com/user/dbohdan/repository/picol/) | C | None (no reference support) | 2-clause BSD | A header-only library interpreter for a limited dialect of Tcl. |
-| [pocketlang](https://github.com/ThakeeNathees/pocketlang) | C | Tracing | MIT | A small language syntactically similar to Ruby. [Embedding examples](https://github.com/ThakeeNathees/pocketlang/tree/master/tests/native/). [Performance comparison](https://github.com/ThakeeNathees/pocketlang#performance). |
-| [Python](https://www.python.org/) | C | Ref. counting + cycle-detecting tracing GC | PSFL (BSD-like) | [Embedding Python in Another Application](https://docs.python.org/3.5/extending/embedding.html). |
-| [QuickJS](https://bellard.org/quickjs/) | C | Ref. counting + cycle-detecting tracing GC | MIT | A small embedded JavaScript interpreter that implements almost all of ES2019 and much of ES2020. |
-| [Quirrel](https://github.com/GaijinEntertainment/quirrel) | C++ | Ref. counting | MIT | A fork of Squirrel with [new features](https://quirrel.io/doc/reference/diff_from_original.html). |
-| [Rebol](https://github.com/Oldes/Rebol3) | C | Tracing | Apache License 2.0 | Relative Expression Based Object Language |
-| [Red](https://github.com/red/red) | Rebol, Red, Red/System | Tracing | 3-clause BSD, BSL | A descendant of Rebol. Embeddable via [libRed](https://github.com/red/docs/blob/master/en/libred.adoc). Features a cross-platform native GUI system. Intended to have low memory usage. |
-| [Rhai](https://github.com/jonathandturner/rhai) | Rust | None (Rust-style lifetimes) | MIT or Apache License 2.0 | An embedded scripting language for Rust inspired by ChaiScript. |
-| [Ring](https://github.com/ring-lang/ring) | C | Tracing | MIT | An embeddable applications programming language with a large standard library and GIL-less multithreading. |
-| [Ruby](https://www.ruby-lang.org/en/) | C | Tracing | Choice of 2-clause BSD, Ruby license, GPL 2 | An embeddable object-oriented scripting language. [Running Ruby in C](https://silverhammermba.github.io/emberb/embed/). |
-| [s7](https://ccrma.stanford.edu/software/snd/snd/s7.html) | C | Tracing | 3-clause BSD | Implements a subset of R5RS/R7RS. Descended from TinyScheme. |
-| [sci](https://github.com/borkdude/sci) | Clojure | host VM's GC | EPL | An interpreter for a subset of Clojure for Clojure and ClojureScript. |
-| [SGScript](https://github.com/snake5/sgscript) | C | Ref. counting + tracing CG | MIT | [Features](http://www.sgscript.org/pages/advdocs/sgscript.docs.htm#Why-SGScript) include a built-in data serialization format, coroutines, class-based OOP, sandboxed evaluation, a built-in debugger and profiler. |
-| [Shine](https://github.com/richardhundt/shine) | C | Tracing | MIT | A language based on Lua with additional safety and expressiveness features implemented as a fork of LuaJIT. |
-| [SquiLu](https://github.com/mingodad/squilu) | C++ | Ref. counting | MIT, some extensions LGPL or GPL | A fork of [Squirrel](http://squirrel-lang.org/). Changes the syntax to accept a subset of JavaScript and C/C++. Implements Lua's features like string pattern matching and global table manipulation functions. Adds extensions for database access (SQLite3, MySQL, PostgreSQL), sockets, and other features. |
-| [Squirrel](http://squirrel-lang.org/) | C++ | Ref. counting | MIT | A language inspired by Lua and JavaScript/Python. Has a Lua-like C++ API. Differentiates itself from Lua with the use of reference counting in place of Lua's tracing GC, a curly-brace syntax, built-in class-based OOP, and zero-indexed arrays. |
-| [Starlark (Go)](https://github.com/google/starlark-go/) | Go | Go's GC | 3-clause BSD | A small dialect of Python for configuration. Not Turing-complete. Untrusted code: can't access the file system and network, can use up memory and CPU to perform a DoS attack. [Spec](https://github.com/bazelbuild/starlark). [Python bindings](https://github.com/caketop/python-starlark-go). |
-| [Starlark (Java)](https://github.com/bazelbuild/bazel/tree/master/src/main/java/net/starlark/java) | Java | JVM's GC | Apache License 2.0 | Starlark for the JVM. The original implementation. |
-| [Starlark (Rust)](https://github.com/google/starlark-rust/) | Rust | ? | Apache License 2.0 | Starlark in Rust. [Python bindings](https://github.com/inducer/starlark-pyo3). |
-| [tcc](https://repo.or.cz/tinycc.git/) | C | None | LGPL 2 | A small C compiler that can be used as a library for a C JIT. [libtcc header](https://repo.or.cz/tinycc.git/blob/HEAD:/libtcc.h). [Embedding example](https://repo.or.cz/tinycc.git/blob/HEAD:/tests/libtcc_test.c). |
-| [Tcl](http://tcl-lang.org/) | C | Ref. counting | Tcl license (BSD-like) | An embeddable general-purpose scripting language with a rich C API. Has a cross-platform GUI toolkit called [Tk](https://wiki.tcl-lang.org/477). [How to embed Tcl in C applications](https://wiki.tcl-lang.org/2074). |
-| [TinyScheme](http://tinyscheme.sourceforge.net/) | C | Tracing? | 3-clause BSD | Implements a subset of R5RS. |
-| [Umka](https://github.com/vtereshkov/umka-lang) | C | Ref. counting | 2-clause BSD | Statically typed. |
-| [Wirefilter](https://github.com/cloudflare/wirefilter) | Rust | None (no dynamic memory allocation) | MIT | An expression language for Wireshark-like filters. |
-| [Wren](https://github.com/munificent/wren) | C | Tracing | MIT | A small class-based performance-oriented scripting language. [Performance comparison](https://wren.io/performance.html). |
-| [zygomys](https://github.com/glycerine/zygomys) | Go | Go's GC | 2-clause BSD | An embedded Lisp for Go. Inspired by Clojure, but more oriented towards imperative programming. Has an infix syntax layer that looks like a subset of Go. |
+| Language | Project name/link | Implementated in | GC | License | Notes |
+|----------|-------------------|------------------|----|---------|-------|
+| Ada | [HAC](https://hacadacompiler.sourceforge.io/) | Ada | None (stack only) | MIT | HAC implements a subset of the Ada language. Thus, it can share sources with the embedding application. |
+| AngelScript | [AngelScript](http://www.angelcode.com/angelscript/) | C++ | Ref. counting + cycle-detecting tracing GC | zlib | A statically typed curly brace language resembling C++ itself. |
+| Anko | [Anko](https://github.com/mattn/anko/) | Go | Go's GC | MIT | Scriptable interpreter with syntax similar to Go. |
+| ArkScript | [ArkScript](https://github.com/SuperFola/Ark) | C++ | None (resource release is destruction + optional manual MM) | MPL 2.0 | A small functional Lisp-like programming language. Separate bytecode compiler and VM. |
+| Awk | [Libmawk](http://repo.hu/projects/libmawk/) | C | Ref. counting | **GPL 2** | Implements Awk. A fork of mawk 1.3 restructured for embedding. |
+| Awk, Basic, Pascal | [Libfawk](http://repo.hu/projects/libfawk/) | C | Ref. counting | 3-clause BSD | A multi-language VM. Includes compilers for three languages: Fawk (Awk dialect), Fbas (Basic dialect), and Fpas (Pascal dialect). |
+| Basic | [MY-BASIC](https://github.com/paladin-t/my_basic) | C | Ref. counting + cycle-detecting tracing GC | MIT | A Basic dialect with prototype-based OOP. |
+| Boron | [Boron](http://urlan.sourceforge.net/boron/) | C | Tracing | LGPL 3+ | An embeddable scripting language similar to Rebol. |
+| C | [PicoC](https://github.com/zsaleeba/picoc) | C | None (manual MM) | 3-clause BSD | Statically typed. Interprets a subset of C. |
+| C | [tcc](https://repo.or.cz/tinycc.git/) | C | None | LGPL 2 | A small C compiler that can be used as a library for a C JIT. [libtcc header](https://repo.or.cz/tinycc.git/blob/HEAD:/libtcc.h). [Embedding example](https://repo.or.cz/tinycc.git/blob/HEAD:/tests/libtcc_test.c). |
+| C#, other CLR languages | [Mono](http://www.mono-project.com/docs/advanced/embedding/scripting/) | C | Tracing | MIT and other | Implements the [CLR](https://en.wikipedia.org/wiki/Common_Language_Runtime). |
+| ChaiScript | [ChaiScript](http://chaiscript.com/) | C++ | Ref. counting | 3-clause BSD | A header-only C++14 interpreter library. |
+| Clojure | [sci](https://github.com/borkdude/sci) | Clojure | host VM's GC | EPL | An interpreter for a subset of Clojure for Clojure and ClojureScript. |
+| Common Lisp | [Clasp](https://github.com/drmeister/clasp) | Common Lisp, C++ | MPS GC (Boehm-Weiser also supported) | LGPL 2+ | Full Common Lisp implementation well integrated with C++, using LLVM for the code generation, to integrate closely with C++ applications or libraries. |
+| Common Lisp | [Embeddable Common Lisp](https://gitlab.com/embeddable-common-lisp/ecl) | Common Lisp, C | Boehm-Weiser GC | LGPL 2+ | Full Common Lisp implementation, available as a shared library `libecl.so` embeddable in any C, C++ or other application. |
+| daScript | [daScript](https://dascript.org/) | C++ | None (region-based + manual MM?) | 3-clause BSD | A statically-typed [performance-oriented](https://dascript.org/#performance) scripting language. |
+| Datalog | [AbcDatalog](http://abcdatalog.seas.harvard.edu/) | Java | JVM's GC | 3-clause BSD | Implements Datalog. |
+| Datalog | [Cascalog](https://github.com/nathanmarz/cascalog) | Clojure | JVM's GC | Apache License 2.0 | Implements Datalog. |
+| Datalog | [Datalog (c-cube)](https://github.com/c-cube/datalog) | OCaml | OCaml's GC | 2-clause BSD | Implements Datalog. |
+| Datalog | [Datalog (fogfish)](https://github.com/fogfish/datalog) | Erlang | None (no collection inside interpreter state) | Apache License 2.0 | Implements Datalog. |
+| Datalog | [Datalog (MITRE Corporation)](http://datalog.sourceforge.net/) | C | Tracing (Lua's GC) | LGPL 2+ | Implements Datalog. It is implemented on top of Lua 5.3 and can be extended with Lua functions. |
+| Dhall | [Dhall](https://dhall-lang.org/) | Haskell | Haskell's GC | 3-clause BSD | A statically-typed functional configuration language. Not Turing-complete. Untrusted code: can't access the file system, can fetch Dhall libraries over HTTP(S) from static URLs (but libraries aren't allowed to access your data), can use up memory and CPU time for a DoS attack. Has a work-in-progress Clojure and Ruby implementation. |
+| Duktape | [Duktape](http://duktape.org/) | C | Ref. counting + cycle-detecting tracing GC | MIT | Implements JavaScript E5/E5.1. |
+| DWScript | [DWScript](https://bitbucket.org/egrange/dwscript/) | Object Pascal (Delphi 2009 or later) | Ref. counting + cycle-detecting tracing GC | MPL 1.1, GPL 3 (JavaScript code generator) | [Description](https://www.delphitools.info/dwscript). A statically typed Delphi/Free Pascal-like language. Can compile to JavaScript. |
+| Dyon | [Dyon](https://github.com/pistondevelopers/dyon) | Rust | None (Rust-style [lifetimes](http://www.piston.rs/dyon-tutorial/lifetimes.html)) | Apache License 2.0 or MIT | Has optional, optimistic (succeed-by-default) static type checking. |
+| Expr | [Expr](https://github.com/antonmedv/expr) | Go | Go's GC | MIT | Compiles and evaluates statically-typed expressions. |
+| Falcon | [Falcon](http://falconpl.org/) | C++ | Tracing | **GPL 2** or custom | The GC is pluggable. |
+| Forth | [Atlast](https://www.fourmilab.ch/atlast/) | C | None (manual MM) | Public domain | A dialect of Forth originally developed at Autodesk. |
+| Forth | [FTH](http://fth.sourceforge.net) | C | Tracing | 2-clause BSD | A dialect of Forth with objects, hashes, regular expressions, and other extensions. |
+| Forth | [pForth](http://www.softsynth.com/pforth/) | C | None (manual MM) | Public domain | A dialect of Forth. |
+| GameMonkey Script | [GameMonkey Script](http://www.gmscript.com/) | C++ | Tracing | MIT | Comes with C bindings. Similar to Lua, multithreaded. |
+| Gentee | [Gentee](https://github.com/gentee/gentee/) | Go | Go's GC | MIT | Statically typed. |
+| gluon | [gluon](https://github.com/gluon-lang/gluon) | Rust | Tracing | MIT | Statically typed. Inspired by Lua, Haskell, and OCaml. Each executing gluon thread gets a separate heap. |
+| Gravity | [Gravity](https://github.com/marcobambini/gravity) | C | Tracing | MIT | A class-based concurrent scripting language with a Swift-like syntax. |
+| Groovy | [Groovy](http://groovy-lang.org/) | Java | JVM's GC | Apache License 2.0 | A scripting language for the JVM. A large subset of Java is valid Groovy. [Integrating Groovy into applications](http://groovy-lang.org/integrating.html). |
+| Haxe | [HashLink](https://hashlink.haxe.org/) | C | Tracing (lazy sweep) | MIT | A bytecode interpreter and a baseline JIT compiler (x86/x86\_64 only) for [Haxe](https://haxe.org/). |
+| Haxe, others | [Neko](http://nekovm.org/) | C | Boehm | MIT | The NekoVM is a target for several compilers, including [Haxe](http://haxe.org/). |
+| Io | [Io](https://github.com/stevedekorte/io) | C | Tracing | 3-clause BSD | A prototype-based OO language. |
+| Janet | [Janet](https://janet-lang.org/) | C | Tracing | MIT | A functional and imperative language with a Lisp syntax. |
+| Java | [BeanShell](https://github.com/beanshell/beanshell/) | Java | JVM's GC | Apache License 2.0 | An small, embeddable Java source code interpreter. Understands Java code with certain extensions like method closures. |
+| JavaScript | [Espruino](https://github.com/espruino/Espruino) | C | Tracing | MPL 2.0 | Implements a subset of JavaScript ES5 in a way suitable for embedded hardware with 8+ KiB RAM. |
+| JavaScript | [Goja](https://github.com/dop251/goja) | Go | Go's GC | MIT | Implements ECMAScript 5.1. Better standard compliance and performance than otto. |
+| JavaScript | [JerryScript](https://github.com/jerryscript-project/jerryscript) | C | Tracing | Apache License 2.0 | A full ECMAScript 5.1 interpreter written in C99 and optimized for low memory consumption. Uses CMake. |
+| JavaScript | [jsish](http://jsish.org/) | C | Ref. counting | MIT | A JavaScript ES 5.2+ interpreter. Internally structured after Tcl with an extensive C API. Features include subinterpreters, introspection, SQLite bindings, and a web framework with WebSocket support. The code is valid C and C++. |
+| JavaScript | [MuJS](https://mujs.com/) | C | Tracing | ISC | Implements JavaScript (ES5). Has a similar C interface to Lua. |
+| JavaScript | [njs](https://nginx.org/en/docs/njs/) | C | None (no collection performed) | 2-clause BSD | Implements a subset of ES5.1 with some ES6 extensions. |
+| JavaScript | [otto](https://github.com/robertkrimen/otto) | Go | Go's GC | MIT | Implements ES5 with [some limitations](https://github.com/robertkrimen/otto#caveat-emptor). |
+| JavaScript | [QuickJS](https://bellard.org/quickjs/) | C | Ref. counting + cycle-detecting tracing GC | MIT | A small embedded JavaScript interpreter that implements almost all of ES2019 and much of ES2020. |
+| Jinx | [Jinx](https://jamesboer.github.io/Jinx/) | C++17 | Ref. counting | MIT | Designed for use in realtime applications such as video games. |
+| Jsonnet | [Jsonnet](https://jsonnet.org/) | C++ | Tracing | Apache License 2.0 | A functional configuration language that extends JSON. Untrusted code: can't access the file system or network, can use up memory and CPU time for a DoS attack. Has [bindings](https://jsonnet.org/ref/bindings.html) for C, C++, Go, Python, and other languages, as well as a separate native Go implementation. |
+| Ketos | [Ketos](https://github.com/murarth/ketos) | Rust | None (no heap allocation)? | Apache License 2.0 | A functional Lisp. |
+| LIL | [LIL](http://runtimeterror.com/tech/lil/) | C, Object Pascal (separate implementations) | None (no reference support) | zlib | A Tcl-like language incompatible with mainline Tcl. |
+| Lily | [Lily](https://github.com/FascinatedBox/lily/) | C | Ref. counting + GC | MIT | A language focusing on expressiveness and safety. |
+| ljs | [ljs](https://github.com/mingodad/ljs) | C | Tracing | MIT | Lua 5.3, Lua 5.1, and LuaJIT with a C/C++/Java/JavaScript syntax. Can convert Lua source code to ljs. |
+| Lua | [Go-Lua](https://github.com/Shopify/go-lua) | Go | Go's GC | MIT | Implements a subset of Lua 5.2. |
+| Lua | [GopherLua](https://github.com/yuin/gopher-lua) | Go | Go's GC | MIT | Implements Lua 5.1 with the added support for Go's channels. Lacks the debug hooks and several functions from the C version. |
+| Lua | [Lua](http://lua.org/) | C | Tracing | MIT | The reference implementation of what is likely the world's most popular embedded scripting language. Allows you to precompile scripts to bytecode. Versions 5.1-5.3, which are the ones used today, are not fully compatible with each other. |
+| Lua | [LuaJ](https://sourceforge.net/projects/luaj/) | Java | JVM's GC | MIT | A Lua 5.2 spec-compliant interpreter written in Java for JME and JSE. Complies Lua directly to JVM bytecode. |
+| Lua | [LuaJIT](http://luajit.org/) | C | Tracing | MIT | Fully compatible with Lua 5.1. Has a built-in C FFI library. [Performance comparison](https://luajit.org/performance.html). |
+| Lua | [Lua-ML](https://github.com/lindig/lua-ml) | OCaml | OCaml's GC | 2-clause BSD | Embeddable Lua 2.5 reimplementation that integrates with OCaml type and module system. It's possible to extend or even replace the standard library with your own modules. |
+| Lua | [Luau](https://luau-lang.org/) | C | Tracing | MIT | Roblox [fork of Lua 5.1](https://luau-lang.org/why) as a scripting language for games to support a gradual type system as well as limiting the set of standard libraries exposed to the users and implements extra sandboxing features to be able to run unprivileged code. Whenever possible, Luau aims to be backwards-compatible with Lua 5.1 and at the same time to incorporate features from later revisions of Lua. |
+| Lua | [luerl](https://github.com/rvirding/luerl) | Erlang | Tracing | Apache License 2.0 | An implementation of Lua 5.2 in pure Erlang with some features like `goto` absent. |
+| Lua | [MoonSharp](https://www.moonsharp.org/) | C# | CLR's GC | 3-clause BSD and other | CLR Based Lua implementation that is 99% compatible with Lua 5.2 |
+| Mond | [Mond](https://github.com/Rohansi/Mond/) | C# | CLR's GC | MIT | A dynamically typed scripting language with generators, async, remote debugging, and a binding API. |
+| Never | [Never](https://github.com/never-lang/never) | C | Tracing | MIT | A statically typed functional programming language. |
+| Pascal | [Pascal Script](http://www.remobjects.com/ps.aspx) | Object Pascal | None (manual MM) | modified zlib/libpng-License with mandatory attribution | Statically typed. Implements "most of Object Pascal". Can't define new classes. |
+| Pawn | [Pawn](http://www.compuphase.com/pawn/pawn.htm) | C | None (no heap allocation) | Apache License 2.0 with a clause to explicitly permit static linking | A curly-brace language with a small-footprint VM. Represents data as 4/8-byte "cells". Compiles to CPU-specific bytecode. [More](https://wiki.alliedmods.net/Pawn_Tutorial#Language_Paradigms). |
+| Perl | [Perl](https://www.perl.org/) | C | Ref. counting | Artistic License or GPL 3 | [Embedding Perl in Another Application](https://perldoc.perl.org/perlembed) |
+| PHP | [ephp](https://github.com/bragful/ephp) | Erlang | None (no collection inside interpreter state) | LGPL 2.1 | Implements a subset of PHP 5.5. |
+| PHP | [PH7](https://github.com/symisc/PH7) | C | Ref. counting | **SPL** or proprietary | Implements a subset of PHP 5.3 with some changes like native UTF-8 support. |
+| pocketlang | [pocketlang](https://github.com/ThakeeNathees/pocketlang) | C | Tracing | MIT | A small language syntactically similar to Ruby. [Embedding examples](https://github.com/ThakeeNathees/pocketlang/tree/master/tests/native/). [Performance comparison](https://github.com/ThakeeNathees/pocketlang#performance). |
+| Prolog | [Erlog](https://github.com/rvirding/erlog) | Erlang | None () | Apache License 2.0 | Interprets a subset of standard Prolog. |
+| Prolog | [Golog](https://github.com/mndrix/golog) | Go | Go's GC | MIT | Implements a subset of standard Prolog. |
+| Python | [CircuitPython](https://github.com/adafruit/circuitpython) | C | Tracing | MIT | A fork of MicroPython, designed for API uniformity across many microcontrollers. |
+| Python | [Jython](http://www.jython.org/) | Java | JVM's GC | PSFL (BSD-like) | An implementation of Python on the JVM. |
+| Python | [MicroPython](https://github.com/micropython/micropython) | C | Tracing | MIT | Implements the Python 3.4 syntax and some of the core datatypes. |
+| Python | [Python](https://www.python.org/) | C | Ref. counting + cycle-detecting tracing GC | PSFL (BSD-like) | [Embedding Python in Another Application](https://docs.python.org/3.5/extending/embedding.html). |
+| QuakeC | [gmqcc/qcvm](https://github.com/graphitemaster/gmqcc) | C++ | None (no dynamic memory allocation) | MIT | A QuakeC compiler and VM. |
+| Quirrel | [Quirrel](https://github.com/GaijinEntertainment/quirrel) | C++ | Ref. counting | MIT | A fork of Squirrel with [new features](https://quirrel.io/doc/reference/diff_from_original.html). |
+| Rebol | [Rebol](https://github.com/Oldes/Rebol3) | C | Tracing | Apache License 2.0 | Relative Expression Based Object Language |
+| Red | [Red](https://github.com/red/red) | Rebol, Red, Red/System | Tracing | 3-clause BSD, BSL | A descendant of Rebol. Embeddable via [libRed](https://github.com/red/docs/blob/master/en/libred.adoc). Features a cross-platform native GUI system. Intended to have low memory usage. |
+| Rexx | [NetRexx](http://www.netrexx.org/) | Java | JVM's GC | ICU (BSD-like) |  |
+| Rexx | [ooRexx](http://www.oorexx.org/) | C++ | Tracing | CPL | Implements Rexx extended with objects. |
+| Rhai | [Rhai](https://github.com/jonathandturner/rhai) | Rust | None (Rust-style lifetimes) | MIT or Apache License 2.0 | An embedded scripting language for Rust inspired by ChaiScript. |
+| Ring | [Ring](https://github.com/ring-lang/ring) | C | Tracing | MIT | An embeddable applications programming language with a large standard library and GIL-less multithreading. |
+| Ruby | [JRuby](http://www.jruby.org/) | Java | JVM's GC | Choice of EPL, GPL, and LGPL | An implementation of Ruby on the JVM. |
+| Ruby | [mruby](https://github.com/mruby/mruby) | C | Tracing | MIT | A lightweight implementation of Ruby. Has a compile-time package manager. |
+| Ruby | [mruby/c](https://github.com/mrubyc/mrubyc) | C | Ref. counting | 3-clause BSD | An even smaller implementation of Ruby for microcontrollers with limited memory. |
+| Ruby | [Ruby](https://www.ruby-lang.org/en/) | C | Tracing | Choice of 2-clause BSD, Ruby license, GPL 2 | An embeddable object-oriented scripting language. [Running Ruby in C](https://silverhammermba.github.io/emberb/embed/). |
+| Scheme | [Animula](https://gitlab.com/hardenedlinux/animula) | C | Tracing | Compiler **GPL 3+** while VM is LGPL 3+ | An optimizing compiler and VM for embedded systems. R7RS. |
+| Scheme | [Chibi Scheme](https://github.com/ashinn/chibi-scheme) | C | Tracing | 3-clause BSD | Implements R7RS small. |
+| Scheme | [CHICKEN Scheme](https://call-cc.org/) | C | Tracing | 3-clause BSD | Implements R5RS (with some [changes](http://wiki.call-cc.org/man/4/Supported%20language)). R7RS support is a work in progress. [Examples of embedding CHICKEN](https://wiki.call-cc.org/embedding). |
+| Scheme | [GNU Guile](https://www.gnu.org/software/guile/) | C | [Boehm](https://www.gnu.org/software/guile/manual/html_node/Conservative-GC.html) | LGPL 3+ | ["Guile mostly implements R6RS."](https://www.gnu.org/software/guile/manual/guile.html#R6RS-Support) |
+| Scheme | [Kawa](https://www.gnu.org/software/kawa/) | Java | JVM's GC | MIT | R7RS. Supports the javax.script API. [Evaluating Scheme expressions from Java](https://www.gnu.org/software/kawa/Evaluating-Scheme-expressions-from-Java.html). |
+| Scheme | [s7](https://ccrma.stanford.edu/software/snd/snd/s7.html) | C | Tracing | 3-clause BSD | Implements a subset of R5RS/R7RS. Descended from TinyScheme. |
+| Scheme | [TinyScheme](http://tinyscheme.sourceforge.net/) | C | Tracing? | 3-clause BSD | Implements a subset of R5RS. |
+| SGScript | [SGScript](https://github.com/snake5/sgscript) | C | Ref. counting + tracing CG | MIT | [Features](http://www.sgscript.org/pages/advdocs/sgscript.docs.htm#Why-SGScript) include a built-in data serialization format, coroutines, class-based OOP, sandboxed evaluation, a built-in debugger and profiler. |
+| Shine | [Shine](https://github.com/richardhundt/shine) | C | Tracing | MIT | A language based on Lua with additional safety and expressiveness features implemented as a fork of LuaJIT. |
+| SquiLu | [SquiLu](https://github.com/mingodad/squilu) | C++ | Ref. counting | MIT, some extensions LGPL or GPL | A fork of [Squirrel](http://squirrel-lang.org/). Changes the syntax to accept a subset of JavaScript and C/C++. Implements Lua's features like string pattern matching and global table manipulation functions. Adds extensions for database access (SQLite3, MySQL, PostgreSQL), sockets, and other features. |
+| Squirrel | [Squirrel](http://squirrel-lang.org/) | C++ | Ref. counting | MIT | A language inspired by Lua and JavaScript/Python. Has a Lua-like C++ API. Differentiates itself from Lua with the use of reference counting in place of Lua's tracing GC, a curly-brace syntax, built-in class-based OOP, and zero-indexed arrays. |
+| Starlark | [Starlark (Go)](https://github.com/google/starlark-go/) | Go | Go's GC | 3-clause BSD | A small dialect of Python for configuration. Not Turing-complete. Untrusted code: can't access the file system and network, can use up memory and CPU to perform a DoS attack. [Spec](https://github.com/bazelbuild/starlark). [Python bindings](https://github.com/caketop/python-starlark-go). |
+| Starlark | [Starlark (Java)](https://github.com/bazelbuild/bazel/tree/master/src/main/java/net/starlark/java) | Java | JVM's GC | Apache License 2.0 | Starlark for the JVM. The original implementation. |
+| Starlark | [Starlark (Rust)](https://github.com/google/starlark-rust/) | Rust | ? | Apache License 2.0 | Starlark in Rust. [Python bindings](https://github.com/inducer/starlark-pyo3). |
+| Tcl | [Jim Tcl](http://jim.tcl-lang.org/) | C | Tracing | 2-clause BSD | Largely compatible with Tcl 8.5 with its own additions. |
+| Tcl | [JTcl](https://github.com/jtcl-project/jtcl) | Java | Ref. counting | Various BSD-like | Tcl 8.4 with some 8.5 features for the JVM. |
+| Tcl | [Molt](https://github.com/wduquette/molt) | Rust | Ref. counting | 3-clause BSD | A minimal Tcl implementation for Rust applications and libraries. |
+| Tcl | [Picol](https://chiselapp.com/user/dbohdan/repository/picol/) | C | None (no reference support) | 2-clause BSD | A header-only library interpreter for a limited dialect of Tcl. |
+| Tcl | [Tcl](http://tcl-lang.org/) | C | Ref. counting | Tcl license (BSD-like) | An embeddable general-purpose scripting language with a rich C API. Has a cross-platform GUI toolkit called [Tk](https://wiki.tcl-lang.org/477). [How to embed Tcl in C applications](https://wiki.tcl-lang.org/2074). |
+| Umka | [Umka](https://github.com/vtereshkov/umka-lang) | C | Ref. counting | 2-clause BSD | Statically typed. |
+| Wirefilter | [Wirefilter](https://github.com/cloudflare/wirefilter) | Rust | None (no dynamic memory allocation) | MIT | An expression language for Wireshark-like filters. |
+| Wren | [Wren](https://github.com/munificent/wren) | C | Tracing | MIT | A small class-based performance-oriented scripting language. [Performance comparison](https://wren.io/performance.html). |
+| zygomys | [zygomys](https://github.com/glycerine/zygomys) | Go | Go's GC | 2-clause BSD | An embedded Lisp for Go. Inspired by Clojure, but more oriented towards imperative programming. Has an infix syntax layer that looks like a subset of Go. |
 
 ## Sorted by implementation language
 
-| Implementation language | Project name/link | GC | License | Notes |
-|-------------------------|-------------------|----|---------|-------|
-| Ada | [HAC](https://hacadacompiler.sourceforge.io/) | None (stack only) | MIT | HAC implements a subset of the Ada language. Thus, it can share sources with the embedding application. |
-| C | [Animula](https://gitlab.com/hardenedlinux/animula) | Tracing | Compiler **GPL 3+** while VM is LGPL 3+ | An optimizing compiler and VM for embedded systems. R7RS. |
-| C | [Atlast](https://www.fourmilab.ch/atlast/) | None (manual MM) | Public domain | A dialect of Forth originally developed at Autodesk. |
-| C | [Boron](http://urlan.sourceforge.net/boron/) | Tracing | LGPL 3+ | An embeddable scripting language similar to Rebol. |
-| C | [CircuitPython](https://github.com/adafruit/circuitpython) | Tracing | MIT | A fork of MicroPython, designed for API uniformity across many microcontrollers. |
-| C | [Chibi Scheme](https://github.com/ashinn/chibi-scheme) | Tracing | 3-clause BSD | Implements R7RS small. |
-| C | [CHICKEN Scheme](https://call-cc.org/) | Tracing | 3-clause BSD | Implements R5RS (with some [changes](http://wiki.call-cc.org/man/4/Supported%20language)). R7RS support is a work in progress. [Examples of embedding CHICKEN](https://wiki.call-cc.org/embedding). |
-| C | [Datalog (MITRE Corporation)](http://datalog.sourceforge.net/) | Tracing (Lua's GC) | LGPL 2+ | Implements Datalog. It is implemented on top of Lua 5.3 and can be extended with Lua functions. |
-| C | [Duktape](http://duktape.org/) | Ref. counting + cycle-detecting tracing GC | MIT | Implements JavaScript E5/E5.1. |
-| C | [Espruino](https://github.com/espruino/Espruino) | Tracing | MPL 2.0 | Implements a subset of JavaScript ES5 in a way suitable for embedded hardware with 8+ KiB RAM. |
-| C | [FTH](http://fth.sourceforge.net) | Tracing | 2-clause BSD | A dialect of Forth with objects, hashes, regular expressions, and other extensions. |
-| C | [Gravity](https://github.com/marcobambini/gravity) | Tracing | MIT | A class-based concurrent scripting language with a Swift-like syntax. |
-| C | [GNU Guile](https://www.gnu.org/software/guile/) | [Boehm](https://www.gnu.org/software/guile/manual/html_node/Conservative-GC.html) | LGPL 3+ | ["Guile mostly implements R6RS."](https://www.gnu.org/software/guile/manual/guile.html#R6RS-Support) |
-| C | [HashLink](https://hashlink.haxe.org/) | Tracing (lazy sweep) | MIT | A bytecode interpreter and a baseline JIT compiler (x86/x86\_64 only) for [Haxe](https://haxe.org/). |
-| C | [Io](https://github.com/stevedekorte/io) | Tracing | 3-clause BSD | A prototype-based OO language. |
-| C | [Janet](https://janet-lang.org/) | Tracing | MIT | A functional and imperative language with a Lisp syntax. |
-| C | [JerryScript](https://github.com/jerryscript-project/jerryscript) | Tracing | Apache License 2.0 | A full ECMAScript 5.1 interpreter written in C99 and optimized for low memory consumption. Uses CMake. |
-| C | [Jim Tcl](http://jim.tcl-lang.org/) | Tracing | 2-clause BSD | Largely compatible with Tcl 8.5 with its own additions. |
-| C | [jsish](http://jsish.org/) | Ref. counting | MIT | A JavaScript ES 5.2+ interpreter. Internally structured after Tcl with an extensive C API. Features include subinterpreters, introspection, SQLite bindings, and a web framework with WebSocket support. The code is valid C and C++. |
-| C | [Libfawk](http://repo.hu/projects/libfawk/) | Ref. counting | 3-clause BSD | A multi-language VM. Includes compilers for three languages: Fawk (Awk dialect), Fbas (Basic dialect), and Fpas (Pascal dialect). |
-| C | [Libmawk](http://repo.hu/projects/libmawk/) | Ref. counting | **GPL 2** | Implements Awk. A fork of mawk 1.3 restructured for embedding. |
-| C | [Lily](https://github.com/FascinatedBox/lily/) | Ref. counting + GC | MIT | A language focusing on expressiveness and safety. |
-| C | [ljs](https://github.com/mingodad/ljs) | Tracing | MIT | Lua 5.3, Lua 5.1, and LuaJIT with a C/C++/Java/JavaScript syntax. Can convert Lua source code to ljs. |
-| C | [Lua](http://lua.org/) | Tracing | MIT | The reference implementation of what is likely the world's most popular embedded scripting language. Allows you to precompile scripts to bytecode. Versions 5.1-5.3, which are the ones used today, are not fully compatible with each other. |
-| C | [LuaJIT](http://luajit.org/) | Tracing | MIT | Fully compatible with Lua 5.1. Has a built-in C FFI library. [Performance comparison](https://luajit.org/performance.html). |
-| C | [Luau](https://luau-lang.org/) | Tracing | MIT | Roblox [fork of Lua 5.1](https://luau-lang.org/why) as a scripting language for games to support a gradual type system as well as limiting the set of standard libraries exposed to the users and implements extra sandboxing features to be able to run unprivileged code. Whenever possible, Luau aims to be backwards-compatible with Lua 5.1 and at the same time to incorporate features from later revisions of Lua. |
-| C | [MicroPython](https://github.com/micropython/micropython) | Tracing | MIT | Implements the Python 3.4 syntax and some of the core datatypes. |
-| C | [Mono](http://www.mono-project.com/docs/advanced/embedding/scripting/) | Tracing | MIT and other | Implements the [CLR](https://en.wikipedia.org/wiki/Common_Language_Runtime). |
-| C | [mruby](https://github.com/mruby/mruby) | Tracing | MIT | A lightweight implementation of Ruby. Has a compile-time package manager. |
-| C | [mruby/c](https://github.com/mrubyc/mrubyc) | Ref. counting | 3-clause BSD | An even smaller implementation of Ruby for microcontrollers with limited memory. |
-| C | [MuJS](https://mujs.com/) | Tracing | ISC | Implements JavaScript (ES5). Has a similar C interface to Lua. |
-| C | [MY-BASIC](https://github.com/paladin-t/my_basic) | Ref. counting + cycle-detecting tracing GC | MIT | A Basic dialect with prototype-based OOP. |
-| C | [Neko](http://nekovm.org/) | Boehm | MIT | The NekoVM is a target for several compilers, including [Haxe](http://haxe.org/). |
-| C | [Never](https://github.com/never-lang/never) | Tracing | MIT | A statically typed functional programming language. |
-| C | [njs](https://nginx.org/en/docs/njs/) | None (no collection performed) | 2-clause BSD | Implements a subset of ES5.1 with some ES6 extensions. |
-| C | [Pawn](http://www.compuphase.com/pawn/pawn.htm) | None (no heap allocation) | Apache License 2.0 with a clause to explicitly permit static linking | A curly-brace language with a small-footprint VM. Represents data as 4/8-byte "cells". Compiles to CPU-specific bytecode. [More](https://wiki.alliedmods.net/Pawn_Tutorial#Language_Paradigms). |
-| C | [Perl](https://www.perl.org/) | Ref. counting | Artistic License or GPL 3 | [Embedding Perl in Another Application](https://perldoc.perl.org/perlembed) |
-| C | [pForth](http://www.softsynth.com/pforth/) | None (manual MM) | Public domain | A dialect of Forth. |
-| C | [PH7](https://github.com/symisc/PH7) | Ref. counting | **SPL** or proprietary | Implements a subset of PHP 5.3 with some changes like native UTF-8 support. |
-| C | [PicoC](https://github.com/zsaleeba/picoc) | None (manual MM) | 3-clause BSD | Statically typed. Interprets a subset of C. |
-| C | [Picol](https://chiselapp.com/user/dbohdan/repository/picol/) | None (no reference support) | 2-clause BSD | A header-only library interpreter for a limited dialect of Tcl. |
-| C | [pocketlang](https://github.com/ThakeeNathees/pocketlang) | Tracing | MIT | A small language syntactically similar to Ruby. [Embedding examples](https://github.com/ThakeeNathees/pocketlang/tree/master/tests/native/). [Performance comparison](https://github.com/ThakeeNathees/pocketlang#performance). |
-| C | [Python](https://www.python.org/) | Ref. counting + cycle-detecting tracing GC | PSFL (BSD-like) | [Embedding Python in Another Application](https://docs.python.org/3.5/extending/embedding.html). |
-| C | [QuickJS](https://bellard.org/quickjs/) | Ref. counting + cycle-detecting tracing GC | MIT | A small embedded JavaScript interpreter that implements almost all of ES2019 and much of ES2020. |
-| C | [Rebol](https://github.com/Oldes/Rebol3) | Tracing | Apache License 2.0 | Relative Expression Based Object Language |
-| C | [Ring](https://github.com/ring-lang/ring) | Tracing | MIT | An embeddable applications programming language with a large standard library and GIL-less multithreading. |
-| C | [Ruby](https://www.ruby-lang.org/en/) | Tracing | Choice of 2-clause BSD, Ruby license, GPL 2 | An embeddable object-oriented scripting language. [Running Ruby in C](https://silverhammermba.github.io/emberb/embed/). |
-| C | [s7](https://ccrma.stanford.edu/software/snd/snd/s7.html) | Tracing | 3-clause BSD | Implements a subset of R5RS/R7RS. Descended from TinyScheme. |
-| C | [SGScript](https://github.com/snake5/sgscript) | Ref. counting + tracing CG | MIT | [Features](http://www.sgscript.org/pages/advdocs/sgscript.docs.htm#Why-SGScript) include a built-in data serialization format, coroutines, class-based OOP, sandboxed evaluation, a built-in debugger and profiler. |
-| C | [Shine](https://github.com/richardhundt/shine) | Tracing | MIT | A language based on Lua with additional safety and expressiveness features implemented as a fork of LuaJIT. |
-| C | [Tcl](http://tcl-lang.org/) | Ref. counting | Tcl license (BSD-like) | An embeddable general-purpose scripting language with a rich C API. Has a cross-platform GUI toolkit called [Tk](https://wiki.tcl-lang.org/477). [How to embed Tcl in C applications](https://wiki.tcl-lang.org/2074). |
-| C | [tcc](https://repo.or.cz/tinycc.git/) | None | LGPL 2 | A small C compiler that can be used as a library for a C JIT. [libtcc header](https://repo.or.cz/tinycc.git/blob/HEAD:/libtcc.h). [Embedding example](https://repo.or.cz/tinycc.git/blob/HEAD:/tests/libtcc_test.c). |
-| C | [TinyScheme](http://tinyscheme.sourceforge.net/) | Tracing? | 3-clause BSD | Implements a subset of R5RS. |
-| C | [Umka](https://github.com/vtereshkov/umka-lang) | Ref. counting | 2-clause BSD | Statically typed. |
-| C | [Wren](https://github.com/munificent/wren) | Tracing | MIT | A small class-based performance-oriented scripting language. [Performance comparison](https://wren.io/performance.html). |
-| C# | [Mond](https://github.com/Rohansi/Mond/) | CLR's GC | MIT | A dynamically typed scripting language with generators, async, remote debugging, and a binding API. |
-| C# | [MoonSharp](https://www.moonsharp.org/) | CLR's GC | 3-clause BSD and other | CLR Based Lua implementation that is 99% compatible with Lua 5.2 |
-| C++ | [AngelScript](http://www.angelcode.com/angelscript/) | Ref. counting + cycle-detecting tracing GC | zlib | A statically typed curly brace language resembling C++ itself. |
-| C++ | [ArkScript](https://github.com/SuperFola/Ark) | None (resource release is destruction + optional manual MM) | MPL 2.0 | A small functional Lisp-like programming language. Separate bytecode compiler and VM. |
-| C++ | [ChaiScript](http://chaiscript.com/) | Ref. counting | 3-clause BSD | A header-only C++14 interpreter library. |
-| C++ | [daScript](https://dascript.org/) | None (region-based + manual MM?) | 3-clause BSD | A statically-typed [performance-oriented](https://dascript.org/#performance) scripting language. |
-| C++ | [Falcon](http://falconpl.org/) | Tracing | **GPL 2** or custom | The GC is pluggable. |
-| C++ | [GameMonkey Script](http://www.gmscript.com/) | Tracing | MIT | Comes with C bindings. Similar to Lua, multithreaded. |
-| C++ | [Jsonnet](https://jsonnet.org/) | Tracing | Apache License 2.0 | A functional configuration language that extends JSON. Untrusted code: can't access the file system or network, can use up memory and CPU time for a DoS attack. Has [bindings](https://jsonnet.org/ref/bindings.html) for C, C++, Go, Python, and other languages, as well as a separate native Go implementation. |
-| C++ | [ooRexx](http://www.oorexx.org/) | Tracing | CPL | Implements Rexx extended with objects. |
-| C++ | [gmqcc/qcvm](https://github.com/graphitemaster/gmqcc) | None (no dynamic memory allocation) | MIT | A QuakeC compiler and VM. |
-| C++ | [Quirrel](https://github.com/GaijinEntertainment/quirrel) | Ref. counting | MIT | A fork of Squirrel with [new features](https://quirrel.io/doc/reference/diff_from_original.html). |
-| C++ | [SquiLu](https://github.com/mingodad/squilu) | Ref. counting | MIT, some extensions LGPL or GPL | A fork of [Squirrel](http://squirrel-lang.org/). Changes the syntax to accept a subset of JavaScript and C/C++. Implements Lua's features like string pattern matching and global table manipulation functions. Adds extensions for database access (SQLite3, MySQL, PostgreSQL), sockets, and other features. |
-| C++ | [Squirrel](http://squirrel-lang.org/) | Ref. counting | MIT | A language inspired by Lua and JavaScript/Python. Has a Lua-like C++ API. Differentiates itself from Lua with the use of reference counting in place of Lua's tracing GC, a curly-brace syntax, built-in class-based OOP, and zero-indexed arrays. |
-| C++17 | [Jinx](https://jamesboer.github.io/Jinx/) | Ref. counting | MIT | Designed for use in realtime applications such as video games. |
-| C, Object Pascal (separate implementations) | [LIL](http://runtimeterror.com/tech/lil/) | None (no reference support) | zlib | A Tcl-like language incompatible with mainline Tcl. |
-| Clojure | [Cascalog](https://github.com/nathanmarz/cascalog) | JVM's GC | Apache License 2.0 | Implements Datalog. |
-| Clojure | [sci](https://github.com/borkdude/sci) | host VM's GC | EPL | An interpreter for a subset of Clojure for Clojure and ClojureScript. |
-| Common Lisp, C | [Embeddable Common Lisp](https://gitlab.com/embeddable-common-lisp/ecl) | Boehm-Weiser GC | LGPL 2+ | Full Common Lisp implementation, available as a shared library `libecl.so` embeddable in any C, C++ or other application. |
-| Common Lisp, C++ | [Clasp](https://github.com/drmeister/clasp) | MPS GC (Boehm-Weiser also supported) | LGPL 2+ | Full Common Lisp implementation well integrated with C++, using LLVM for the code generation, to integrate closely with C++ applications or libraries. |
-| Erlang | [Datalog (fogfish)](https://github.com/fogfish/datalog) | None (no collection inside interpreter state) | Apache License 2.0 | Implements Datalog. |
-| Erlang | [ephp](https://github.com/bragful/ephp) | None (no collection inside interpreter state) | LGPL 2.1 | Implements a subset of PHP 5.5. |
-| Erlang | [Erlog](https://github.com/rvirding/erlog) | None () | Apache License 2.0 | Interprets a subset of standard Prolog. |
-| Erlang | [luerl](https://github.com/rvirding/luerl) | Tracing | Apache License 2.0 | An implementation of Lua 5.2 in pure Erlang with some features like `goto` absent. |
-| Go | [Anko](https://github.com/mattn/anko/) | Go's GC | MIT | Scriptable interpreter with syntax similar to Go. |
-| Go | [Expr](https://github.com/antonmedv/expr) | Go's GC | MIT | Compiles and evaluates statically-typed expressions. |
-| Go | [Gentee](https://github.com/gentee/gentee/) | Go's GC | MIT | Statically typed. |
-| Go | [Goja](https://github.com/dop251/goja) | Go's GC | MIT | Implements ECMAScript 5.1. Better standard compliance and performance than otto. |
-| Go | [Golog](https://github.com/mndrix/golog) | Go's GC | MIT | Implements a subset of standard Prolog. |
-| Go | [Go-Lua](https://github.com/Shopify/go-lua) | Go's GC | MIT | Implements a subset of Lua 5.2. |
-| Go | [GopherLua](https://github.com/yuin/gopher-lua) | Go's GC | MIT | Implements Lua 5.1 with the added support for Go's channels. Lacks the debug hooks and several functions from the C version. |
-| Go | [otto](https://github.com/robertkrimen/otto) | Go's GC | MIT | Implements ES5 with [some limitations](https://github.com/robertkrimen/otto#caveat-emptor). |
-| Go | [Starlark (Go)](https://github.com/google/starlark-go/) | Go's GC | 3-clause BSD | A small dialect of Python for configuration. Not Turing-complete. Untrusted code: can't access the file system and network, can use up memory and CPU to perform a DoS attack. [Spec](https://github.com/bazelbuild/starlark). [Python bindings](https://github.com/caketop/python-starlark-go). |
-| Go | [zygomys](https://github.com/glycerine/zygomys) | Go's GC | 2-clause BSD | An embedded Lisp for Go. Inspired by Clojure, but more oriented towards imperative programming. Has an infix syntax layer that looks like a subset of Go. |
-| Haskell | [Dhall](https://dhall-lang.org/) | Haskell's GC | 3-clause BSD | A statically-typed functional configuration language. Not Turing-complete. Untrusted code: can't access the file system, can fetch Dhall libraries over HTTP(S) from static URLs (but libraries aren't allowed to access your data), can use up memory and CPU time for a DoS attack. Has a work-in-progress Clojure and Ruby implementation. |
-| Java | [AbcDatalog](http://abcdatalog.seas.harvard.edu/) | JVM's GC | 3-clause BSD | Implements Datalog. |
-| Java | [BeanShell](https://github.com/beanshell/beanshell/) | JVM's GC | Apache License 2.0 | An small, embeddable Java source code interpreter. Understands Java code with certain extensions like method closures. |
-| Java | [Groovy](http://groovy-lang.org/) | JVM's GC | Apache License 2.0 | A scripting language for the JVM. A large subset of Java is valid Groovy. [Integrating Groovy into applications](http://groovy-lang.org/integrating.html). |
-| Java | [JRuby](http://www.jruby.org/) | JVM's GC | Choice of EPL, GPL, and LGPL | An implementation of Ruby on the JVM. |
-| Java | [JTcl](https://github.com/jtcl-project/jtcl) | Ref. counting | Various BSD-like | Tcl 8.4 with some 8.5 features for the JVM. |
-| Java | [Jython](http://www.jython.org/) | JVM's GC | PSFL (BSD-like) | An implementation of Python on the JVM. |
-| Java | [Kawa](https://www.gnu.org/software/kawa/) | JVM's GC | MIT | R7RS. Supports the javax.script API. [Evaluating Scheme expressions from Java](https://www.gnu.org/software/kawa/Evaluating-Scheme-expressions-from-Java.html). |
-| Java | [LuaJ](https://sourceforge.net/projects/luaj/) | JVM's GC | MIT | A Lua 5.2 spec-compliant interpreter written in Java for JME and JSE. Complies Lua directly to JVM bytecode. |
-| Java | [NetRexx](http://www.netrexx.org/) | JVM's GC | ICU (BSD-like) |  |
-| Java | [Starlark (Java)](https://github.com/bazelbuild/bazel/tree/master/src/main/java/net/starlark/java) | JVM's GC | Apache License 2.0 | Starlark for the JVM. The original implementation. |
-| Object Pascal | [Pascal Script](http://www.remobjects.com/ps.aspx) | None (manual MM) | modified zlib/libpng-License with mandatory attribution | Statically typed. Implements "most of Object Pascal". Can't define new classes. |
-| Object Pascal (Delphi 2009 or later) | [DWScript](https://bitbucket.org/egrange/dwscript/) | Ref. counting + cycle-detecting tracing GC | MPL 1.1, GPL 3 (JavaScript code generator) | [Description](https://www.delphitools.info/dwscript). A statically typed Delphi/Free Pascal-like language. Can compile to JavaScript. |
-| OCaml | [Datalog (c-cube)](https://github.com/c-cube/datalog) | OCaml's GC | 2-clause BSD | Implements Datalog. |
-| OCaml | [Lua-ML](https://github.com/lindig/lua-ml) | OCaml's GC | 2-clause BSD | Embeddable Lua 2.5 reimplementation that integrates with OCaml type and module system. It's possible to extend or even replace the standard library with your own modules. |
-| Rebol, Red, Red/System | [Red](https://github.com/red/red) | Tracing | 3-clause BSD, BSL | A descendant of Rebol. Embeddable via [libRed](https://github.com/red/docs/blob/master/en/libred.adoc). Features a cross-platform native GUI system. Intended to have low memory usage. |
-| Rust | [Dyon](https://github.com/pistondevelopers/dyon) | None (Rust-style [lifetimes](http://www.piston.rs/dyon-tutorial/lifetimes.html)) | Apache License 2.0 or MIT | Has optional, optimistic (succeed-by-default) static type checking. |
-| Rust | [gluon](https://github.com/gluon-lang/gluon) | Tracing | MIT | Statically typed. Inspired by Lua, Haskell, and OCaml. Each executing gluon thread gets a separate heap. |
-| Rust | [Ketos](https://github.com/murarth/ketos) | None (no heap allocation)? | Apache License 2.0 | A functional Lisp. |
-| Rust | [Molt](https://github.com/wduquette/molt) | Ref. counting | 3-clause BSD | A minimal Tcl implementation for Rust applications and libraries. |
-| Rust | [Rhai](https://github.com/jonathandturner/rhai) | None (Rust-style lifetimes) | MIT or Apache License 2.0 | An embedded scripting language for Rust inspired by ChaiScript. |
-| Rust | [Starlark (Rust)](https://github.com/google/starlark-rust/) | ? | Apache License 2.0 | Starlark in Rust. [Python bindings](https://github.com/inducer/starlark-pyo3). |
-| Rust | [Wirefilter](https://github.com/cloudflare/wirefilter) | None (no dynamic memory allocation) | MIT | An expression language for Wireshark-like filters. |
+| Implementated in | Project name/link | Language | GC | License | Notes |
+|------------------|-------------------|----------|----|---------|-------|
+| Ada | [HAC](https://hacadacompiler.sourceforge.io/) | Ada | None (stack only) | MIT | HAC implements a subset of the Ada language. Thus, it can share sources with the embedding application. |
+| C | [Animula](https://gitlab.com/hardenedlinux/animula) | Scheme | Tracing | Compiler **GPL 3+** while VM is LGPL 3+ | An optimizing compiler and VM for embedded systems. R7RS. |
+| C | [Atlast](https://www.fourmilab.ch/atlast/) | Forth | None (manual MM) | Public domain | A dialect of Forth originally developed at Autodesk. |
+| C | [Boron](http://urlan.sourceforge.net/boron/) | Boron | Tracing | LGPL 3+ | An embeddable scripting language similar to Rebol. |
+| C | [CircuitPython](https://github.com/adafruit/circuitpython) | Python | Tracing | MIT | A fork of MicroPython, designed for API uniformity across many microcontrollers. |
+| C | [Chibi Scheme](https://github.com/ashinn/chibi-scheme) | Scheme | Tracing | 3-clause BSD | Implements R7RS small. |
+| C | [CHICKEN Scheme](https://call-cc.org/) | Scheme | Tracing | 3-clause BSD | Implements R5RS (with some [changes](http://wiki.call-cc.org/man/4/Supported%20language)). R7RS support is a work in progress. [Examples of embedding CHICKEN](https://wiki.call-cc.org/embedding). |
+| C | [Datalog (MITRE Corporation)](http://datalog.sourceforge.net/) | Datalog | Tracing (Lua's GC) | LGPL 2+ | Implements Datalog. It is implemented on top of Lua 5.3 and can be extended with Lua functions. |
+| C | [Duktape](http://duktape.org/) | Duktape | Ref. counting + cycle-detecting tracing GC | MIT | Implements JavaScript E5/E5.1. |
+| C | [Espruino](https://github.com/espruino/Espruino) | JavaScript | Tracing | MPL 2.0 | Implements a subset of JavaScript ES5 in a way suitable for embedded hardware with 8+ KiB RAM. |
+| C | [FTH](http://fth.sourceforge.net) | Forth | Tracing | 2-clause BSD | A dialect of Forth with objects, hashes, regular expressions, and other extensions. |
+| C | [Gravity](https://github.com/marcobambini/gravity) | Gravity | Tracing | MIT | A class-based concurrent scripting language with a Swift-like syntax. |
+| C | [GNU Guile](https://www.gnu.org/software/guile/) | Scheme | [Boehm](https://www.gnu.org/software/guile/manual/html_node/Conservative-GC.html) | LGPL 3+ | ["Guile mostly implements R6RS."](https://www.gnu.org/software/guile/manual/guile.html#R6RS-Support) |
+| C | [HashLink](https://hashlink.haxe.org/) | Haxe | Tracing (lazy sweep) | MIT | A bytecode interpreter and a baseline JIT compiler (x86/x86\_64 only) for [Haxe](https://haxe.org/). |
+| C | [Io](https://github.com/stevedekorte/io) | Io | Tracing | 3-clause BSD | A prototype-based OO language. |
+| C | [Janet](https://janet-lang.org/) | Janet | Tracing | MIT | A functional and imperative language with a Lisp syntax. |
+| C | [JerryScript](https://github.com/jerryscript-project/jerryscript) | JavaScript | Tracing | Apache License 2.0 | A full ECMAScript 5.1 interpreter written in C99 and optimized for low memory consumption. Uses CMake. |
+| C | [Jim Tcl](http://jim.tcl-lang.org/) | Tcl | Tracing | 2-clause BSD | Largely compatible with Tcl 8.5 with its own additions. |
+| C | [jsish](http://jsish.org/) | JavaScript | Ref. counting | MIT | A JavaScript ES 5.2+ interpreter. Internally structured after Tcl with an extensive C API. Features include subinterpreters, introspection, SQLite bindings, and a web framework with WebSocket support. The code is valid C and C++. |
+| C | [Libfawk](http://repo.hu/projects/libfawk/) | Awk, Basic, Pascal | Ref. counting | 3-clause BSD | A multi-language VM. Includes compilers for three languages: Fawk (Awk dialect), Fbas (Basic dialect), and Fpas (Pascal dialect). |
+| C | [Libmawk](http://repo.hu/projects/libmawk/) | Awk | Ref. counting | **GPL 2** | Implements Awk. A fork of mawk 1.3 restructured for embedding. |
+| C | [Lily](https://github.com/FascinatedBox/lily/) | Lily | Ref. counting + GC | MIT | A language focusing on expressiveness and safety. |
+| C | [ljs](https://github.com/mingodad/ljs) | ljs | Tracing | MIT | Lua 5.3, Lua 5.1, and LuaJIT with a C/C++/Java/JavaScript syntax. Can convert Lua source code to ljs. |
+| C | [Lua](http://lua.org/) | Lua | Tracing | MIT | The reference implementation of what is likely the world's most popular embedded scripting language. Allows you to precompile scripts to bytecode. Versions 5.1-5.3, which are the ones used today, are not fully compatible with each other. |
+| C | [LuaJIT](http://luajit.org/) | Lua | Tracing | MIT | Fully compatible with Lua 5.1. Has a built-in C FFI library. [Performance comparison](https://luajit.org/performance.html). |
+| C | [Luau](https://luau-lang.org/) | Lua | Tracing | MIT | Roblox [fork of Lua 5.1](https://luau-lang.org/why) as a scripting language for games to support a gradual type system as well as limiting the set of standard libraries exposed to the users and implements extra sandboxing features to be able to run unprivileged code. Whenever possible, Luau aims to be backwards-compatible with Lua 5.1 and at the same time to incorporate features from later revisions of Lua. |
+| C | [MicroPython](https://github.com/micropython/micropython) | Python | Tracing | MIT | Implements the Python 3.4 syntax and some of the core datatypes. |
+| C | [Mono](http://www.mono-project.com/docs/advanced/embedding/scripting/) | C#, other CLR languages | Tracing | MIT and other | Implements the [CLR](https://en.wikipedia.org/wiki/Common_Language_Runtime). |
+| C | [mruby](https://github.com/mruby/mruby) | Ruby | Tracing | MIT | A lightweight implementation of Ruby. Has a compile-time package manager. |
+| C | [mruby/c](https://github.com/mrubyc/mrubyc) | Ruby | Ref. counting | 3-clause BSD | An even smaller implementation of Ruby for microcontrollers with limited memory. |
+| C | [MuJS](https://mujs.com/) | JavaScript | Tracing | ISC | Implements JavaScript (ES5). Has a similar C interface to Lua. |
+| C | [MY-BASIC](https://github.com/paladin-t/my_basic) | Basic | Ref. counting + cycle-detecting tracing GC | MIT | A Basic dialect with prototype-based OOP. |
+| C | [Neko](http://nekovm.org/) | Haxe, others | Boehm | MIT | The NekoVM is a target for several compilers, including [Haxe](http://haxe.org/). |
+| C | [Never](https://github.com/never-lang/never) | Never | Tracing | MIT | A statically typed functional programming language. |
+| C | [njs](https://nginx.org/en/docs/njs/) | JavaScript | None (no collection performed) | 2-clause BSD | Implements a subset of ES5.1 with some ES6 extensions. |
+| C | [Pawn](http://www.compuphase.com/pawn/pawn.htm) | Pawn | None (no heap allocation) | Apache License 2.0 with a clause to explicitly permit static linking | A curly-brace language with a small-footprint VM. Represents data as 4/8-byte "cells". Compiles to CPU-specific bytecode. [More](https://wiki.alliedmods.net/Pawn_Tutorial#Language_Paradigms). |
+| C | [Perl](https://www.perl.org/) | Perl | Ref. counting | Artistic License or GPL 3 | [Embedding Perl in Another Application](https://perldoc.perl.org/perlembed) |
+| C | [pForth](http://www.softsynth.com/pforth/) | Forth | None (manual MM) | Public domain | A dialect of Forth. |
+| C | [PH7](https://github.com/symisc/PH7) | PHP | Ref. counting | **SPL** or proprietary | Implements a subset of PHP 5.3 with some changes like native UTF-8 support. |
+| C | [PicoC](https://github.com/zsaleeba/picoc) | C | None (manual MM) | 3-clause BSD | Statically typed. Interprets a subset of C. |
+| C | [Picol](https://chiselapp.com/user/dbohdan/repository/picol/) | Tcl | None (no reference support) | 2-clause BSD | A header-only library interpreter for a limited dialect of Tcl. |
+| C | [pocketlang](https://github.com/ThakeeNathees/pocketlang) | pocketlang | Tracing | MIT | A small language syntactically similar to Ruby. [Embedding examples](https://github.com/ThakeeNathees/pocketlang/tree/master/tests/native/). [Performance comparison](https://github.com/ThakeeNathees/pocketlang#performance). |
+| C | [Python](https://www.python.org/) | Python | Ref. counting + cycle-detecting tracing GC | PSFL (BSD-like) | [Embedding Python in Another Application](https://docs.python.org/3.5/extending/embedding.html). |
+| C | [QuickJS](https://bellard.org/quickjs/) | JavaScript | Ref. counting + cycle-detecting tracing GC | MIT | A small embedded JavaScript interpreter that implements almost all of ES2019 and much of ES2020. |
+| C | [Rebol](https://github.com/Oldes/Rebol3) | Rebol | Tracing | Apache License 2.0 | Relative Expression Based Object Language |
+| C | [Ring](https://github.com/ring-lang/ring) | Ring | Tracing | MIT | An embeddable applications programming language with a large standard library and GIL-less multithreading. |
+| C | [Ruby](https://www.ruby-lang.org/en/) | Ruby | Tracing | Choice of 2-clause BSD, Ruby license, GPL 2 | An embeddable object-oriented scripting language. [Running Ruby in C](https://silverhammermba.github.io/emberb/embed/). |
+| C | [s7](https://ccrma.stanford.edu/software/snd/snd/s7.html) | Scheme | Tracing | 3-clause BSD | Implements a subset of R5RS/R7RS. Descended from TinyScheme. |
+| C | [SGScript](https://github.com/snake5/sgscript) | SGScript | Ref. counting + tracing CG | MIT | [Features](http://www.sgscript.org/pages/advdocs/sgscript.docs.htm#Why-SGScript) include a built-in data serialization format, coroutines, class-based OOP, sandboxed evaluation, a built-in debugger and profiler. |
+| C | [Shine](https://github.com/richardhundt/shine) | Shine | Tracing | MIT | A language based on Lua with additional safety and expressiveness features implemented as a fork of LuaJIT. |
+| C | [Tcl](http://tcl-lang.org/) | Tcl | Ref. counting | Tcl license (BSD-like) | An embeddable general-purpose scripting language with a rich C API. Has a cross-platform GUI toolkit called [Tk](https://wiki.tcl-lang.org/477). [How to embed Tcl in C applications](https://wiki.tcl-lang.org/2074). |
+| C | [tcc](https://repo.or.cz/tinycc.git/) | C | None | LGPL 2 | A small C compiler that can be used as a library for a C JIT. [libtcc header](https://repo.or.cz/tinycc.git/blob/HEAD:/libtcc.h). [Embedding example](https://repo.or.cz/tinycc.git/blob/HEAD:/tests/libtcc_test.c). |
+| C | [TinyScheme](http://tinyscheme.sourceforge.net/) | Scheme | Tracing? | 3-clause BSD | Implements a subset of R5RS. |
+| C | [Umka](https://github.com/vtereshkov/umka-lang) | Umka | Ref. counting | 2-clause BSD | Statically typed. |
+| C | [Wren](https://github.com/munificent/wren) | Wren | Tracing | MIT | A small class-based performance-oriented scripting language. [Performance comparison](https://wren.io/performance.html). |
+| C# | [Mond](https://github.com/Rohansi/Mond/) | Mond | CLR's GC | MIT | A dynamically typed scripting language with generators, async, remote debugging, and a binding API. |
+| C# | [MoonSharp](https://www.moonsharp.org/) | Lua | CLR's GC | 3-clause BSD and other | CLR Based Lua implementation that is 99% compatible with Lua 5.2 |
+| C++ | [AngelScript](http://www.angelcode.com/angelscript/) | AngelScript | Ref. counting + cycle-detecting tracing GC | zlib | A statically typed curly brace language resembling C++ itself. |
+| C++ | [ArkScript](https://github.com/SuperFola/Ark) | ArkScript | None (resource release is destruction + optional manual MM) | MPL 2.0 | A small functional Lisp-like programming language. Separate bytecode compiler and VM. |
+| C++ | [ChaiScript](http://chaiscript.com/) | ChaiScript | Ref. counting | 3-clause BSD | A header-only C++14 interpreter library. |
+| C++ | [daScript](https://dascript.org/) | daScript | None (region-based + manual MM?) | 3-clause BSD | A statically-typed [performance-oriented](https://dascript.org/#performance) scripting language. |
+| C++ | [Falcon](http://falconpl.org/) | Falcon | Tracing | **GPL 2** or custom | The GC is pluggable. |
+| C++ | [GameMonkey Script](http://www.gmscript.com/) | GameMonkey Script | Tracing | MIT | Comes with C bindings. Similar to Lua, multithreaded. |
+| C++ | [Jsonnet](https://jsonnet.org/) | Jsonnet | Tracing | Apache License 2.0 | A functional configuration language that extends JSON. Untrusted code: can't access the file system or network, can use up memory and CPU time for a DoS attack. Has [bindings](https://jsonnet.org/ref/bindings.html) for C, C++, Go, Python, and other languages, as well as a separate native Go implementation. |
+| C++ | [ooRexx](http://www.oorexx.org/) | Rexx | Tracing | CPL | Implements Rexx extended with objects. |
+| C++ | [gmqcc/qcvm](https://github.com/graphitemaster/gmqcc) | QuakeC | None (no dynamic memory allocation) | MIT | A QuakeC compiler and VM. |
+| C++ | [Quirrel](https://github.com/GaijinEntertainment/quirrel) | Quirrel | Ref. counting | MIT | A fork of Squirrel with [new features](https://quirrel.io/doc/reference/diff_from_original.html). |
+| C++ | [SquiLu](https://github.com/mingodad/squilu) | SquiLu | Ref. counting | MIT, some extensions LGPL or GPL | A fork of [Squirrel](http://squirrel-lang.org/). Changes the syntax to accept a subset of JavaScript and C/C++. Implements Lua's features like string pattern matching and global table manipulation functions. Adds extensions for database access (SQLite3, MySQL, PostgreSQL), sockets, and other features. |
+| C++ | [Squirrel](http://squirrel-lang.org/) | Squirrel | Ref. counting | MIT | A language inspired by Lua and JavaScript/Python. Has a Lua-like C++ API. Differentiates itself from Lua with the use of reference counting in place of Lua's tracing GC, a curly-brace syntax, built-in class-based OOP, and zero-indexed arrays. |
+| C++17 | [Jinx](https://jamesboer.github.io/Jinx/) | Jinx | Ref. counting | MIT | Designed for use in realtime applications such as video games. |
+| C, Object Pascal (separate implementations) | [LIL](http://runtimeterror.com/tech/lil/) | LIL | None (no reference support) | zlib | A Tcl-like language incompatible with mainline Tcl. |
+| Clojure | [Cascalog](https://github.com/nathanmarz/cascalog) | Datalog | JVM's GC | Apache License 2.0 | Implements Datalog. |
+| Clojure | [sci](https://github.com/borkdude/sci) | Clojure | host VM's GC | EPL | An interpreter for a subset of Clojure for Clojure and ClojureScript. |
+| Common Lisp, C | [Embeddable Common Lisp](https://gitlab.com/embeddable-common-lisp/ecl) | Common Lisp | Boehm-Weiser GC | LGPL 2+ | Full Common Lisp implementation, available as a shared library `libecl.so` embeddable in any C, C++ or other application. |
+| Common Lisp, C++ | [Clasp](https://github.com/drmeister/clasp) | Common Lisp | MPS GC (Boehm-Weiser also supported) | LGPL 2+ | Full Common Lisp implementation well integrated with C++, using LLVM for the code generation, to integrate closely with C++ applications or libraries. |
+| Erlang | [Datalog (fogfish)](https://github.com/fogfish/datalog) | Datalog | None (no collection inside interpreter state) | Apache License 2.0 | Implements Datalog. |
+| Erlang | [ephp](https://github.com/bragful/ephp) | PHP | None (no collection inside interpreter state) | LGPL 2.1 | Implements a subset of PHP 5.5. |
+| Erlang | [Erlog](https://github.com/rvirding/erlog) | Prolog | None () | Apache License 2.0 | Interprets a subset of standard Prolog. |
+| Erlang | [luerl](https://github.com/rvirding/luerl) | Lua | Tracing | Apache License 2.0 | An implementation of Lua 5.2 in pure Erlang with some features like `goto` absent. |
+| Go | [Anko](https://github.com/mattn/anko/) | Anko | Go's GC | MIT | Scriptable interpreter with syntax similar to Go. |
+| Go | [Expr](https://github.com/antonmedv/expr) | Expr | Go's GC | MIT | Compiles and evaluates statically-typed expressions. |
+| Go | [Gentee](https://github.com/gentee/gentee/) | Gentee | Go's GC | MIT | Statically typed. |
+| Go | [Goja](https://github.com/dop251/goja) | JavaScript | Go's GC | MIT | Implements ECMAScript 5.1. Better standard compliance and performance than otto. |
+| Go | [Golog](https://github.com/mndrix/golog) | Prolog | Go's GC | MIT | Implements a subset of standard Prolog. |
+| Go | [Go-Lua](https://github.com/Shopify/go-lua) | Lua | Go's GC | MIT | Implements a subset of Lua 5.2. |
+| Go | [GopherLua](https://github.com/yuin/gopher-lua) | Lua | Go's GC | MIT | Implements Lua 5.1 with the added support for Go's channels. Lacks the debug hooks and several functions from the C version. |
+| Go | [otto](https://github.com/robertkrimen/otto) | JavaScript | Go's GC | MIT | Implements ES5 with [some limitations](https://github.com/robertkrimen/otto#caveat-emptor). |
+| Go | [Starlark (Go)](https://github.com/google/starlark-go/) | Starlark | Go's GC | 3-clause BSD | A small dialect of Python for configuration. Not Turing-complete. Untrusted code: can't access the file system and network, can use up memory and CPU to perform a DoS attack. [Spec](https://github.com/bazelbuild/starlark). [Python bindings](https://github.com/caketop/python-starlark-go). |
+| Go | [zygomys](https://github.com/glycerine/zygomys) | zygomys | Go's GC | 2-clause BSD | An embedded Lisp for Go. Inspired by Clojure, but more oriented towards imperative programming. Has an infix syntax layer that looks like a subset of Go. |
+| Haskell | [Dhall](https://dhall-lang.org/) | Dhall | Haskell's GC | 3-clause BSD | A statically-typed functional configuration language. Not Turing-complete. Untrusted code: can't access the file system, can fetch Dhall libraries over HTTP(S) from static URLs (but libraries aren't allowed to access your data), can use up memory and CPU time for a DoS attack. Has a work-in-progress Clojure and Ruby implementation. |
+| Java | [AbcDatalog](http://abcdatalog.seas.harvard.edu/) | Datalog | JVM's GC | 3-clause BSD | Implements Datalog. |
+| Java | [BeanShell](https://github.com/beanshell/beanshell/) | Java | JVM's GC | Apache License 2.0 | An small, embeddable Java source code interpreter. Understands Java code with certain extensions like method closures. |
+| Java | [Groovy](http://groovy-lang.org/) | Groovy | JVM's GC | Apache License 2.0 | A scripting language for the JVM. A large subset of Java is valid Groovy. [Integrating Groovy into applications](http://groovy-lang.org/integrating.html). |
+| Java | [JRuby](http://www.jruby.org/) | Ruby | JVM's GC | Choice of EPL, GPL, and LGPL | An implementation of Ruby on the JVM. |
+| Java | [JTcl](https://github.com/jtcl-project/jtcl) | Tcl | Ref. counting | Various BSD-like | Tcl 8.4 with some 8.5 features for the JVM. |
+| Java | [Jython](http://www.jython.org/) | Python | JVM's GC | PSFL (BSD-like) | An implementation of Python on the JVM. |
+| Java | [Kawa](https://www.gnu.org/software/kawa/) | Scheme | JVM's GC | MIT | R7RS. Supports the javax.script API. [Evaluating Scheme expressions from Java](https://www.gnu.org/software/kawa/Evaluating-Scheme-expressions-from-Java.html). |
+| Java | [LuaJ](https://sourceforge.net/projects/luaj/) | Lua | JVM's GC | MIT | A Lua 5.2 spec-compliant interpreter written in Java for JME and JSE. Complies Lua directly to JVM bytecode. |
+| Java | [NetRexx](http://www.netrexx.org/) | Rexx | JVM's GC | ICU (BSD-like) |  |
+| Java | [Starlark (Java)](https://github.com/bazelbuild/bazel/tree/master/src/main/java/net/starlark/java) | Starlark | JVM's GC | Apache License 2.0 | Starlark for the JVM. The original implementation. |
+| Object Pascal | [Pascal Script](http://www.remobjects.com/ps.aspx) | Pascal | None (manual MM) | modified zlib/libpng-License with mandatory attribution | Statically typed. Implements "most of Object Pascal". Can't define new classes. |
+| Object Pascal (Delphi 2009 or later) | [DWScript](https://bitbucket.org/egrange/dwscript/) | DWScript | Ref. counting + cycle-detecting tracing GC | MPL 1.1, GPL 3 (JavaScript code generator) | [Description](https://www.delphitools.info/dwscript). A statically typed Delphi/Free Pascal-like language. Can compile to JavaScript. |
+| OCaml | [Datalog (c-cube)](https://github.com/c-cube/datalog) | Datalog | OCaml's GC | 2-clause BSD | Implements Datalog. |
+| OCaml | [Lua-ML](https://github.com/lindig/lua-ml) | Lua | OCaml's GC | 2-clause BSD | Embeddable Lua 2.5 reimplementation that integrates with OCaml type and module system. It's possible to extend or even replace the standard library with your own modules. |
+| Rebol, Red, Red/System | [Red](https://github.com/red/red) | Red | Tracing | 3-clause BSD, BSL | A descendant of Rebol. Embeddable via [libRed](https://github.com/red/docs/blob/master/en/libred.adoc). Features a cross-platform native GUI system. Intended to have low memory usage. |
+| Rust | [Dyon](https://github.com/pistondevelopers/dyon) | Dyon | None (Rust-style [lifetimes](http://www.piston.rs/dyon-tutorial/lifetimes.html)) | Apache License 2.0 or MIT | Has optional, optimistic (succeed-by-default) static type checking. |
+| Rust | [gluon](https://github.com/gluon-lang/gluon) | gluon | Tracing | MIT | Statically typed. Inspired by Lua, Haskell, and OCaml. Each executing gluon thread gets a separate heap. |
+| Rust | [Ketos](https://github.com/murarth/ketos) | Ketos | None (no heap allocation)? | Apache License 2.0 | A functional Lisp. |
+| Rust | [Molt](https://github.com/wduquette/molt) | Tcl | Ref. counting | 3-clause BSD | A minimal Tcl implementation for Rust applications and libraries. |
+| Rust | [Rhai](https://github.com/jonathandturner/rhai) | Rhai | None (Rust-style lifetimes) | MIT or Apache License 2.0 | An embedded scripting language for Rust inspired by ChaiScript. |
+| Rust | [Starlark (Rust)](https://github.com/google/starlark-rust/) | Starlark | ? | Apache License 2.0 | Starlark in Rust. [Python bindings](https://github.com/inducer/starlark-pyo3). |
+| Rust | [Wirefilter](https://github.com/cloudflare/wirefilter) | Wirefilter | None (no dynamic memory allocation) | MIT | An expression language for Wireshark-like filters. |
 
 ## See also
 

README.md.njk

@@ -6,20 +6,20 @@ The following is a list of reasonably mature open source [embedded scripting lan
 
 {{ toc }}
 
-## Sorted alphabetically
+## Sorted by interpreted language
 
-| Project name/link | Implementation language | GC | License | Notes |
-|-------------------|-------------------------|----|---------|-------|
-{% for proj in projects | sort(false, false, "sort_key") %}
-| [{{ proj.name }}]({{ proj.url }}) | {{ proj.impl_lang }} | {{ proj.gc }} | {{ proj.license }} | {{ proj.notes | safe }} |
+| Language | Project name/link | Implementated in | GC | License | Notes |
+|----------|-------------------|------------------|----|---------|-------|
+{% for proj in projects | sort(false, false, "lang") %}
+| {{ proj.lang }} | [{{ proj.name }}]({{ proj.url }}) | {{ proj.impl_in }} | {{ proj.gc }} | {{ proj.license }} | {{ proj.notes | safe }} |
 {% endfor %}
 
 ## Sorted by implementation language
 
-| Implementation language | Project name/link | GC | License | Notes |
-|-------------------------|-------------------|----|---------|-------|
-{% for proj in projects | sort(false, false, "impl_lang") %}
-| {{ proj.impl_lang }} | [{{ proj.name }}]({{ proj.url }}) | {{ proj.gc }} | {{ proj.license }} | {{ proj.notes | safe }} |
+| Implementated in | Project name/link | Language | GC | License | Notes |
+|------------------|-------------------|----------|----|---------|-------|
+{% for proj in projects | sort(false, false, "impl_in") %}
+| {{ proj.impl_in }} | [{{ proj.name }}]({{ proj.url }}) | {{ proj.lang }} | {{ proj.gc }} | {{ proj.license }} | {{ proj.notes | safe }} |
 {% endfor %}
 
 ## See also

data/projects.toml

@@ -1,7 +1,7 @@
 [AbcDatalog]
 url = "http://abcdatalog.seas.harvard.edu/"
 lang = "Datalog"
-impl_lang = "Java"
+impl_in = "Java"
 gc = "JVM's GC"
 license = "3-clause BSD"
 notes = "Implements Datalog."
@@ -9,7 +9,7 @@ notes = "Implements Datalog."
 [AngelScript]
 url = "http://www.angelcode.com/angelscript/"
 lang = "AngelScript"
-impl_lang = "C++"
+impl_in = "C++"
 gc = "Ref. counting + cycle-detecting tracing GC"
 license = "zlib"
 notes = "A statically typed curly brace language resembling C++ itself."
@@ -17,7 +17,7 @@ notes = "A statically typed curly brace language resembling C++ itself."
 [Animula]
 url = "https://gitlab.com/hardenedlinux/animula"
 lang = "Scheme"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "Compiler **GPL 3+** while VM is LGPL 3+"
 notes = "An optimizing compiler and VM for embedded systems. R7RS."
@@ -25,7 +25,7 @@ notes = "An optimizing compiler and VM for embedded systems. R7RS."
 [Anko]
 url = "https://github.com/mattn/anko/"
 lang = "Anko"
-impl_lang = "Go"
+impl_in = "Go"
 gc = "Go's GC"
 license = "MIT"
 notes = "Scriptable interpreter with syntax similar to Go."
@@ -33,7 +33,7 @@ notes = "Scriptable interpreter with syntax similar to Go."
 [ArkScript]
 url = "https://github.com/SuperFola/Ark"
 lang = "ArkScript"
-impl_lang = "C++"
+impl_in = "C++"
 gc = "None (resource release is destruction + optional manual MM)"
 license = "MPL 2.0"
 notes = "A small functional Lisp-like programming language. Separate bytecode compiler and VM."
@@ -41,7 +41,7 @@ notes = "A small functional Lisp-like programming language. Separate bytecode co
 [Atlast]
 url = "https://www.fourmilab.ch/atlast/"
 lang = "Forth"
-impl_lang = "C"
+impl_in = "C"
 gc = "None (manual MM)"
 license = "Public domain"
 notes = "A dialect of Forth originally developed at Autodesk."
@@ -49,7 +49,7 @@ notes = "A dialect of Forth originally developed at Autodesk."
 [BeanShell]
 url = "https://github.com/beanshell/beanshell/"
 lang = "Java"
-impl_lang = "Java"
+impl_in = "Java"
 gc = "JVM's GC"
 license = "Apache License 2.0"
 notes = "An small, embeddable Java source code interpreter. Understands Java code with certain extensions like method closures."
@@ -57,7 +57,7 @@ notes = "An small, embeddable Java source code interpreter. Understands Java cod
 [Boron]
 url = "http://urlan.sourceforge.net/boron/"
 lang = "Boron"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "LGPL 3+"
 notes = "An embeddable scripting language similar to Rebol."
@@ -65,7 +65,7 @@ notes = "An embeddable scripting language similar to Rebol."
 [Cascalog]
 url = "https://github.com/nathanmarz/cascalog"
 lang = "Datalog"
-impl_lang = "Clojure"
+impl_in = "Clojure"
 gc = "JVM's GC"
 license = "Apache License 2.0"
 notes = "Implements Datalog."
@@ -73,7 +73,7 @@ notes = "Implements Datalog."
 [CircuitPython]
 url = "https://github.com/adafruit/circuitpython"
 lang = "Python"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "MIT"
 notes = "A fork of MicroPython, designed for API uniformity across many microcontrollers."
@@ -81,7 +81,7 @@ notes = "A fork of MicroPython, designed for API uniformity across many microcon
 [ChaiScript]
 url = "http://chaiscript.com/"
 lang = "ChaiScript"
-impl_lang = "C++"
+impl_in = "C++"
 gc = "Ref. counting"
 license = "3-clause BSD"
 notes = "A header-only C++14 interpreter library."
@@ -89,7 +89,7 @@ notes = "A header-only C++14 interpreter library."
 ["Chibi Scheme"]
 url = "https://github.com/ashinn/chibi-scheme"
 lang = "Scheme"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "3-clause BSD"
 notes = "Implements R7RS small."
@@ -97,7 +97,7 @@ notes = "Implements R7RS small."
 ["CHICKEN Scheme"]
 url = "https://call-cc.org/"
 lang = "Scheme"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "3-clause BSD"
 notes = "Implements R5RS (with some [changes](http://wiki.call-cc.org/man/4/Supported%20language)). R7RS support is a work in progress. [Examples of embedding CHICKEN](https://wiki.call-cc.org/embedding)."
@@ -105,7 +105,7 @@ notes = "Implements R5RS (with some [changes](http://wiki.call-cc.org/man/4/Supp
 [Clasp]
 url = "https://github.com/drmeister/clasp"
 lang = "Common Lisp"
-impl_lang = "Common Lisp, C++"
+impl_in = "Common Lisp, C++"
 gc = "MPS GC (Boehm-Weiser also supported)"
 license = "LGPL 2+"
 notes = "Full Common Lisp implementation well integrated with C++, using LLVM for the code generation, to integrate closely with C++ applications or libraries."
@@ -113,7 +113,7 @@ notes = "Full Common Lisp implementation well integrated with C++, using LLVM fo
 [daScript]
 url = "https://dascript.org/"
 lang = "daScript"
-impl_lang = "C++"
+impl_in = "C++"
 gc = "None (region-based + manual MM?)"
 license = "3-clause BSD"
 notes = "A statically-typed [performance-oriented](https://dascript.org/#performance) scripting language."
@@ -121,7 +121,7 @@ notes = "A statically-typed [performance-oriented](https://dascript.org/#perform
 ["Datalog (c-cube)"]
 url = "https://github.com/c-cube/datalog"
 lang = "Datalog"
-impl_lang = "OCaml"
+impl_in = "OCaml"
 gc = "OCaml's GC"
 license = "2-clause BSD"
 notes = "Implements Datalog."
@@ -129,7 +129,7 @@ notes = "Implements Datalog."
 ["Datalog (fogfish)"]
 url = "https://github.com/fogfish/datalog"
 lang = "Datalog"
-impl_lang = "Erlang"
+impl_in = "Erlang"
 gc = "None (no collection inside interpreter state)"
 license = "Apache License 2.0"
 notes = "Implements Datalog."
@@ -137,7 +137,7 @@ notes = "Implements Datalog."
 ["Datalog (MITRE Corporation)"]
 url = "http://datalog.sourceforge.net/"
 lang = "Datalog"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing (Lua's GC)"
 license = "LGPL 2+"
 notes = "Implements Datalog. It is implemented on top of Lua 5.3 and can be extended with Lua functions."
@@ -145,7 +145,7 @@ notes = "Implements Datalog. It is implemented on top of Lua 5.3 and can be exte
 [Dhall]
 url = "https://dhall-lang.org/"
 lang = "Dhall"
-impl_lang = "Haskell"
+impl_in = "Haskell"
 gc = "Haskell's GC"
 license = "3-clause BSD"
 notes = "A statically-typed functional configuration language. Not Turing-complete. Untrusted code: can't access the file system, can fetch Dhall libraries over HTTP(S) from static URLs (but libraries aren't allowed to access your data), can use up memory and CPU time for a DoS attack. Has a work-in-progress Clojure and Ruby implementation."
@@ -153,7 +153,7 @@ notes = "A statically-typed functional configuration language. Not Turing-comple
 [Duktape]
 url = "http://duktape.org/"
 lang = "Duktape"
-impl_lang = "C"
+impl_in = "C"
 gc = "Ref. counting + cycle-detecting tracing GC"
 license = "MIT"
 notes = "Implements JavaScript E5/E5.1."
@@ -161,7 +161,7 @@ notes = "Implements JavaScript E5/E5.1."
 [DWScript]
 url = "https://bitbucket.org/egrange/dwscript/"
 lang = "DWScript"
-impl_lang = "Object Pascal (Delphi 2009 or later)"
+impl_in = "Object Pascal (Delphi 2009 or later)"
 gc = "Ref. counting + cycle-detecting tracing GC"
 license = "MPL 1.1, GPL 3 (JavaScript code generator)"
 notes = "[Description](https://www.delphitools.info/dwscript). A statically typed Delphi/Free Pascal-like language. Can compile to JavaScript."
@@ -169,7 +169,7 @@ notes = "[Description](https://www.delphitools.info/dwscript). A statically type
 [Dyon]
 url = "https://github.com/pistondevelopers/dyon"
 lang = "Dyon"
-impl_lang = "Rust"
+impl_in = "Rust"
 gc = "None (Rust-style [lifetimes](http://www.piston.rs/dyon-tutorial/lifetimes.html))"
 license = "Apache License 2.0 or MIT"
 notes = "Has optional, optimistic (succeed-by-default) static type checking."
@@ -177,7 +177,7 @@ notes = "Has optional, optimistic (succeed-by-default) static type checking."
 ["Embeddable Common Lisp"]
 url = "https://gitlab.com/embeddable-common-lisp/ecl"
 lang = "Common Lisp"
-impl_lang = "Common Lisp, C"
+impl_in = "Common Lisp, C"
 gc = "Boehm-Weiser GC"
 license = "LGPL 2+"
 notes = "Full Common Lisp implementation, available as a shared library `libecl.so` embeddable in any C, C++ or other application."
@@ -185,7 +185,7 @@ notes = "Full Common Lisp implementation, available as a shared library `libecl.
 [ephp]
 url = "https://github.com/bragful/ephp"
 lang = "PHP"
-impl_lang = "Erlang"
+impl_in = "Erlang"
 gc = "None (no collection inside interpreter state)"
 license = "LGPL 2.1"
 notes = "Implements a subset of PHP 5.5."
@@ -193,7 +193,7 @@ notes = "Implements a subset of PHP 5.5."
 [Erlog]
 url = "https://github.com/rvirding/erlog"
 lang = "Prolog"
-impl_lang = "Erlang"
+impl_in = "Erlang"
 gc = "None ()"
 license = "Apache License 2.0"
 notes = "Interprets a subset of standard Prolog."
@@ -201,7 +201,7 @@ notes = "Interprets a subset of standard Prolog."
 [Espruino]
 url = "https://github.com/espruino/Espruino"
 lang = "JavaScript"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "MPL 2.0"
 notes = "Implements a subset of JavaScript ES5 in a way suitable for embedded hardware with 8+ KiB RAM."
@@ -209,7 +209,7 @@ notes = "Implements a subset of JavaScript ES5 in a way suitable for embedded ha
 [Expr]
 url = "https://github.com/antonmedv/expr"
 lang = "Expr"
-impl_lang = "Go"
+impl_in = "Go"
 gc = "Go's GC"
 license = "MIT"
 notes = "Compiles and evaluates statically-typed expressions."
@@ -217,7 +217,7 @@ notes = "Compiles and evaluates statically-typed expressions."
 [Falcon]
 url = "http://falconpl.org/"
 lang = "Falcon"
-impl_lang = "C++"
+impl_in = "C++"
 gc = "Tracing"
 license = "**GPL 2** or custom"
 notes = "The GC is pluggable."
@@ -225,7 +225,7 @@ notes = "The GC is pluggable."
 [FTH]
 url = "http://fth.sourceforge.net"
 lang = "Forth"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "2-clause BSD"
 notes = "A dialect of Forth with objects, hashes, regular expressions, and other extensions."
@@ -233,7 +233,7 @@ notes = "A dialect of Forth with objects, hashes, regular expressions, and other
 ["GameMonkey Script"]
 url = "http://www.gmscript.com/"
 lang = "GameMonkey Script"
-impl_lang = "C++"
+impl_in = "C++"
 gc = "Tracing"
 license = "MIT"
 notes = "Comes with C bindings. Similar to Lua, multithreaded."
@@ -241,7 +241,7 @@ notes = "Comes with C bindings. Similar to Lua, multithreaded."
 [Gentee]
 url = "https://github.com/gentee/gentee/"
 lang = "Gentee"
-impl_lang = "Go"
+impl_in = "Go"
 gc = "Go's GC"
 license = "MIT"
 notes = "Statically typed."
@@ -249,7 +249,7 @@ notes = "Statically typed."
 [gluon]
 url = "https://github.com/gluon-lang/gluon"
 lang = "gluon"
-impl_lang = "Rust"
+impl_in = "Rust"
 gc = "Tracing"
 license = "MIT"
 notes = "Statically typed. Inspired by Lua, Haskell, and OCaml. Each executing gluon thread gets a separate heap."
@@ -257,7 +257,7 @@ notes = "Statically typed. Inspired by Lua, Haskell, and OCaml. Each executing g
 [Goja]
 url = "https://github.com/dop251/goja"
 lang = "JavaScript"
-impl_lang = "Go"
+impl_in = "Go"
 gc = "Go's GC"
 license = "MIT"
 notes = "Implements ECMAScript 5.1. Better standard compliance and performance than otto."
@@ -265,7 +265,7 @@ notes = "Implements ECMAScript 5.1. Better standard compliance and performance t
 [Golog]
 url = "https://github.com/mndrix/golog"
 lang = "Prolog"
-impl_lang = "Go"
+impl_in = "Go"
 gc = "Go's GC"
 license = "MIT"
 notes = "Implements a subset of standard Prolog."
@@ -273,7 +273,7 @@ notes = "Implements a subset of standard Prolog."
 [Go-Lua]
 url = "https://github.com/Shopify/go-lua"
 lang = "Lua"
-impl_lang = "Go"
+impl_in = "Go"
 gc = "Go's GC"
 license = "MIT"
 notes = "Implements a subset of Lua 5.2."
@@ -281,7 +281,7 @@ notes = "Implements a subset of Lua 5.2."
 [GopherLua]
 url = "https://github.com/yuin/gopher-lua"
 lang = "Lua"
-impl_lang = "Go"
+impl_in = "Go"
 gc = "Go's GC"
 license = "MIT"
 notes = "Implements Lua 5.1 with the added support for Go's channels. Lacks the debug hooks and several functions from the C version."
@@ -289,7 +289,7 @@ notes = "Implements Lua 5.1 with the added support for Go's channels. Lacks the
 [Gravity]
 url = "https://github.com/marcobambini/gravity"
 lang = "Gravity"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "MIT"
 notes = "A class-based concurrent scripting language with a Swift-like syntax."
@@ -297,7 +297,7 @@ notes = "A class-based concurrent scripting language with a Swift-like syntax."
 [Groovy]
 url = "http://groovy-lang.org/"
 lang = "Groovy"
-impl_lang = "Java"
+impl_in = "Java"
 gc = "JVM's GC"
 license = "Apache License 2.0"
 notes = "A scripting language for the JVM. A large subset of Java is valid Groovy. [Integrating Groovy into applications](http://groovy-lang.org/integrating.html)."
@@ -305,7 +305,7 @@ notes = "A scripting language for the JVM. A large subset of Java is valid Groov
 ["GNU Guile"]
 url = "https://www.gnu.org/software/guile/"
 lang = "Scheme"
-impl_lang = "C"
+impl_in = "C"
 gc = "[Boehm](https://www.gnu.org/software/guile/manual/html_node/Conservative-GC.html)"
 license = "LGPL 3+"
 notes = "[\"Guile mostly implements R6RS.\"](https://www.gnu.org/software/guile/manual/guile.html#R6RS-Support)"
@@ -313,7 +313,7 @@ notes = "[\"Guile mostly implements R6RS.\"](https://www.gnu.org/software/guile/
 [HAC]
 url = "https://hacadacompiler.sourceforge.io/"
 lang = "Ada"
-impl_lang = "Ada"
+impl_in = "Ada"
 gc = "None (stack only)"
 license = "MIT"
 notes = "HAC implements a subset of the Ada language. Thus, it can share sources with the embedding application."
@@ -321,7 +321,7 @@ notes = "HAC implements a subset of the Ada language. Thus, it can share sources
 [HashLink]
 url = "https://hashlink.haxe.org/"
 lang = "Haxe"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing (lazy sweep)"
 license = "MIT"
 notes = "A bytecode interpreter and a baseline JIT compiler (x86/x86\\_64 only) for [Haxe](https://haxe.org/)."
@@ -329,7 +329,7 @@ notes = "A bytecode interpreter and a baseline JIT compiler (x86/x86\\_64 only)
 [Io]
 url = "https://github.com/stevedekorte/io"
 lang = "Io"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "3-clause BSD"
 notes = "A prototype-based OO language."
@@ -337,7 +337,7 @@ notes = "A prototype-based OO language."
 [Janet]
 url = "https://janet-lang.org/"
 lang = "Janet"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "MIT"
 notes = "A functional and imperative language with a Lisp syntax."
@@ -345,7 +345,7 @@ notes = "A functional and imperative language with a Lisp syntax."
 [JerryScript]
 url = "https://github.com/jerryscript-project/jerryscript"
 lang = "JavaScript"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "Apache License 2.0"
 notes = "A full ECMAScript 5.1 interpreter written in C99 and optimized for low memory consumption. Uses CMake."
@@ -353,7 +353,7 @@ notes = "A full ECMAScript 5.1 interpreter written in C99 and optimized for low
 ["Jim Tcl"]
 url = "http://jim.tcl-lang.org/"
 lang = "Tcl"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "2-clause BSD"
 notes = "Largely compatible with Tcl 8.5 with its own additions."
@@ -361,7 +361,7 @@ notes = "Largely compatible with Tcl 8.5 with its own additions."
 [Jinx]
 url = "https://jamesboer.github.io/Jinx/"
 lang = "Jinx"
-impl_lang = "C++17"
+impl_in = "C++17"
 gc = "Ref. counting"
 license = "MIT"
 notes = "Designed for use in realtime applications such as video games."
@@ -369,7 +369,7 @@ notes = "Designed for use in realtime applications such as video games."
 [JRuby]
 url = "http://www.jruby.org/"
 lang = "Ruby"
-impl_lang = "Java"
+impl_in = "Java"
 gc = "JVM's GC"
 license = "Choice of EPL, GPL, and LGPL"
 notes = "An implementation of Ruby on the JVM."
@@ -377,7 +377,7 @@ notes = "An implementation of Ruby on the JVM."
 [jsish]
 url = "http://jsish.org/"
 lang = "JavaScript"
-impl_lang = "C"
+impl_in = "C"
 gc = "Ref. counting"
 license = "MIT"
 notes = "A JavaScript ES 5.2+ interpreter. Internally structured after Tcl with an extensive C API. Features include subinterpreters, introspection, SQLite bindings, and a web framework with WebSocket support. The code is valid C and C++."
@@ -385,7 +385,7 @@ notes = "A JavaScript ES 5.2+ interpreter. Internally structured after Tcl with
 [Jsonnet]
 url = "https://jsonnet.org/"
 lang = "Jsonnet"
-impl_lang = "C++"
+impl_in = "C++"
 gc = "Tracing"
 license = "Apache License 2.0"
 notes = "A functional configuration language that extends JSON. Untrusted code: can't access the file system or network, can use up memory and CPU time for a DoS attack. Has [bindings](https://jsonnet.org/ref/bindings.html) for C, C++, Go, Python, and other languages, as well as a separate native Go implementation."
@@ -393,7 +393,7 @@ notes = "A functional configuration language that extends JSON. Untrusted code:
 [JTcl]
 url = "https://github.com/jtcl-project/jtcl"
 lang = "Tcl"
-impl_lang = "Java"
+impl_in = "Java"
 gc = "Ref. counting"
 license = "Various BSD-like"
 notes = "Tcl 8.4 with some 8.5 features for the JVM."
@@ -401,7 +401,7 @@ notes = "Tcl 8.4 with some 8.5 features for the JVM."
 [Jython]
 url = "http://www.jython.org/"
 lang = "Python"
-impl_lang = "Java"
+impl_in = "Java"
 gc = "JVM's GC"
 license = "PSFL (BSD-like)"
 notes = "An implementation of Python on the JVM."
@@ -409,7 +409,7 @@ notes = "An implementation of Python on the JVM."
 [Kawa]
 url = "https://www.gnu.org/software/kawa/"
 lang = "Scheme"
-impl_lang = "Java"
+impl_in = "Java"
 gc = "JVM's GC"
 license = "MIT"
 notes = "R7RS. Supports the javax.script API. [Evaluating Scheme expressions from Java](https://www.gnu.org/software/kawa/Evaluating-Scheme-expressions-from-Java.html)."
@@ -417,7 +417,7 @@ notes = "R7RS. Supports the javax.script API. [Evaluating Scheme expressions fro
 [Ketos]
 url = "https://github.com/murarth/ketos"
 lang = "Ketos"
-impl_lang = "Rust"
+impl_in = "Rust"
 gc = "None (no heap allocation)?"
 license = "Apache License 2.0"
 notes = "A functional Lisp."
@@ -425,7 +425,7 @@ notes = "A functional Lisp."
 [Libfawk]
 url = "http://repo.hu/projects/libfawk/"
 lang = "Awk, Basic, Pascal"
-impl_lang = "C"
+impl_in = "C"
 gc = "Ref. counting"
 license = "3-clause BSD"
 notes = "A multi-language VM. Includes compilers for three languages: Fawk (Awk dialect), Fbas (Basic dialect), and Fpas (Pascal dialect)."
@@ -433,7 +433,7 @@ notes = "A multi-language VM. Includes compilers for three languages: Fawk (Awk
 [Libmawk]
 url = "http://repo.hu/projects/libmawk/"
 lang = "Awk"
-impl_lang = "C"
+impl_in = "C"
 gc = "Ref. counting"
 license = "**GPL 2**"
 notes = "Implements Awk. A fork of mawk 1.3 restructured for embedding."
@@ -441,7 +441,7 @@ notes = "Implements Awk. A fork of mawk 1.3 restructured for embedding."
 [LIL]
 url = "http://runtimeterror.com/tech/lil/"
 lang = "LIL"
-impl_lang = "C, Object Pascal (separate implementations)"
+impl_in = "C, Object Pascal (separate implementations)"
 gc = "None (no reference support)"
 license = "zlib"
 notes = "A Tcl-like language incompatible with mainline Tcl."
@@ -449,7 +449,7 @@ notes = "A Tcl-like language incompatible with mainline Tcl."
 [Lily]
 url = "https://github.com/FascinatedBox/lily/"
 lang = "Lily"
-impl_lang = "C"
+impl_in = "C"
 gc = "Ref. counting + GC"
 license = "MIT"
 notes = "A language focusing on expressiveness and safety."
@@ -457,7 +457,7 @@ notes = "A language focusing on expressiveness and safety."
 [ljs]
 url = "https://github.com/mingodad/ljs"
 lang = "ljs"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "MIT"
 notes = "Lua 5.3, Lua 5.1, and LuaJIT with a C/C++/Java/JavaScript syntax. Can convert Lua source code to ljs."
@@ -465,7 +465,7 @@ notes = "Lua 5.3, Lua 5.1, and LuaJIT with a C/C++/Java/JavaScript syntax. Can c
 [Lua]
 url = "http://lua.org/"
 lang = "Lua"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "MIT"
 notes = "The reference implementation of what is likely the world's most popular embedded scripting language. Allows you to precompile scripts to bytecode. Versions 5.1-5.3, which are the ones used today, are not fully compatible with each other."
@@ -473,7 +473,7 @@ notes = "The reference implementation of what is likely the world's most popular
 [LuaJ]
 url = "https://sourceforge.net/projects/luaj/"
 lang = "Lua"
-impl_lang = "Java"
+impl_in = "Java"
 gc = "JVM's GC"
 license = "MIT"
 notes = "A Lua 5.2 spec-compliant interpreter written in Java for JME and JSE. Complies Lua directly to JVM bytecode."
@@ -481,7 +481,7 @@ notes = "A Lua 5.2 spec-compliant interpreter written in Java for JME and JSE. C
 [LuaJIT]
 url = "http://luajit.org/"
 lang = "Lua"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "MIT"
 notes = "Fully compatible with Lua 5.1. Has a built-in C FFI library. [Performance comparison](https://luajit.org/performance.html)."
@@ -489,7 +489,7 @@ notes = "Fully compatible with Lua 5.1. Has a built-in C FFI library. [Performan
 [Lua-ML]
 url = "https://github.com/lindig/lua-ml"
 lang = "Lua"
-impl_lang = "OCaml"
+impl_in = "OCaml"
 gc = "OCaml's GC"
 license = "2-clause BSD"
 notes = "Embeddable Lua 2.5 reimplementation that integrates with OCaml type and module system. It's possible to extend or even replace the standard library with your own modules."
@@ -497,7 +497,7 @@ notes = "Embeddable Lua 2.5 reimplementation that integrates with OCaml type and
 [Luau]
 url = "https://luau-lang.org/"
 lang = "Lua"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "MIT"
 notes = "Roblox [fork of Lua 5.1](https://luau-lang.org/why) as a scripting language for games to support a gradual type system as well as limiting the set of standard libraries exposed to the users and implements extra sandboxing features to be able to run unprivileged code. Whenever possible, Luau aims to be backwards-compatible with Lua 5.1 and at the same time to incorporate features from later revisions of Lua."
@@ -505,7 +505,7 @@ notes = "Roblox [fork of Lua 5.1](https://luau-lang.org/why) as a scripting lang
 [luerl]
 url = "https://github.com/rvirding/luerl"
 lang = "Lua"
-impl_lang = "Erlang"
+impl_in = "Erlang"
 gc = "Tracing"
 license = "Apache License 2.0"
 notes = "An implementation of Lua 5.2 in pure Erlang with some features like `goto` absent."
@@ -513,7 +513,7 @@ notes = "An implementation of Lua 5.2 in pure Erlang with some features like `go
 [MicroPython]
 url = "https://github.com/micropython/micropython"
 lang = "Python"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "MIT"
 notes = "Implements the Python 3.4 syntax and some of the core datatypes."
@@ -521,7 +521,7 @@ notes = "Implements the Python 3.4 syntax and some of the core datatypes."
 [Molt]
 url = "https://github.com/wduquette/molt"
 lang = "Tcl"
-impl_lang = "Rust"
+impl_in = "Rust"
 gc = "Ref. counting"
 license = "3-clause BSD"
 notes = "A minimal Tcl implementation for Rust applications and libraries."
@@ -529,7 +529,7 @@ notes = "A minimal Tcl implementation for Rust applications and libraries."
 [Mond]
 url = "https://github.com/Rohansi/Mond/"
 lang = "Mond"
-impl_lang = "C#"
+impl_in = "C#"
 gc = "CLR's GC"
 license = "MIT"
 notes = "A dynamically typed scripting language with generators, async, remote debugging, and a binding API."
@@ -537,7 +537,7 @@ notes = "A dynamically typed scripting language with generators, async, remote d
 [Mono]
 url = "http://www.mono-project.com/docs/advanced/embedding/scripting/"
 lang = "C#, other CLR languages"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "MIT and other"
 notes = "Implements the [CLR](https://en.wikipedia.org/wiki/Common_Language_Runtime)."
@@ -545,7 +545,7 @@ notes = "Implements the [CLR](https://en.wikipedia.org/wiki/Common_Language_Runt
 [MoonSharp]
 url = "https://www.moonsharp.org/"
 lang = "Lua"
-impl_lang = "C#"
+impl_in = "C#"
 gc = "CLR's GC"
 license = "3-clause BSD and other"
 notes = "CLR Based Lua implementation that is 99% compatible with Lua 5.2"
@@ -553,7 +553,7 @@ notes = "CLR Based Lua implementation that is 99% compatible with Lua 5.2"
 [mruby]
 url = "https://github.com/mruby/mruby"
 lang = "Ruby"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "MIT"
 notes = "A lightweight implementation of Ruby. Has a compile-time package manager."
@@ -561,7 +561,7 @@ notes = "A lightweight implementation of Ruby. Has a compile-time package manage
 ["mruby/c"]
 url = "https://github.com/mrubyc/mrubyc"
 lang = "Ruby"
-impl_lang = "C"
+impl_in = "C"
 gc = "Ref. counting"
 license = "3-clause BSD"
 notes = "An even smaller implementation of Ruby for microcontrollers with limited memory."
@@ -569,7 +569,7 @@ notes = "An even smaller implementation of Ruby for microcontrollers with limite
 [MuJS]
 url = "https://mujs.com/"
 lang = "JavaScript"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "ISC"
 notes = "Implements JavaScript (ES5). Has a similar C interface to Lua."
@@ -577,7 +577,7 @@ notes = "Implements JavaScript (ES5). Has a similar C interface to Lua."
 [MY-BASIC]
 url = "https://github.com/paladin-t/my_basic"
 lang = "Basic"
-impl_lang = "C"
+impl_in = "C"
 gc = "Ref. counting + cycle-detecting tracing GC"
 license = "MIT"
 notes = "A Basic dialect with prototype-based OOP."
@@ -585,7 +585,7 @@ notes = "A Basic dialect with prototype-based OOP."
 [Neko]
 url = "http://nekovm.org/"
 lang = "Haxe, others"
-impl_lang = "C"
+impl_in = "C"
 gc = "Boehm"
 license = "MIT"
 notes = "The NekoVM is a target for several compilers, including [Haxe](http://haxe.org/)."
@@ -593,7 +593,7 @@ notes = "The NekoVM is a target for several compilers, including [Haxe](http://h
 [NetRexx]
 url = "http://www.netrexx.org/"
 lang = "Rexx"
-impl_lang = "Java"
+impl_in = "Java"
 gc = "JVM's GC"
 license = "ICU (BSD-like)"
 notes = ""
@@ -601,7 +601,7 @@ notes = ""
 [Never]
 url = "https://github.com/never-lang/never"
 lang = "Never"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "MIT"
 notes = "A statically typed functional programming language."
@@ -609,7 +609,7 @@ notes = "A statically typed functional programming language."
 [njs]
 url = "https://nginx.org/en/docs/njs/"
 lang = "JavaScript"
-impl_lang = "C"
+impl_in = "C"
 gc = "None (no collection performed)"
 license = "2-clause BSD"
 notes = "Implements a subset of ES5.1 with some ES6 extensions."
@@ -617,7 +617,7 @@ notes = "Implements a subset of ES5.1 with some ES6 extensions."
 [ooRexx]
 url = "http://www.oorexx.org/"
 lang = "Rexx"
-impl_lang = "C++"
+impl_in = "C++"
 gc = "Tracing"
 license = "CPL"
 notes = "Implements Rexx extended with objects."
@@ -625,7 +625,7 @@ notes = "Implements Rexx extended with objects."
 [otto]
 url = "https://github.com/robertkrimen/otto"
 lang = "JavaScript"
-impl_lang = "Go"
+impl_in = "Go"
 gc = "Go's GC"
 license = "MIT"
 notes = "Implements ES5 with [some limitations](https://github.com/robertkrimen/otto#caveat-emptor)."
@@ -633,7 +633,7 @@ notes = "Implements ES5 with [some limitations](https://github.com/robertkrimen/
 ["Pascal Script"]
 url = "http://www.remobjects.com/ps.aspx"
 lang = "Pascal"
-impl_lang = "Object Pascal"
+impl_in = "Object Pascal"
 gc = "None (manual MM)"
 license = "modified zlib/libpng-License with mandatory attribution"
 notes = "Statically typed. Implements \"most of Object Pascal\". Can't define new classes."
@@ -641,7 +641,7 @@ notes = "Statically typed. Implements \"most of Object Pascal\". Can't define ne
 [Pawn]
 url = "http://www.compuphase.com/pawn/pawn.htm"
 lang = "Pawn"
-impl_lang = "C"
+impl_in = "C"
 gc = "None (no heap allocation)"
 license = "Apache License 2.0 with a clause to explicitly permit static linking"
 notes = "A curly-brace language with a small-footprint VM. Represents data as 4/8-byte \"cells\". Compiles to CPU-specific bytecode. [More](https://wiki.alliedmods.net/Pawn_Tutorial#Language_Paradigms)."
@@ -649,7 +649,7 @@ notes = "A curly-brace language with a small-footprint VM. Represents data as 4/
 [Perl]
 url = "https://www.perl.org/"
 lang = "Perl"
-impl_lang = "C"
+impl_in = "C"
 gc = "Ref. counting"
 license = "Artistic License or GPL 3"
 notes = "[Embedding Perl in Another Application](https://perldoc.perl.org/perlembed)"
@@ -657,7 +657,7 @@ notes = "[Embedding Perl in Another Application](https://perldoc.perl.org/perlem
 [pForth]
 url = "http://www.softsynth.com/pforth/"
 lang = "Forth"
-impl_lang = "C"
+impl_in = "C"
 gc = "None (manual MM)"
 license = "Public domain"
 notes = "A dialect of Forth."
@@ -665,7 +665,7 @@ notes = "A dialect of Forth."
 [PH7]
 url = "https://github.com/symisc/PH7"
 lang = "PHP"
-impl_lang = "C"
+impl_in = "C"
 gc = "Ref. counting"
 license = "**SPL** or proprietary"
 notes = "Implements a subset of PHP 5.3 with some changes like native UTF-8 support."
@@ -673,7 +673,7 @@ notes = "Implements a subset of PHP 5.3 with some changes like native UTF-8 supp
 [PicoC]
 url = "https://github.com/zsaleeba/picoc"
 lang = "C"
-impl_lang = "C"
+impl_in = "C"
 gc = "None (manual MM)"
 license = "3-clause BSD"
 notes = "Statically typed. Interprets a subset of C."
@@ -681,7 +681,7 @@ notes = "Statically typed. Interprets a subset of C."
 [Picol]
 url = "https://chiselapp.com/user/dbohdan/repository/picol/"
 lang = "Tcl"
-impl_lang = "C"
+impl_in = "C"
 gc = "None (no reference support)"
 license = "2-clause BSD"
 notes = "A header-only library interpreter for a limited dialect of Tcl."
@@ -689,7 +689,7 @@ notes = "A header-only library interpreter for a limited dialect of Tcl."
 [pocketlang]
 url = "https://github.com/ThakeeNathees/pocketlang"
 lang = "pocketlang"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "MIT"
 notes = "A small language syntactically similar to Ruby. [Embedding examples](https://github.com/ThakeeNathees/pocketlang/tree/master/tests/native/). [Performance comparison](https://github.com/ThakeeNathees/pocketlang#performance)."
@@ -697,7 +697,7 @@ notes = "A small language syntactically similar to Ruby. [Embedding examples](ht
 [Python]
 url = "https://www.python.org/"
 lang = "Python"
-impl_lang = "C"
+impl_in = "C"
 gc = "Ref. counting + cycle-detecting tracing GC"
 license = "PSFL (BSD-like)"
 notes = "[Embedding Python in Another Application](https://docs.python.org/3.5/extending/embedding.html)."
@@ -705,7 +705,7 @@ notes = "[Embedding Python in Another Application](https://docs.python.org/3.5/e
 ["gmqcc/qcvm"]
 url = "https://github.com/graphitemaster/gmqcc"
 lang = "QuakeC"
-impl_lang = "C++"
+impl_in = "C++"
 gc = "None (no dynamic memory allocation)"
 license = "MIT"
 notes = "A QuakeC compiler and VM."
@@ -713,7 +713,7 @@ notes = "A QuakeC compiler and VM."
 [QuickJS]
 url = "https://bellard.org/quickjs/"
 lang = "JavaScript"
-impl_lang = "C"
+impl_in = "C"
 gc = "Ref. counting + cycle-detecting tracing GC"
 license = "MIT"
 notes = "A small embedded JavaScript interpreter that implements almost all of ES2019 and much of ES2020."
@@ -721,7 +721,7 @@ notes = "A small embedded JavaScript interpreter that implements almost all of E
 [Quirrel]
 url = "https://github.com/GaijinEntertainment/quirrel"
 lang = "Quirrel"
-impl_lang = "C++"
+impl_in = "C++"
 gc = "Ref. counting"
 license = "MIT"
 notes = "A fork of Squirrel with [new features](https://quirrel.io/doc/reference/diff_from_original.html)."
@@ -729,7 +729,7 @@ notes = "A fork of Squirrel with [new features](https://quirrel.io/doc/reference
 [Rebol]
 url = "https://github.com/Oldes/Rebol3"
 lang = "Rebol"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "Apache License 2.0"
 notes = "Relative Expression Based Object Language"
@@ -737,7 +737,7 @@ notes = "Relative Expression Based Object Language"
 [Red]
 url = "https://github.com/red/red"
 lang = "Red"
-impl_lang = "Rebol, Red, Red/System"
+impl_in = "Rebol, Red, Red/System"
 gc = "Tracing"
 license = "3-clause BSD, BSL"
 notes = "A descendant of Rebol. Embeddable via [libRed](https://github.com/red/docs/blob/master/en/libred.adoc). Features a cross-platform native GUI system. Intended to have low memory usage."
@@ -745,7 +745,7 @@ notes = "A descendant of Rebol. Embeddable via [libRed](https://github.com/red/d
 [Rhai]
 url = "https://github.com/jonathandturner/rhai"
 lang = "Rhai"
-impl_lang = "Rust"
+impl_in = "Rust"
 gc = "None (Rust-style lifetimes)"
 license = "MIT or Apache License 2.0"
 notes = "An embedded scripting language for Rust inspired by ChaiScript."
@@ -753,7 +753,7 @@ notes = "An embedded scripting language for Rust inspired by ChaiScript."
 [Ring]
 url = "https://github.com/ring-lang/ring"
 lang = "Ring"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "MIT"
 notes = "An embeddable applications programming language with a large standard library and GIL-less multithreading."
@@ -761,7 +761,7 @@ notes = "An embeddable applications programming language with a large standard l
 [Ruby]
 url = "https://www.ruby-lang.org/en/"
 lang = "Ruby"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "Choice of 2-clause BSD, Ruby license, GPL 2"
 notes = "An embeddable object-oriented scripting language. [Running Ruby in C](https://silverhammermba.github.io/emberb/embed/)."
@@ -769,7 +769,7 @@ notes = "An embeddable object-oriented scripting language. [Running Ruby in C](h
 [s7]
 url = "https://ccrma.stanford.edu/software/snd/snd/s7.html"
 lang = "Scheme"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "3-clause BSD"
 notes = "Implements a subset of R5RS/R7RS. Descended from TinyScheme."
@@ -777,7 +777,7 @@ notes = "Implements a subset of R5RS/R7RS. Descended from TinyScheme."
 [sci]
 url = "https://github.com/borkdude/sci"
 lang = "Clojure"
-impl_lang = "Clojure"
+impl_in = "Clojure"
 gc = "host VM's GC"
 license = "EPL"
 notes = "An interpreter for a subset of Clojure for Clojure and ClojureScript."
@@ -785,7 +785,7 @@ notes = "An interpreter for a subset of Clojure for Clojure and ClojureScript."
 [SGScript]
 url = "https://github.com/snake5/sgscript"
 lang = "SGScript"
-impl_lang = "C"
+impl_in = "C"
 gc = "Ref. counting + tracing CG"
 license = "MIT"
 notes = "[Features](http://www.sgscript.org/pages/advdocs/sgscript.docs.htm#Why-SGScript) include a built-in data serialization format, coroutines, class-based OOP, sandboxed evaluation, a built-in debugger and profiler."
@@ -793,7 +793,7 @@ notes = "[Features](http://www.sgscript.org/pages/advdocs/sgscript.docs.htm#Why-
 [Shine]
 url = "https://github.com/richardhundt/shine"
 lang = "Shine"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "MIT"
 notes = "A language based on Lua with additional safety and expressiveness features implemented as a fork of LuaJIT."
@@ -801,7 +801,7 @@ notes = "A language based on Lua with additional safety and expressiveness featu
 [SquiLu]
 url = "https://github.com/mingodad/squilu"
 lang = "SquiLu"
-impl_lang = "C++"
+impl_in = "C++"
 gc = "Ref. counting"
 license = "MIT, some extensions LGPL or GPL"
 notes = "A fork of [Squirrel](http://squirrel-lang.org/). Changes the syntax to accept a subset of JavaScript and C/C++. Implements Lua's features like string pattern matching and global table manipulation functions. Adds extensions for database access (SQLite3, MySQL, PostgreSQL), sockets, and other features."
@@ -809,7 +809,7 @@ notes = "A fork of [Squirrel](http://squirrel-lang.org/). Changes the syntax to
 [Squirrel]
 url = "http://squirrel-lang.org/"
 lang = "Squirrel"
-impl_lang = "C++"
+impl_in = "C++"
 gc = "Ref. counting"
 license = "MIT"
 notes = "A language inspired by Lua and JavaScript/Python. Has a Lua-like C++ API. Differentiates itself from Lua with the use of reference counting in place of Lua's tracing GC, a curly-brace syntax, built-in class-based OOP, and zero-indexed arrays."
@@ -817,7 +817,7 @@ notes = "A language inspired by Lua and JavaScript/Python. Has a Lua-like C++ AP
 ["Starlark (Go)"]
 url = "https://github.com/google/starlark-go/"
 lang = "Starlark"
-impl_lang = "Go"
+impl_in = "Go"
 gc = "Go's GC"
 license = "3-clause BSD"
 notes = "A small dialect of Python for configuration. Not Turing-complete. Untrusted code: can't access the file system and network, can use up memory and CPU to perform a DoS attack. [Spec](https://github.com/bazelbuild/starlark). [Python bindings](https://github.com/caketop/python-starlark-go)."
@@ -825,7 +825,7 @@ notes = "A small dialect of Python for configuration. Not Turing-complete. Untru
 ["Starlark (Java)"]
 url = "https://github.com/bazelbuild/bazel/tree/master/src/main/java/net/starlark/java"
 lang = "Starlark"
-impl_lang = "Java"
+impl_in = "Java"
 gc = "JVM's GC"
 license = "Apache License 2.0"
 notes = "Starlark for the JVM. The original implementation."
@@ -833,7 +833,7 @@ notes = "Starlark for the JVM. The original implementation."
 ["Starlark (Rust)"]
 url = "https://github.com/google/starlark-rust/"
 lang = "Starlark"
-impl_lang = "Rust"
+impl_in = "Rust"
 gc = "?"
 license = "Apache License 2.0"
 notes = "Starlark in Rust. [Python bindings](https://github.com/inducer/starlark-pyo3)."
@@ -841,7 +841,7 @@ notes = "Starlark in Rust. [Python bindings](https://github.com/inducer/starlark
 [Tcl]
 url = "http://tcl-lang.org/"
 lang = "Tcl"
-impl_lang = "C"
+impl_in = "C"
 gc = "Ref. counting"
 license = "Tcl license (BSD-like)"
 notes = "An embeddable general-purpose scripting language with a rich C API. Has a cross-platform GUI toolkit called [Tk](https://wiki.tcl-lang.org/477). [How to embed Tcl in C applications](https://wiki.tcl-lang.org/2074)."
@@ -849,7 +849,7 @@ notes = "An embeddable general-purpose scripting language with a rich C API. Has
 [tcc]
 url = "https://repo.or.cz/tinycc.git/"
 lang = "C"
-impl_lang = "C"
+impl_in = "C"
 gc = "None"
 license = "LGPL 2"
 notes = "A small C compiler that can be used as a library for a C JIT. [libtcc header](https://repo.or.cz/tinycc.git/blob/HEAD:/libtcc.h). [Embedding example](https://repo.or.cz/tinycc.git/blob/HEAD:/tests/libtcc_test.c)."
@@ -857,7 +857,7 @@ notes = "A small C compiler that can be used as a library for a C JIT. [libtcc h
 [TinyScheme]
 url = "http://tinyscheme.sourceforge.net/"
 lang = "Scheme"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing?"
 license = "3-clause BSD"
 notes = "Implements a subset of R5RS."
@@ -865,7 +865,7 @@ notes = "Implements a subset of R5RS."
 [Umka]
 url = "https://github.com/vtereshkov/umka-lang"
 lang = "Umka"
-impl_lang = "C"
+impl_in = "C"
 gc = "Ref. counting"
 license = "2-clause BSD"
 notes = "Statically typed."
@@ -873,7 +873,7 @@ notes = "Statically typed."
 [Wirefilter]
 url = "https://github.com/cloudflare/wirefilter"
 lang = "Wirefilter"
-impl_lang = "Rust"
+impl_in = "Rust"
 gc = "None (no dynamic memory allocation)"
 license = "MIT"
 notes = "An expression language for Wireshark-like filters."
@@ -881,7 +881,7 @@ notes = "An expression language for Wireshark-like filters."
 [Wren]
 url = "https://github.com/munificent/wren"
 lang = "Wren"
-impl_lang = "C"
+impl_in = "C"
 gc = "Tracing"
 license = "MIT"
 notes = "A small class-based performance-oriented scripting language. [Performance comparison](https://wren.io/performance.html)."
@@ -889,7 +889,7 @@ notes = "A small class-based performance-oriented scripting language. [Performan
 [zygomys]
 url = "https://github.com/glycerine/zygomys"
 lang = "zygomys"
-impl_lang = "Go"
+impl_in = "Go"
 gc = "Go's GC"
 license = "2-clause BSD"
 notes = "An embedded Lisp for Go. Inspired by Clojure, but more oriented towards imperative programming. Has an infix syntax layer that looks like a subset of Go."