diff --git a/paper/citation-cache.json b/paper/citation-cache.json
index 042541db..a84d7c20 100644
--- a/paper/citation-cache.json
+++ b/paper/citation-cache.json
@@ -104,6 +104,53 @@
 				"title": "Alternate Timelines for TidalCycles",
 				"type": ""
 			}
+		},
+		"https://www.semanticscholar.org/paper/Bringing-the-TidalCycles-Mini-Notation-to-the-Roberts/74965efadd572ae3f40d14c633a5c8581c1b9f42": {
+			"fetched": "2022-04-12T22:47:17.063Z",
+			"bibtex": [
+				"",
+				"@misc{roberts_bringing_2019,",
+				"   title = {Bringing the {TidalCycles} {Mini}-{Notation} to the {Browser}},",
+				"   url = {https://www.semanticscholar.org/paper/Bringing-the-TidalCycles-Mini-Notation-to-the-Roberts/74965efadd572ae3f40d14c633a5c8581c1b9f42},",
+				"   abstract = {A JavaScript dialect of its mini-notation for pattern is created, enabling easy integration with creative coding tools and an accompanying technique for visually annotating the playback of TidalCycles patterns over time. TidalCycles has rapidly become the most popular system for many styles of live coding performance, in particular Algoraves. We created a JavaScript dialect of its mini-notation for pattern, enabling easy integration with creative coding tools. Our research pairs a formalism describing the mini-notation with a small JavaScript library for generating events over time; this library is suitable for generating events inside of an AudioWorkletProcessor thread and for assisting with scheduling in JavaScript environments more generally. We describe integrating the library into the two live coding systems, Gibber and Hydra, and discuss an accompanying technique for visually annotating the playback of TidalCycles patterns over time.},",
+				"   language = {en},",
+				"   urldate = {2022-04-12},",
+				"   journal = {www.semanticscholar.org},",
+				"   author = {Roberts, Charles},",
+				"   year = {2019},",
+				"}",
+				""
+			],
+			"csl": {
+				"URL": "https://www.semanticscholar.org/paper/Bringing-the-TidalCycles-Mini-Notation-to-the-Roberts/74965efadd572ae3f40d14c633a5c8581c1b9f42",
+				"abstract": "A JavaScript dialect of its mini-notation for pattern is created, enabling easy integration with creative coding tools and an accompanying technique for visually annotating the playback of TidalCycles patterns over time. TidalCycles has rapidly become the most popular system for many styles of live coding performance, in particular Algoraves. We created a JavaScript dialect of its mini-notation for pattern, enabling easy integration with creative coding tools. Our research pairs a formalism describing the mini-notation with a small JavaScript library for generating events over time; this library is suitable for generating events inside of an AudioWorkletProcessor thread and for assisting with scheduling in JavaScript environments more generally. We describe integrating the library into the two live coding systems, Gibber and Hydra, and discuss an accompanying technique for visually annotating the playback of TidalCycles patterns over time.",
+				"accessed": {
+					"date-parts": [
+						[
+							2022,
+							4,
+							12
+						]
+					]
+				},
+				"author": [
+					{
+						"family": "Roberts",
+						"given": "Charles"
+					}
+				],
+				"container-title": "www.semanticscholar.org",
+				"id": "https://www.semanticscholar.org/paper/Bringing-the-TidalCycles-Mini-Notation-to-the-Roberts/74965efadd572ae3f40d14c633a5c8581c1b9f42",
+				"issued": {
+					"date-parts": [
+						[
+							2019
+						]
+					]
+				},
+				"title": "Bringing the TidalCycles Mini-Notation to the Browser",
+				"type": ""
+			}
 		}
 	}
 }
\ No newline at end of file
diff --git a/paper/paper-preprocessed.md b/paper/paper-preprocessed.md
index a845d9c5..9f206b95 100644
--- a/paper/paper-preprocessed.md
+++ b/paper/paper-preprocessed.md
@@ -67,36 +67,193 @@ references:
   publisher-place: Valdivia, Chile
   title: Alternate Timelines for TidalCycles
   URL: "https://zenodo.org/record/5788732"
