Update information about the current state of BQN development

6 files changed, 21 insertions, 31 deletions

diff --git a/README.md b/README.md
index f69131cb..16b5ffc3 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 # BQN: finally, an APL for your flying saucer
 
-*This repository does not yet have a working implementation. However, there are some incomplete implementations you can use, with one you can try online [here](https://mlochbaum.github.io/BQN2NGN/web/index.html). See [running.md](running.md) for more.*
+*Try it [here](https://mlochbaum.github.io/BQN/try.html)! The online version is mainly good for small programs currently; see [running.md](running.md) for more options.*
 
 **BQN** is a new programming language in the APL lineage, which aims to remove inconsistent and burdensome aspects of the APL tradition and put the great ideas on a firmer footing. BQN is aimed at existing and aspiring APL-family programmers, and using it requires a solid understanding of functions and multidimensional arrays. However, because of its focus on providing simple, consistent, and powerful array operations, BQN should also be a good language for learning array programming and building stronger array intuition.
 
@@ -32,7 +32,7 @@ Rather strange, most likely:
 
         ⊑+`∘⌽⍟12↕2  # The 12th Fibonacci number
 
-For longer samples, you can [gaze into the abyss](c.bqn) that is the (incomplete) self-hosted compiler, or take a look at the friendlier [markdown processor](md.bqn) used to format and highlight documentation files. There are also [some translations](examples/fifty.bqn) from ["A History of APL in 50 Functions"](https://www.jsoftware.com/papers/50/) here.
+For longer samples, you can [gaze into the abyss](src/c.bqn) that is the self-hosted compiler, or the [shallower but wider abyss](src/r.bqn) of the runtime, or take a look at the friendlier [markdown processor](md.bqn) used to format and highlight documentation files. There are also [some translations](examples/fifty.bqn) from ["A History of APL in 50 Functions"](https://www.jsoftware.com/papers/50/) here.
 
 ## Array model
 
diff --git a/doc/group.md b/doc/group.md
index e043e5ca..17e05850 100644
--- a/doc/group.md
+++ b/doc/group.md
@@ -4,12 +4,6 @@
 
 BQN replaces the [Key](https://aplwiki.com/wiki/Key) operator from J or Dyalog APL, and [many forms of partitioning](https://aplwiki.com/wiki/Partition_representations), with a single (ambivalent) Group function `⊔`. This function is somewhat related to the K function `=` of the same name, but results in an array rather than a dictionary.
 
-The BQN prototype does not implement this function: instead it uses `⊔` for a Group/Key function very similar to `{⊂⍵}⌸` in Dyalog APL, and also has a Cut function `\`. The new BQN Group on numeric arguments (equivalently, rank-1 results) can be defined like this:
-
-    ⊔↩((↕1+(>⌈´))=¨<)∘⊣ /¨⟜< ↕∘≠⍠⊢
-
-Once defined, the old BQN Key (dyadic) is `⍷⊸⊐⊸⊔` and Group (monadic) is `⍷⊸⊐⊔↕∘≠` using the Deduplicate or Unique Cells function `⍷` (BQN2NGN spells it `∪`). Cut on matching-length arguments is `` +`⊸⊔ ``.
-
 ## Definition
 
 Group operates on a numeric list of indices and an array, treated as a list of its major cells or "values", to produce a list of groups, each of which is a selection from those cells. The two arrays have the same length, and each value cell is paired with the index at the same position. That index indicates the result group the cell should go into, with an "index" of ¯1 indicating that it should be dropped and not appear in the result.
diff --git a/docs/doc/group.html b/docs/doc/group.html
index 2ec68f63..7f85ea48 100644
--- a/docs/doc/group.html
+++ b/docs/doc/group.html
@@ -2,10 +2,6 @@
 <div class="nav"><a href="https://github.com/mlochbaum/BQN">BQN</a></div>
 <h1 id="group">Group</h1>
 <p>BQN replaces the <a href="https://aplwiki.com/wiki/Key">Key</a> operator from J or Dyalog APL, and <a href="https://aplwiki.com/wiki/Partition_representations">many forms of partitioning</a>, with a single (ambivalent) Group function <code><span class='Function'>⊔</span></code>. This function is somewhat related to the K function <code><span class='Function'>=</span></code> of the same name, but results in an array rather than a dictionary.</p>
-<p>The BQN prototype does not implement this function: instead it uses <code><span class='Function'>⊔</span></code> for a Group/Key function very similar to <code><span class='Brace'>{</span><span class='Value'>⊂⍵</span><span class='Brace'>}</span><span class='Value'>⌸</span></code> in Dyalog APL, and also has a Cut function <code><span class='Value'>\</span></code>. The new BQN Group on numeric arguments (equivalently, rank-1 results) can be defined like this:</p>
-<pre><span class='Function'>⊔</span><span class='Gets'>↩</span><span class='Paren'>((</span><span class='Function'>↕</span><span class='Number'>1</span><span class='Function'>+</span><span class='Paren'>(</span><span class='Function'>&gt;⌈</span><span class='Modifier'>´</span><span class='Paren'>))</span><span class='Function'>=</span><span class='Modifier'>¨</span><span class='Function'>&lt;</span><span class='Paren'>)</span><span class='Modifier2'>∘</span><span class='Function'>⊣</span> <span class='Function'>/</span><span class='Modifier'>¨</span><span class='Modifier2'>⟜</span><span class='Function'>&lt;</span> <span class='Function'>↕</span><span class='Modifier2'>∘</span><span class='Function'>≠</span><span class='Value'>⍠</span><span class='Function'>⊢</span>
-</pre>
-<p>Once defined, the old BQN Key (dyadic) is <code><span class='Function'>⍷</span><span class='Modifier2'>⊸</span><span class='Function'>⊐</span><span class='Modifier2'>⊸</span><span class='Function'>⊔</span></code> and Group (monadic) is <code><span class='Function'>⍷</span><span class='Modifier2'>⊸</span><span class='Function'>⊐⊔↕</span><span class='Modifier2'>∘</span><span class='Function'>≠</span></code> using the Deduplicate or Unique Cells function <code><span class='Function'>⍷</span></code> (BQN2NGN spells it <code><span class='Value'>∪</span></code>). Cut on matching-length arguments is <code><span class='Function'>+</span><span class='Modifier'>`</span><span class='Modifier2'>⊸</span><span class='Function'>⊔</span></code>.</p>
 <h2 id="definition">Definition</h2>
 <p>Group operates on a numeric list of indices and an array, treated as a list of its major cells or &quot;values&quot;, to produce a list of groups, each of which is a selection from those cells. The two arrays have the same length, and each value cell is paired with the index at the same position. That index indicates the result group the cell should go into, with an &quot;index&quot; of ¯1 indicating that it should be dropped and not appear in the result.</p>
 <pre>    <span class='Number'>0</span><span class='Ligature'>‿</span><span class='Number'>1</span><span class='Ligature'>‿</span><span class='Number'>2</span><span class='Ligature'>‿</span><span class='Number'>0</span><span class='Ligature'>‿</span><span class='Number'>1</span> <span class='Function'>≍</span> <span class='String'>&quot;abcde&quot;</span>  <span class='Comment'># Corresponding indices and values
diff --git a/docs/index.html b/docs/index.html
index 9a783767..2f5f3edb 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,7 +1,7 @@
 <head><link href="style.css" rel="stylesheet"/></head>
 <div class="nav"><a href="https://github.com/mlochbaum/BQN">BQN</a></div>
 <h1 id="bqn-finally-an-apl-for-your-flying-saucer">BQN: finally, an APL for your flying saucer</h1>
-<p><em>This repository does not yet have a working implementation. However, there are some incomplete implementations you can use, with one you can try online <a href="https://mlochbaum.github.io/BQN2NGN/web/index.html">here</a>. See <a href="running.html">running.md</a> for more.</em></p>
+<p><em>Try it <a href="https://mlochbaum.github.io/BQN/try.html">here</a>! The online version is mainly good for small programs currently; see <a href="running.html">running.md</a> for more options.</em></p>
 <p><strong>BQN</strong> is a new programming language in the APL lineage, which aims to remove inconsistent and burdensome aspects of the APL tradition and put the great ideas on a firmer footing. BQN is aimed at existing and aspiring APL-family programmers, and using it requires a solid understanding of functions and multidimensional arrays. However, because of its focus on providing simple, consistent, and powerful array operations, BQN should also be a good language for learning array programming and building stronger array intuition.</p>
 <p>BQN maintains many of the ideas that made APL\360 revolutionary in 1966:</p>
 <ul>
@@ -29,7 +29,7 @@
 <pre>    <span class='Function'>⊑+</span><span class='Modifier'>`</span><span class='Modifier2'>∘</span><span class='Function'>⌽</span><span class='Modifier2'>⍟</span><span class='Number'>12</span><span class='Function'>↕</span><span class='Number'>2</span>  <span class='Comment'># The 12th Fibonacci number
 </span>144
 </pre>
-<p>For longer samples, you can <a href="https://github.com/mlochbaum/BQN/blob/master/c.bqn">gaze into the abyss</a> that is the (incomplete) self-hosted compiler, or take a look at the friendlier <a href="https://github.com/mlochbaum/BQN/blob/master/md.bqn">markdown processor</a> used to format and highlight documentation files. There are also <a href="https://github.com/mlochbaum/BQN/blob/master/examples/fifty.bqn">some translations</a> from <a href="https://www.jsoftware.com/papers/50/">&quot;A History of APL in 50 Functions&quot;</a> here.</p>
+<p>For longer samples, you can <a href="https://github.com/mlochbaum/BQN/blob/master/src/c.bqn">gaze into the abyss</a> that is the self-hosted compiler, or the <a href="https://github.com/mlochbaum/BQN/blob/master/src/r.bqn">shallower but wider abyss</a> of the runtime, or take a look at the friendlier <a href="https://github.com/mlochbaum/BQN/blob/master/md.bqn">markdown processor</a> used to format and highlight documentation files. There are also <a href="https://github.com/mlochbaum/BQN/blob/master/examples/fifty.bqn">some translations</a> from <a href="https://www.jsoftware.com/papers/50/">&quot;A History of APL in 50 Functions&quot;</a> here.</p>
 <h2 id="array-model">Array model</h2>
 <p>Most of BQN's functionality deals with the manipulation of multidimensional arrays. However, it discards many of the complications of traditional APL <a href="https://aplwiki.com/wiki/Array_model">array models</a>. Unlike in APL, non-array data is possible, and common: numbers, characters, and functions are not arrays (see the full list of <a href="#types">types</a> below). This avoids some difficulties that show up when trying to treat scalar arrays as the fundamental unit; in particular, there is no &quot;floating&quot; so a value is always different from a scalar array that contains it. This system has been <a href="https://dl.acm.org/doi/abs/10.1145/586656.586663">proposed</a> in APL's past under the name <strong>based array theory</strong>.</p>
 <p>Currently, the intention is that arrays will not have prototypes, so that all empty arrays of the same shape behave identically. Different elements of an array should not influence each other. While some APLs force numbers placed in the same array to a common representation, which may have different precision properties, BQN will enforce 64-bit floating-point precision, and only use representations or methods compatible with it (for example, integers up to 32 bits).</p>
diff --git a/docs/running.html b/docs/running.html
index 6a5a356a..ca02f587 100644
--- a/docs/running.html
+++ b/docs/running.html
@@ -1,21 +1,21 @@
 <head><link href="style.css" rel="stylesheet"/></head>
 <div class="nav"><a href="https://github.com/mlochbaum/BQN">BQN</a></div>
 <h1 id="how-to-run-bqn">How to run BQN</h1>
-<p>BQN is in a very early stage of development, and there is currently no complete implementation of the language. However, it's a relatively simple language to implement, and a few implementations come close.</p>
-<h3 id="bqn2ngn">BQN2NGN</h3>
-<p><a href="https://github.com/mlochbaum/BQN2NGN">BQN2NGN</a> is a prototype implementation in Javascript build to experiment with the langauge, which is now abandoned. Because you can <a href="https://mlochbaum.github.io/BQN2NGN/web/index.html">use it online</a>, this is probably the quickest way to get started with BQN. It has good primitive support, with the main issues being that it has no Fold and Insert is spelled <code><span class='Modifier'>´</span></code> even though current BQN uses <code><span class='Modifier'>˝</span></code>, that it has a different version of <a href="doc/group.html">Group</a> (<code><span class='Function'>⊔</span></code>), and that it is missing Choose (<code><span class='Modifier2'>◶</span></code>). There are also some spelling differences, with Deduplicate (<code><span class='Function'>⍷</span></code>) spelled with <code><span class='Value'>∪</span></code> and Valences (<code><span class='Modifier2'>⊘</span></code>) spelled with <code><span class='Value'>⍠</span></code>. It is missing value blocks and function headers.</p>
-<p>For automated testing I run BQN2NGN using the <code><span class='Value'>bqn</span></code> executable, which is just a symlink to <code><span class='Value'>apl.js</span></code> in the BQN2NGN repository. It requires Node to run.</p>
+<p>BQN is in an early stage of development, and no implementation is complete yet. However, it's a relatively simple language to implement, and a few implementations come close. At the moment, dzaima/BQN is the most usable version, with good performance and error reporting.</p>
+<h3 id="bqn">BQN</h3>
+<p>This repository contains a BQN implementation written mainly in BQN: the bytecode <a href="https://github.com/mlochbaum/BQN/blob/master/src/c.bqn">compiler</a> is completely self-hosted, and the <a href="https://github.com/mlochbaum/BQN/blob/master/src/r.bqn">majority of the runtime</a> is written in BQN except that it is allowed to define primitives; some preprocessing turns the primitives into identifiers. The remaining part, a VM, can be implemented in any language to obtain a version of BQN running in that language. A <a href="https://github.com/mlochbaum/BQN/blob/master/docs/bqn.js">Javascript implementation</a> allows BQN to be run as a REPL (running locally) from <a href="https://mlochbaum.github.io/BQN/try.html">this webpage</a> or in Node.js as a library. The bytecode is also the same as dzaima/BQN's format, and <a href="https://github.com/mlochbaum/BQN/blob/master/c.bqn">another version</a> of the compiler runs on and targets dzaima+reference BQN. This version also contains an earlier experiment targetting <a href="https://en.wikipedia.org/wiki/WebAssembly">WebAssembly</a> that works only on a very small subset of BQN.</p>
+<p>This version is not yet suitable for serious programming. The runtime checks for errors but the compiler does not, so syntax errors go unreported. It does not yet support function headers or multiple bodies. The Javascript-based compiler is also slow, taking about 0.05 seconds plus 1 second per kilobyte of source (this is purely due to the slow runtime, as dzaima+reference achieves 3ms/kB with the same compiler once warmed up).</p>
+<p>All versions have automated tests in the <a href="https://github.com/mlochbaum/BQN/blob/master/test/">test</a> directory, with the self-hosted version (<a href="https://github.com/mlochbaum/BQN/blob/master/test/tj.js">test/tj.js</a>) and WebAssembly backend  (<a href="https://github.com/mlochbaum/BQN/blob/master/test/t.js">test/t.js</a>) tested with Javascript using Node and the dzaima/BQN backend tested with BQN itself (<a href="https://github.com/mlochbaum/BQN/blob/master/test/bt">test/bt</a>).</p>
 <h3 id="dzaimabqn">dzaima/BQN</h3>
 <p><a href="https://github.com/dzaima/BQN/">dzaima/BQN</a> is an implementation in Java created by modifying the existing dzaima/APL. It should be easy to run on desktop Linux and Android. It is still in development and has almost complete syntax support but incomplete primitive support.</p>
 <h3 id="dzaimareference-bqn">dzaima+reference BQN</h3>
-<p>This repository contains a dzaima/BQN script <code><span class='Value'>dzref</span></code> that fills in the gaps in primitive support using BQN implementations of primitives which are not yet up to spec (<a href="https://github.com/mlochbaum/BQN/blob/master/spec/reference.bqn">reference implementations</a> of all primitives starting from a small set of pre-existing functions are part of BQN's specification). These alternate implementations can be slow.</p>
+<p>This repository contains a dzaima/BQN script <code><span class='Value'>dzref</span></code> that fills in the gaps in primitive support using BQN implementations of primitives that are not yet up to spec (<a href="https://github.com/mlochbaum/BQN/blob/master/spec/reference.bqn">reference implementations</a> of all primitives starting from a small set of pre-existing functions are part of BQN's specification).</p>
 <p>You can run <code><span class='Value'>dzref</span></code> from ordinary dzaima/BQN using the <code><span class='Value'>•</span><span class='Function'>EX</span></code> command; see for example <a href="https://github.com/mlochbaum/BQN/blob/master/cshim.bqn">cshim.bqn</a>. For testing, it is run as a Unix script, in which case it depends on an executable <code><span class='Value'>dbqn</span></code> that runs dzaima/BQN on a file argument. I use the following script, using the path to a clone of dzaima/BQN for the jar file.</p>
 <pre><span class='Comment'>#! /bin/bash
 </span>
 <span class='Value'>java</span> <span class='Function'>-</span><span class='Value'>jar</span> <span class='Function'>/</span><span class='Value'>path</span><span class='Function'>/</span><span class='Value'>to</span><span class='Function'>/</span><span class='Value'>dzaima</span><span class='Function'>/BQN/BQN.jar</span> <span class='Function'>-</span><span class='Value'>f</span> <span class='String'>&quot;$@&quot;</span>
 </pre>
 <p>The left argument for <code><span class='Value'>•</span><span class='Function'>EX</span></code> or the shell arguments can contain up to two arguments for the script. The first is a file to run, and the second is BQN code to be run after it.</p>
-<h3 id="bqn">BQN</h3>
-<p>This repository contains the beginnings of a self-hosted compiler for BQN, which is not yet complete enough to do any real programming with. There are currently several versions of the compiler: <a href="https://github.com/mlochbaum/BQN/blob/master/nc.bqn">nc.bqn</a> is run with BQN2NGN, while <a href="https://github.com/mlochbaum/BQN/blob/master/c.bqn">c.bqn</a> is run with dzaima+reference. Both compilers have a simple backend targetting <a href="https://en.wikipedia.org/wiki/WebAssembly">WebAssembly</a>, and c.bqn additionally has a backend that targets dzaima/BQN's own bytecode, so that the compiler uses only BQN, but the runtime uses the Java implementations of BQN primitives from dzaima/BQN. The bytecode compiler has almost complete expression support and also supports blocks, but not headers or multiple bodies.</p>
-<p>All versions have automated tests in the <a href="https://github.com/mlochbaum/BQN/blob/master/test/">test</a> directory, with the WebAssembly versions tested with Javascript using Node (<a href="https://github.com/mlochbaum/BQN/blob/master/test/nt.js">test/nt.js</a> and <a href="https://github.com/mlochbaum/BQN/blob/master/test/t.js">test/t.js</a> for BQN2NGN and dzaima/BQN respectively) and the dzaima/BQN backend tested with BQN itself (<a href="https://github.com/mlochbaum/BQN/blob/master/test/bt">test/bt</a>).</p>
+<h3 id="bqn2ngn">BQN2NGN</h3>
+<p><a href="https://github.com/mlochbaum/BQN2NGN">BQN2NGN</a> is a prototype implementation in Javascript build to experiment with the langauge, which is now abandoned. It can be used online <a href="https://mlochbaum.github.io/BQN2NGN/web/index.html">here</a>. Major differences are that it has no Fold and Insert is spelled <code><span class='Modifier'>´</span></code> even though current BQN uses <code><span class='Modifier'>˝</span></code>, that it has a different version of <a href="doc/group.html">Group</a> (<code><span class='Function'>⊔</span></code>), and that it is missing Choose (<code><span class='Modifier2'>◶</span></code>). There are also some spelling differences, with Deduplicate (<code><span class='Function'>⍷</span></code>) spelled with <code><span class='Value'>∪</span></code> and Valences (<code><span class='Modifier2'>⊘</span></code>) spelled with <code><span class='Value'>⍠</span></code>. It is missing value blocks and function headers.</p>
 
diff --git a/running.md b/running.md
index 95e3b7e4..d8775834 100644
--- a/running.md
+++ b/running.md
@@ -2,13 +2,15 @@
 
 # How to run BQN
 
-BQN is in a very early stage of development, and there is currently no complete implementation of the language. However, it's a relatively simple language to implement, and a few implementations come close.
+BQN is in an early stage of development, and no implementation is complete yet. However, it's a relatively simple language to implement, and a few implementations come close. At the moment, dzaima/BQN is the most usable version, with good performance and error reporting.
 
-### BQN2NGN
+### BQN
+
+This repository contains a BQN implementation written mainly in BQN: the bytecode [compiler](src/c.bqn) is completely self-hosted, and the [majority of the runtime](src/r.bqn) is written in BQN except that it is allowed to define primitives; some preprocessing turns the primitives into identifiers. The remaining part, a VM, can be implemented in any language to obtain a version of BQN running in that language. A [Javascript implementation](docs/bqn.js) allows BQN to be run as a REPL (running locally) from [this webpage](https://mlochbaum.github.io/BQN/try.html) or in Node.js as a library. The bytecode is also the same as dzaima/BQN's format, and [another version](c.bqn) of the compiler runs on and targets dzaima+reference BQN. This version also contains an earlier experiment targetting [WebAssembly](https://en.wikipedia.org/wiki/WebAssembly) that works only on a very small subset of BQN.
 
-[BQN2NGN](https://github.com/mlochbaum/BQN2NGN) is a prototype implementation in Javascript build to experiment with the langauge, which is now abandoned. Because you can [use it online](https://mlochbaum.github.io/BQN2NGN/web/index.html), this is probably the quickest way to get started with BQN. It has good primitive support, with the main issues being that it has no Fold and Insert is spelled `´` even though current BQN uses `˝`, that it has a different version of [Group](doc/group.md) (`⊔`), and that it is missing Choose (`◶`). There are also some spelling differences, with Deduplicate (`⍷`) spelled with `∪` and Valences (`⊘`) spelled with `⍠`. It is missing value blocks and function headers.
+This version is not yet suitable for serious programming. The runtime checks for errors but the compiler does not, so syntax errors go unreported. It does not yet support function headers or multiple bodies. The Javascript-based compiler is also slow, taking about 0.05 seconds plus 1 second per kilobyte of source (this is purely due to the slow runtime, as dzaima+reference achieves 3ms/kB with the same compiler once warmed up).
 
-For automated testing I run BQN2NGN using the `bqn` executable, which is just a symlink to `apl.js` in the BQN2NGN repository. It requires Node to run.
+All versions have automated tests in the [test](test/) directory, with the self-hosted version ([test/tj.js](test/tj.js)) and WebAssembly backend  ([test/t.js](test/t.js)) tested with Javascript using Node and the dzaima/BQN backend tested with BQN itself ([test/bt](test/bt)).
 
 ### dzaima/BQN
 
@@ -16,7 +18,7 @@ For automated testing I run BQN2NGN using the `bqn` executable, which is just a
 
 ### dzaima+reference BQN
 
-This repository contains a dzaima/BQN script `dzref` that fills in the gaps in primitive support using BQN implementations of primitives which are not yet up to spec ([reference implementations](spec/reference.bqn) of all primitives starting from a small set of pre-existing functions are part of BQN's specification). These alternate implementations can be slow.
+This repository contains a dzaima/BQN script `dzref` that fills in the gaps in primitive support using BQN implementations of primitives that are not yet up to spec ([reference implementations](spec/reference.bqn) of all primitives starting from a small set of pre-existing functions are part of BQN's specification).
 
 You can run `dzref` from ordinary dzaima/BQN using the `•EX` command; see for example [cshim.bqn](cshim.bqn). For testing, it is run as a Unix script, in which case it depends on an executable `dbqn` that runs dzaima/BQN on a file argument. I use the following script, using the path to a clone of dzaima/BQN for the jar file.
 
@@ -26,8 +28,6 @@ You can run `dzref` from ordinary dzaima/BQN using the `•EX` command; see for
 
 The left argument for `•EX` or the shell arguments can contain up to two arguments for the script. The first is a file to run, and the second is BQN code to be run after it.
 
-### BQN
-
-This repository contains the beginnings of a self-hosted compiler for BQN, which is not yet complete enough to do any real programming with. There are currently several versions of the compiler: [nc.bqn](nc.bqn) is run with BQN2NGN, while [c.bqn](c.bqn) is run with dzaima+reference. Both compilers have a simple backend targetting [WebAssembly](https://en.wikipedia.org/wiki/WebAssembly), and c.bqn additionally has a backend that targets dzaima/BQN's own bytecode, so that the compiler uses only BQN, but the runtime uses the Java implementations of BQN primitives from dzaima/BQN. The bytecode compiler has almost complete expression support and also supports blocks, but not headers or multiple bodies.
+### BQN2NGN
 
-All versions have automated tests in the [test](test/) directory, with the WebAssembly versions tested with Javascript using Node ([test/nt.js](test/nt.js) and [test/t.js](test/t.js) for BQN2NGN and dzaima/BQN respectively) and the dzaima/BQN backend tested with BQN itself ([test/bt](test/bt)).
+[BQN2NGN](https://github.com/mlochbaum/BQN2NGN) is a prototype implementation in Javascript build to experiment with the langauge, which is now abandoned. It can be used online [here](https://mlochbaum.github.io/BQN2NGN/web/index.html). Major differences are that it has no Fold and Insert is spelled `´` even though current BQN uses `˝`, that it has a different version of [Group](doc/group.md) (`⊔`), and that it is missing Choose (`◶`). There are also some spelling differences, with Deduplicate (`⍷`) spelled with `∪` and Valences (`⊘`) spelled with `⍠`. It is missing value blocks and function headers.