+- abstract: A JavaScript dialect of its mini-notation for pattern is
+    created, enabling easy integration with creative coding tools and an
+    accompanying technique for visually annotating the playback of
+    TidalCycles patterns over time. TidalCycles has rapidly become the
+    most popular system for many styles of live coding performance, in
+    particular Algoraves. We created a JavaScript dialect of its
+    mini-notation for pattern, enabling easy integration with creative
+    coding tools. Our research pairs a formalism describing the
+    mini-notation with a small JavaScript library for generating events
+    over time; this library is suitable for generating events inside of
+    an AudioWorkletProcessor thread and for assisting with scheduling in
+    JavaScript environments more generally. We describe integrating the
+    library into the two live coding systems, Gibber and Hydra, and
+    discuss an accompanying technique for visually annotating the
+    playback of TidalCycles patterns over time.
+  accessed:
+    date-parts:
+    - - 2022
+      - 4
+      - 12
+  author:
+  - family: Roberts
+    given: Charles
+  container-title: www.semanticscholar.org
+  id: "https://www.semanticscholar.org/paper/Bringing-the-TidalCycles-Mini-Notation-to-the-Roberts/74965efadd572ae3f40d14c633a5c8581c1b9f42"
+  issued:
+    date-parts:
+    - - 2019
+  title: Bringing the TidalCycles Mini-Notation to the Browser
+  URL: "https://www.semanticscholar.org/paper/Bringing-the-TidalCycles-Mini-Notation-to-the-Roberts/74965efadd572ae3f40d14c633a5c8581c1b9f42"
 title: Strudel
 url2cite: all-links
 ---
 
 # Introduction
 
-That
-@https://www.tandfonline.com/doi/abs/10.1080/14794713.2016.1227602?journalCode_x61_rpdm20
-are excellent, I reference their work at least twice per sentence
-[@https://www.tandfonline.com/doi/abs/10.1080/14794713.2016.1227602?journalCode_x61_rpdm20,
-p. 3]. Another reference [@https://zenodo.org/record/5788732].
-
-<MiniRepl tune={`"1 2 3"`} />
+This paper introduces Strudel, an alternative implementation of the
+TidalCycles live coding system, using the JavaScript programming
+language.
 
 # Background
 
 General motivations / related work. Reference vortex paper and summarise
 its background.
 
+The reimplementation of TidalCycles in Python (cite TidalVortex) showed
+that it is possible to translate pure functional reactive programming
+ideas to a multi paradigm language. It proved to be a stepping stone to
+move to other multi-paradigm languages, like JavaScript. A significant
+part of of the Python codebase could be ported to JavaScript by
+syntactical adjustments.
+
 # Introducing TidalStrudel
 
 (do we want to call it TidalStrudel once, and Strudel for short from
 then on as with vortex? Or just stick with Strudel? Should we start
-calling TidalCycles just Cycles??)
+calling TidalCycles just Cycles?? froos: I think TidalStrudel sounds a
+bit weird, but we can stick to the TidalX naming scheme if that's
+important. For me, StrudelCycles sounds better, because it has 3/4
+phonems in common with TidalCycles)
 
 -   Motivating musical example
 
 # Tidal patterns
 
+(should we explain shortly what tidal patterns do in general here?)
+
+The essence of TidalCycles are Patterns. Patterns are abstract entities
+that represent flows of time. Taking a time span as its input, a Pattern
+can output a set of events that happen within that time span. It depends
+on the structure of the Pattern where the events are placed. From now
+on, this process of generating events from a time span will be called
+**querying**. Example:
+
+<MiniRepl tune={`const pattern = sequence(c3, [e3, g3]);
+const events = pattern.query(0, 1);
+console.log(events.map(e => e.show()))`} />
+
+In this example, we create a pattern using the `sequence` function and
+**query** it for the timespan from `0` to `1`. Those numbers represent
+units of time called **cycles**. The length of one cycle defaults to one
+second, but could be any number of seconds. The console output looks
+like this:
+
+<MiniRepl tune={`(0   -> 1/2 c3)
+(1/2 -> 3/4 e3)
+(3/2 -> 1   g3)`} />
+
+In this output, each line represents one event. The two fractions
+represent the begin and end time of the event, followed by its value. In
+this case, the events are placed in sequential order, where c3 takes the
+first half, and e3 and g3 together take the second half. This temporal
+placement is the result of the `sequence` function, which divides its
+arguments equally over one cycle. If an argument is an array, the same
+rule applies to that part of the sequence. In our example e3 and g3 are
+divided equally over the second half of the whole sequence.
+
+# Mini Notation
+
+In this example, the Pattern is created using the `mini` function, which
+parses Tidal's Mini Notation. The Mini Notation is a Domain Specific
+Language (DSL) that allows expressing rhythms in a short mannger.
+
 -   Some comparisons of -Strudel with -Vortex and -Cycles code?
+
+(the following examples are from vortex paper, with added js versions)
+
+## 1
+
+<MiniRepl tune={`sound "bd ~ [sd cp]"`} />
+<MiniRepl tune={`sound("bd", silence, ["sd", "cp"])`} />
+<MiniRepl tune={`sound("bd ~ [sd cp]")`} />
+
+without mini notation:
+
+<MiniRepl tune={`sound $ cat
+   [pure "bd", silence,
+    cat(pure "sd", pure "cp")]`} />
+<MiniRepl tune={`sound('bd', silence, cat('sd', 'cp'))`} />
+
+## 2
+
+<MiniRepl tune={`sound "bd ~ <sd cp>"`} />
+<MiniRepl tune={`sound("bd", silence, slowcat("sd", "cp"))`} />
+<MiniRepl tune={`sound("bd ~ <sd cp>")
+// sound('bd', silence, slowcat('sd', 'cp'))`} />
+
+## 3
+
+<MiniRepl tune={`sound "bd {cp sd, lt mt ht}"`} />
+<MiniRepl tune={`sound("bd", pm(["cp", "sd"], ["lt", "mt", "ht"]))`} />
+<MiniRepl tune={`?`} />
+
+## 4
+
+<MiniRepl tune={`sound "bd {cp sd, [lt mt,bd bd bd] ht}"`} />
+<MiniRepl tune={` sound("bd", pm(["cp", "sd"],
+ [pr(["lt", "mt"],
+ ["bd", "bd", "bd"]
+ ),
+ "ht" ]))`} />
+<MiniRepl tune={`??`} />
+
+## 5
+
+<MiniRepl tune={`sound "bd sd cp" # speed "1 2"`} />
+<MiniRepl tune={`sound("bd", "sd", "cp") >> speed (1, 2)`} />
+<MiniRepl tune={`sound("bd sd cp").speed("1 2")`} />
+
+(operator overloading like in vortex?)
+
+## 6
+
+<MiniRepl tune={`rev $ sound "bd sd"`} />
+<MiniRepl tune={`rev(sound("bd", "sd"))
+sound("bd", "sd").rev()`} />
+<MiniRepl tune={`rev(sound("bd sd"))
+sound("bd sd").rev()`} />
+
+## 7
+
+<MiniRepl tune={`jux rev $ every 3 (fast 2) $ sound "bd sd"`} />
+<MiniRepl tune={`jux(rev, every(3, fast(2), sound("bd", "sd")))
+sound("bd","sd").every(3, fast(2)).jux(rev)`} />
+<MiniRepl tune={`jux(rev, every(3, fast(2), sound("bd sd")))
+sound("bd sd").every(3, fast(2)).jux(rev)`} />
+
+(partial application)
+
+## 8
+
+<MiniRepl tune={`n ("1 2 3" + "4 5") # sound "drum"`} />
+<MiniRepl tune={`n (sequence(1,2,3) + sequence(4,5)) >> sound "drum"`} />
+<MiniRepl tune={`n("1 2 3".add("4 5")).sound("drum")
+n("5 [6 7] 8").sound("drum")`} />
+
+(operator overloading?)
+
+## 9
+
+<MiniRepl tune={`speed("1 2 3" + sine)`} />
+<MiniRepl tune={`speed(sequence(1,2,3) + sine)`} />
+<MiniRepl tune={`speed("1 2 3".add(sine))
+"c3*4".add(sine.mul(12).slow(8)).pianoroll()`} />
+
+## 10
+
 -   Mininotation
 
 # Strudel/web specifics
@@ -118,6 +275,55 @@ or whether javascript affordances mean it's going its own way..
 -   emulating musician thought patterns
 -   microtonal features? webserial
 
+## User Code Transpilation
+
+(compare user input vs shifted output)
+
+### double quotes -\> mini calls
+
+<MiniRepl tune={`"c3 e3" // or `c3 e3``} />
+<MiniRepl tune={`mini("c3 e3")`} />
+
+### operator overloading
+
+<MiniRepl tune={`cat(c3, e3) * 4`} />
+<MiniRepl tune={`reify(cat("c3","e3")).fast(4)`} />
+
+(reify is redundant here, the shapeshifter could have an additional
+check...)
+
+(TBD: ability to multiply mini notation strings)
+
+### pseudo variables
+
+<MiniRepl tune={`cat(c3, r, e3)`} />
+<MiniRepl tune={`cat("c3",silence,"e3")`} />
+
+### locations
+
+<MiniRepl tune={`cat(c3, e3)`} />
+<MiniRepl tune={`cat(
+  reify("c3").withLocation([1,4,4],[1,6,6]),
+  reify("e3").withLocation([1,8,8],[1,10,10])
+)`} />
+<MiniRepl tune={`mini("c3 e3")`} />
+
+with locations:
+
+<MiniRepl tune={`// "c3 e3"
+mini("c3 e3").withMiniLocation([1,0,0],[1,7,7])`} />
+
+(talk about mini adding locations of mini notation parser)
+
+### top level await
+
+<MiniRepl tune={`const p = (await piano()).toDestination()
+cat(c3).tone(p)`} />
+<MiniRepl tune={`(async()=>{
+  const p = (await piano()).toDestination();
+  return cat("c3").tone(p);
+})()`} />
+
 # Musical examples
 
 ...
@@ -128,4 +334,16 @@ or whether javascript affordances mean it's going its own way..
 -   OSC -\> Supercollider
 -   mininotation as the 'regex' of metre
 
+That
+@https://www.tandfonline.com/doi/abs/10.1080/14794713.2016.1227602?journalCode_x61_rpdm20
+are excellent, I reference their work at least twice per sentence
+[@https://www.tandfonline.com/doi/abs/10.1080/14794713.2016.1227602?journalCode_x61_rpdm20,
+p. 3]. Another reference [@https://zenodo.org/record/5788732].
+
+<MiniRepl tune={`"1 2 3"`} />
+
 # References
+
+-   gibber
+-   krill
+-   glicol
diff --git a/paper/paper.md b/paper/paper.md
index 4d1e8061..f7e6db45 100644
--- a/paper/paper.md
+++ b/paper/paper.md
@@ -340,9 +340,8 @@ That @roberts2016 are excellent, I reference their work at least twice per sente
 
 [@roberts2016]: https://www.tandfonline.com/doi/abs/10.1080/14794713.2016.1227602?journalCode=rpdm20
 [@mclean21]: https://zenodo.org/record/5788732
-[@tidal.pegjs](https://www.ntnu.edu/documents/1282113268/1290797448/WAC2019-CameraReadySubmission-49.pdf/eadc2fee-7584-373e-31e6-79828b0b196a?t=1575329719278)
+[@tidal.pegjs]: https://www.semanticscholar.org/paper/Bringing-the-TidalCycles-Mini-Notation-to-the-Roberts/74965efadd572ae3f40d14c633a5c8581c1b9f42
 [@mclean22]: https://zenodo.org/record/6456380
-[@roberts19]: https://www.semanticscholar.org/paper/Bringing-the-TidalCycles-Mini-Notation-to-the-Roberts/74965efadd572ae3f40d14c633a5c8581c1b9f42
 [@ogborn17]: https://www.semanticscholar.org/paper/Estuary%3A-Browser-based-Collaborative-Projectional-Ogborn-Beverley/c6b5d34575d6230dfd8751ca4af8e5f6e44d916b
 
 - gibber
diff --git a/paper/paper.pdf b/paper/paper.pdf
index 05a99753..d5841524 100644
Binary files a/paper/paper.pdf and b/paper/paper.pdf differ