My core.logic fork

Benjamin Schwerdtner October 28, 2026 11:59 PM

Mein core.logic-Fork

ftlm :faster-than-light /memes Joyful ideas are better ideas

Mein core.logic-Fork

Eine Serie darüber, wie Clojures Maps, Vektoren und Sets in core.logic relational werden: Jede Relation läuft in jede Richtung, und was sie noch nicht entscheiden kann, darauf wartet sie sichtbar, statt zu raten. Code und Überblick stehen im README des Repositorys.

Wie es aussieht

Jede Relation ist eine Clojure-Funktion, als Relation gelesen, also kann jedes Argument das unbekannte sein.

Maps. get, assoc, merge, conj und keys, vorwärts und rückwärts:

(run* [v] (geto {:a 1 :b 2} :b v))          ;;=> (2)
(run* [k] (geto {:a 1 :b 2} k 2))           ;;=> (:b)          welcher Key hat 2

(run* [m] (assoco m :b 2 {:a 1 :b 2}))
;;=> ({:a 1} {:a 1, :b _0})                 ;; m hatte kein :b, oder ein :b, das assoc überschrieb

(run* [m1 m2] (mergeo m1 m2 {:a 1}))
;;=> ([{:a 1} {}] [{} {:a 1}] [{:a _0} {:a 1}])

(run* [q] (fresh [v] (conjo q [:foo v] {:foo 1})))
;;=> ({} {:foo _0})                         ;; der Testfall aus dem Wiki, unten

(run* [k] (== {:a 1 k 2} {:a 1 :b 2}))      ;;=> (:b)          unbekannte Keys unifizieren
(run* [ks] (keyso {:a 1 :b 2} ks))          ;;=> (#{:b :a})

(run* [m] (geto m :a 1) (geto m :b 2))
;;=> ((lmap {:b 2, :a 1} | _0))             ;; eine offene Map: diese Keys, vielleicht mehr

Vektoren. nth, conj, concat, subvec, mit exakt gelösten Längen:

(run* [i] (ntho [:a :b :a] i :a))           ;;=> (0 2)
(run* [v x] (conjo v x [1 2 3]))            ;;=> ([[1 2] 3])
(run* [s e] (subveco [:a :b :c :d] s e [:b :c]))
;;=> ([1 3])                                ;; woher der Ausschnitt stammt

(run* [a b] (concato a b [1 2 3]))
;;=> ([[] [1 2 3]] [[1] [2 3]] [[1 2] [3]] [[1 2 3] []])

(run* [v] (counto v 2) (ntho v 0 :a))       ;;=> ([:a _0])

(run* [x] (fresh [l r] (concato x [1] l) (concato [1] x r) (concato r [2] l)))
;;=> ()                                     ;; |x| + 1 ≠ |x| + 2, ohne Suche

Sets. Literale mit unbekannten Elementen, conj, union, difference:

(run* [x y] (== #{x y} #{1 2}))             ;;=> ([1 2] [2 1])
(run* [s] (conjo s 3 #{1 2 3}))             ;;=> (#{1 3 2} #{1 2})
(run* [a] (uniono a #{2 3} #{1 2 3}))       ;;=> (#{1 3} #{1} #{1 3 2} #{1 2})
(run* [x] (subseto #{1 x} #{1 2 3}))        ;;=> (3 2)         x ist verschieden von 1

(run* [x] (differenceo #{1 2 3} x #{1}))
;;=> (((lset #{3 2} | _0) :- (clojure.core.logic/lackso _0 1)))
;; 2 und 3, plus ein Rest ohne 1

(run* [s] (containso s 1) (containso s 2))
;;=> ((lset #{1 2} | _0))

Zusammen. Die Relationen lassen sich über die Arten hinweg kombinieren, und auch Pfade sind Relationen:

(def db {:users [{:name "ada" :tags #{:admin}} {:name "bob" :tags #{}}]})

(run* [n] (fresh [us u tags]
            (geto db :users us) (ntho us (lvar) u)
            (geto u :name n) (geto u :tags tags) (containso tags :admin)))
;;=> ("ada")

(run* [p] (get-ino db p "bob"))             ;;=> ((:users 1 :name))

;; dieselbe Frage als Muster: mindestens diese Keys, mindestens dieses Element
(run* [n] (fresh [i u] (get-ino db [:users i] u) (matcho u {:name n :tags #{:admin}})))
;;=> ("ada")

Warum das die eigentliche Sache von core.logic ist

Eine Logiksprache nimmt ihre Terme von ihrer Wirtssprache. Der Term von miniKanren ist das Scheme-Paar, weil Schemes Daten das Paar sind: appendo und membero funktionieren so gut, weil eine teilweise bekannte Liste eine natürliche Form hat, einen bekannten Anfang und einen ungebundenen Rest. core.logic hat miniKanren nach Clojure gebracht, und das Paar kam mit. Clojures eigene Daten waren Bürger zweiter Klasse: Zwei Maps unifizierten nur, wenn sie genau dieselben Keys hatten, und außer featurec, das Werte an bekannten Keys liest, konnte nichts eine Map zerlegen oder eine bauen.

Aber die Daten sind das, was Clojure ausmacht. Literale, unveränderliche Maps, Vektoren und Sets, für alles benutzt: "just use maps", Daten vor Funktionen vor Makros, ein Programm ist eine Pipeline aus get, assoc, merge, conj und union. Clojure-Leute kodieren einen Datensatz nicht als Assoziationsliste oder ein Set als Liste ohne Duplikate; sie schreiben {:name "ada"} und #{1 2}.

Ein relationales Clojure sollte also über diese Daten relational sein. Diese Serie macht das wahr: get, assoc, merge, nth, concat, union und Verwandte, jeweils als Relation, die rückwärts läuft. Eine Anfrage kann fragen, aus welcher Map ein assoc kam, welcher Key-Pfad zu einem Wert führt oder welche zwei Sets diese Vereinigung haben, auf denselben Daten, die der Rest des Programms benutzt. Das ist der Teil von core.logic, den nur Clojure haben kann, und den miniKanren auf Listen nur kodieren kann.

Der Wunsch ist nicht neu. 2013 hat David Nolen ihn auf die Roadmap von core.logic selbst gesetzt. Die Wiki-Seite Constraints & modes beginnt mit: "core.logic unfortunately to this day continues to emphasize operating on sequence-like data structures due to its Prolog & Scheme roots", und wünscht sich "constraint versions of Clojure functions". Sie skizziert ein assocc, stellt fest, dass es rückwärts verzweigt, und nimmt conjo als Testfall:

(run* [q]
  (fresh [v o]
    (== o {:foo 1})
    (conjo q [:foo v] o)))

"So we should see the following results: ({} {:foo _0})." Genau das antwortet der Fork. Die Begleitseite CLP(Set) wünscht sich Sets mit unbekannten Elementen, (unionc #{:cat x y} #{:dog :bird z} o), und merkt an, dass so eine Vereinigung darüber verzweigt, welche Elemente zusammenfallen. Auch die läuft im Fork: Mit o = #{:cat :dog :bird} sind x und y in beliebiger Reihenfolge :dog und :bird, und z ist :cat. (Beim Schreiben habe ich dabei einen Bug gefunden: Der Fork hat x früher auch :cat sein lassen. Behoben.) Beide Seiten stehen noch auf der Roadmap im Wiki, unter "Immediate", und wurden nie gebaut. Die Maschinerie, die sie skizzieren, ist nicht die, die diese Serie baut (ein defc mit Modus-Deklarationen, Set-Domänen wie die FD-Domänen), aber ihre Testfälle sind die, die sie beantwortet.

Sie legt auch die Messlatte. Eine Relation, die nur in manche Richtungen funktioniert, ist eine Funktion mit Extraschritten. Deshalb hält die Serie jede Relation an eine Regel: Sie antwortet in jedem Modus korrekt, oder sie wartet, bis sie es kann (Teil 2).

Relationale Maps: ein Rundgang durch die API.
Kein nicht unterstütztes Verhalten: warum das Design neu gemacht werden musste, und wie unbekannte Keys, lazy Checks und suspendierte Goals zusammenpassen.
Schnell machen: von 33 s auf 8 ms, und was langsam war.
Vektoren: offene Vektoren, Längen exakt gelöst, und get-in als Abfragesprache.
Literatur und Parität mit miniKanren: wo das in der Forschung steht, und was core.logic noch fehlt.
Auf dem Weg zu relationalem hyperdimensionalem Rechnen: dieselben Datenstrukturen, als Hypervektoren kodiert.
Sets: Maps ohne Werte, und was das bringt.
Seite an Seite mit miniKanren: die Testsuite von faster-miniKanren auf core.logic, die Bugs, die sie gefunden hat, und Maps, Sets und Vektoren neben ihren Kodierungen in miniKanren.
Ein relationaler Clojure-Interpreter: evalo für eine Teilmenge von Clojure, mit relationalen Maps als Umgebung; was er rückwärts kann, und wo seine Suche noch langsam ist.

Als Nächstes vielleicht: Records als Typen, und ClojureScript. Siehe Future Work.

Generiert von Claude im Auftrag von Benjamin Schwerdtner.

Datum: 2026-10-28 Wed 00:00

Clojure.org October 27, 2026 12:00 AM

Clojure 1.13.0-alpha11

Clojure 1.13.0-alpha11 is now available! Find download and usage information on the Downloads page.

Fix:

CLJ-2990 :req! on a nested map with :missing binds an internal Object

Try it out

Update your deps.edn :deps with:

org.clojure/clojure {:mvn/version "1.13.0-alpha11"}

Start a REPL with the Clojure CLI (any version) with:

clj -Sdeps '{:deps {org.clojure/clojure {:mvn/version "1.13.0-alpha11"}}}'

Benjamin Schwerdtner October 26, 2026 11:59 PM

gasbb: Clojure in Google Sheets

ftlm :faster-than-light /memes Joyful ideas are better ideas

gasbb: Clojure in Google Sheets

If nbb is a thing, what else could be a thing?

nbb is borkdude's ClojureScript scripting for Node. It is a formula, really: take SCI, the Small Clojure Interpreter, drop it into a host that is already there, and inherit everything the host can do. ¹ Node gives you npm. The browser gives you scittle. VS Code gives you Joyride. ² Same move, different host. (Jacking in nbb and Binaural Beats with Scittle are older posts of mine from that world.)

So you go looking for hosts that have a JavaScript engine and a scripting slot with no Clojure interpreter in it yet. Postgres has one (plv8). Figma has one. ³ And Google Sheets has one: Apps Script, Google's JavaScript, running on V8. ⁴

That one is now gasbb: Clojure for Google Apps Script.

Clojure in a cell

=CLJ("(->> % (map first) frequencies)", B2:B100)

A range comes in as a vector of rows. What comes out spills back into the sheet: a sequence goes down a column, a map becomes key/value rows.

This is the demo spreadsheet. It is public. File → Make a copy and you have your own, script included.

There is something funny about frequencies in a spreadsheet cell. Spreadsheets are the most successful functional programming environment ever: every cell is a pure function of other cells, and a huge number of people use them without ever hearing the word "pure". Clojure is the same idea for people who did hear the word. They were always cousins. gasbb just introduces them.

Clojure files in the project

Apps Script projects hold two kinds of files: scripts and HTML. ⁵ No .clj. But HTML files are kept verbatim, and a script can read one back as a string with HtmlService.createHtmlOutputFromFile(name).getContent(). ⁶

So a file called main.clj is "an HTML file" that happens to contain Clojure. gasbb reads it at runtime and hands it to SCI. require works the same way: util.text is looked up as the file util/text.clj. It is a little bit of a smuggling operation, and I like it.

(ns main
  (:require [gasbb.sheets :as sheets]))

(defn top-scorers []
  (->> (sheets/read-maps "Scores")   ;; header row -> keyword keys
       (filter #(> (:points %) 30))
       (sort-by :points >)
       (map :name)))

Interop is just js/SpreadsheetApp, js/GmailApp, js/UrlFetchApp. Everything Apps Script can do, Clojure can do, once the service's permission is listed in the manifest. ⁷

The one thing you cannot smuggle: Apps Script only sees functions that are declared in a script file. Menus, triggers and custom functions point at names. So there is a small Code.gs that declares the entry points and forwards each one to Clojure:

function onOpen(e)          { gasbb.run("main.clj", "main/on-open", e); }
function CLJ(code, ...args) { return gasbb.cell(code, args); }

A REPL that forgets everything

REPL sidebar

Rendered locally with the same bundle. In a sheet, every eval is a round trip to Google, so expect more than the milliseconds shown.

There is a REPL in a sidebar. And here comes the twist: every call from the sidebar to the server is a fresh Apps Script execution. All files evaluated again, nothing kept from the last call. ⁸ Your def from a second ago is gone.

So the sidebar remembers for the server. It keeps the top-level ns, require and def forms you evaluated, and replays them before each new eval, namespace and all. The REPL has amnesia, and the browser is its notebook. Like the guy in Memento with the tattoos.

The catch: the notebook gets re-read, not just remembered. A def with a side effect, say appending a row, runs again on every eval. Keep side effects out of def.

It sounds slow. The interpreter is not the slow part: the SCI context comes up in about 8 milliseconds inside Apps Script, and loading a .clj file plus a required namespace takes about 20. ⁹ What you feel is everything around it: starting a fresh execution, parsing the ~950 KB bundle, the round trip from the browser. Interpreters are cheap now. Round trips are not.

What it can't do

Custom functions are sandboxed: they have to finish within 30 seconds, and they can only call services that don't access personal data. ¹⁰ CLJ inherits that.
SCI is an interpreter. Don't loop over 100,000 cells one by one, read the range in one go and work on the data. (You should do that in JavaScript too.)
No setTimeout in Apps Script, so nothing that needs timers. ¹¹

Do we need this?

Honest question. Claude writes Apps Script JavaScript fluently. Why should anyone want a Clojure bridge in the age of AI code?

Maybe the language matters less now. What still matters is the loop: can you (or your agent) ask the running system something, get an answer in milliseconds, and try again? A REPL into a spreadsheet is that kind of loop. A spreadsheet already is that kind of loop.

Or maybe it is just fun. That is allowed too.

Open questions

What is the next host? Postgres (plv8), k6, n8n, Figma, Obsidian, Godot (via GodotJS)… Which one has the most people stuck in a scripting slot they don't love?
Is a spreadsheet the best REPL most people will ever use, and should we build programming tools that look more like one?
Does an AI agent prefer a REPL to a codebase? My guess is yes, but I don't know yet.

Code, setup guide and the demo: https://github.com/benjamin-asdf/gasbb

Generated by Claude Code on behalf of Benjamin Schwerdtner.

Footnotes:

nbb: "Scripting in Clojure on Node.js using SCI", "the same interpreter that powers babashka", https://github.com/babashka/nbb. scittle: "Execute Clojure(Script) directly from browser script tags via SCI", https://github.com/babashka/scittle. SCI lists babashka first among its users: https://github.com/babashka/sci

"Joyride is Powered by SCI (Small Clojure Interpreter)." https://github.com/BetterThanTomorrow/joyride

plv8: "V8 Engine Javascript Procedural Language add-on for PostgreSQL", https://github.com/plv8/plv8. Figma: "Figma plugins are written using primarily JavaScript and HTML", https://developers.figma.com/docs/plugins/how-plugins-run/. For Apps Script there is prior art that compiles ClojureScript ahead of time, e.g. https://github.com/whitecoop/cljs-apps-script (2016). I found no interpreter you could use live from a cell.

⁴

"Apps Script is now supported by the V8 runtime that powers Chrome and Node.js." https://developers.google.com/apps-script/guides/v8-runtime. V8, not Node: no npm, no Node APIs. The old Rhino runtime was deprecated on January 31, 2026: https://developers.google.com/apps-script/guides/v8-runtime/migration

⁵

"A script project has one or more script files which can either be code files (having a .gs extension) or HTML files (a .html extension)." Plus the appsscript.json manifest. https://developers.google.com/apps-script/guides/projects

⁶

createHtmlOutputFromFile "creates a new HtmlOutput object from a file in the code editor", https://developers.google.com/apps-script/reference/html/html-service; getContent() returns its content, https://developers.google.com/apps-script/reference/html/html-output. Scriptlets are not evaluated on this path. In gasbb's self test inside Apps Script, Clojure source came back unchanged.

⁷

"Apps Script automatically determines required scopes by scanning the code for function calls." https://developers.google.com/apps-script/concepts/scopes. Calls made from Clojure don't show up in that scan, so gasbb's setup guide lists them in oauthScopes by hand.

⁸

gasbb's self test checks both halves over repeated runs in Apps Script: a global counter of how often its file was evaluated is 1 every time, and a global variable and a Clojure def set at the end of one run are gone in the next.

⁹

Measured with gasbb's self test, which runs inside Apps Script through the Apps Script API (scripts/gas.py test in the repo): first eval including SCI context init ~8 ms, loading a .clj file with one required namespace ~20 ms, one CLJ call ~9 ms. One run, on 2026-10-26. Not included: starting the execution, parsing the bundle, the round trip.

¹⁰

"A custom function call must return within 30 seconds. If it doesn't, the cell displays #ERROR!" Custom functions "never ask users to authorize access to personal data. Consequently, they can only call services that don't have access to personal data." https://developers.google.com/apps-script/guides/sheets/functions

¹¹

gasbb's self test checks it inside Apps Script: typeof setTimeout is "undefined". Apps Script has Utilities.sleep for waiting, but no timers or event loop to schedule callbacks on.

Date: 2026-10-26 Mon 14:00

Benjamin Schwerdtner October 26, 2026 11:59 PM

gasbb: Clojure in Google Sheets

ftlm :faster-than-light /memes Joyful ideas are better ideas

gasbb: Clojure in Google Sheets

Wenn nbb ein Ding ist, was könnte sonst noch ein Ding sein?

nbb ist borkdudes ClojureScript-Scripting für Node. Eigentlich ist es eine Formel: Man nimmt SCI, den Small Clojure Interpreter, setzt ihn in einen Host, der sowieso schon da ist, und erbt alles, was der Host kann. ¹ Node bringt npm mit. Der Browser bringt scittle. VS Code bringt Joyride. ² Gleicher Zug, anderer Host. (Jacking in nbb und Binaural Beats with Scittle sind ältere Posts von mir aus dieser Ecke.)

Also sucht man Hosts, die eine JavaScript-Engine und einen Scripting-Platz haben, in dem noch kein Clojure-Interpreter steckt. Postgres hat einen (plv8). Figma hat einen. ³ Und Google Sheets hat einen: Apps Script, Googles JavaScript, das auf V8 läuft. ⁴

Daraus ist jetzt gasbb geworden: Clojure für Google Apps Script.

Clojure in einer Zelle

=CLJ("(->> % (map first) frequencies)", B2:B100)

Ein Bereich kommt als Vektor von Zeilen herein. Was herauskommt, ergießt sich zurück ins Sheet: Eine Sequenz läuft eine Spalte hinunter, eine Map wird zu Schlüssel/Wert-Zeilen.

Das ist das Demo-Spreadsheet. Es ist öffentlich. Datei → Kopie erstellen, und man hat sein eigenes, mitsamt Script.

frequencies in einer Tabellenzelle hat etwas Komisches. Tabellenkalkulationen sind die erfolgreichste funktionale Programmierumgebung aller Zeiten: Jede Zelle ist eine reine Funktion anderer Zellen, und unglaublich viele Menschen benutzen sie, ohne je das Wort "pure" gehört zu haben. Clojure ist dieselbe Idee für Leute, die das Wort doch gehört haben. Die beiden waren schon immer Cousins. gasbb stellt sie nur einander vor.

Clojure-Dateien im Projekt

Apps-Script-Projekte enthalten zwei Sorten Dateien: Scripts und HTML. ⁵ Kein .clj. Aber HTML-Dateien werden wortgetreu gespeichert, und ein Script kann eine davon mit HtmlService.createHtmlOutputFromFile(name).getContent() als String zurücklesen. ⁶

Eine Datei namens main.clj ist also "eine HTML-Datei", die zufällig Clojure enthält. gasbb liest sie zur Laufzeit und gibt sie an SCI. require funktioniert genauso: util.text wird als Datei util/text.clj gesucht. Ein kleiner Schmuggel, und ich mag ihn.

(ns main
  (:require [gasbb.sheets :as sheets]))

(defn top-scorers []
  (->> (sheets/read-maps "Scores")   ;; Kopfzeile -> Keyword-Schlüssel
       (filter #(> (:points %) 30))
       (sort-by :points >)
       (map :name)))

Interop ist einfach js/SpreadsheetApp, js/GmailApp, js/UrlFetchApp. Alles, was Apps Script kann, kann Clojure, sobald die Berechtigung des Dienstes im Manifest steht. ⁷

Das Einzige, was sich nicht schmuggeln lässt: Apps Script sieht nur Funktionen, die in einer Script-Datei deklariert sind. Menüs, Trigger und eigene Tabellenfunktionen zeigen auf Namen. Deshalb gibt es eine kleine Code.gs, die die Einstiegspunkte deklariert und jeden an Clojure weiterreicht:

function onOpen(e)          { gasbb.run("main.clj", "main/on-open", e); }
function CLJ(code, ...args) { return gasbb.cell(code, args); }

Ein REPL, der alles vergisst

REPL sidebar

Lokal mit demselben Bundle gerendert. Im Sheet ist jede Auswertung ein Weg zu Google und zurück, also mehr als die gezeigten Millisekunden.

In einer Seitenleiste gibt es einen REPL. Und jetzt kommt der Twist: Jeder Aufruf von der Seitenleiste zum Server ist eine frische Apps-Script-Ausführung. Alle Dateien neu ausgewertet, nichts bleibt vom letzten Aufruf. ⁸ Das def von vor einer Sekunde ist weg.

Also erinnert sich die Seitenleiste für den Server. Sie behält die ns-, require- und def-Formen auf oberster Ebene, die man ausgewertet hat, und spielt sie vor jeder neuen Auswertung erneut ab, samt Namespace. Der REPL hat Amnesie, und der Browser ist sein Notizbuch. Wie der Typ in Memento mit den Tattoos.

Der Haken: Das Notizbuch wird nicht nur erinnert, sondern jedes Mal neu gelesen. Ein def mit Nebenwirkung, etwa einer angehängten Zeile, läuft bei jeder Auswertung erneut. Nebenwirkungen gehören nicht in ein def.

Klingt langsam. Der Interpreter ist aber nicht der langsame Teil: Der SCI-Kontext steht in Apps Script nach etwa 8 Millisekunden, und eine .clj-Datei samt einem per require geladenen Namespace braucht etwa 20. ⁹ Was man spürt, ist alles drumherum: eine frische Ausführung starten, das ~950 KB große Bundle parsen, der Weg vom Browser und zurück. Interpreter sind heute billig. Round Trips nicht.

Was es nicht kann

Eigene Tabellenfunktionen laufen in einer Sandbox: Sie müssen innerhalb von 30 Sekunden fertig sein und dürfen nur Dienste aufrufen, die nicht auf persönliche Daten zugreifen. ¹⁰ CLJ erbt das.
SCI ist ein Interpreter. Nicht 100.000 Zellen einzeln durchlaufen, sondern den Bereich in einem Rutsch lesen und mit den Daten arbeiten. (Das sollte man in JavaScript auch so machen.)
In Apps Script gibt es kein setTimeout, also nichts, was Timer braucht. ¹¹

Braucht man das?

Ehrliche Frage. Claude schreibt Apps-Script-JavaScript flüssig. Warum sollte jemand im Zeitalter von KI-Code eine Clojure-Brücke wollen?

Vielleicht zählt die Sprache jetzt weniger. Was weiter zählt, ist die Schleife: Kann man (oder der eigene Agent) das laufende System etwas fragen, in Millisekunden eine Antwort bekommen und es nochmal versuchen? Ein REPL in ein Spreadsheet ist so eine Schleife. Ein Spreadsheet ist schon so eine Schleife.

Oder es macht einfach Spaß. Das ist auch erlaubt.

Offene Fragen

Was ist der nächste Host? Postgres (plv8), k6, n8n, Figma, Obsidian, Godot (über GodotJS)… Wo stecken die meisten Leute in einem Scripting-Platz, den sie nicht mögen?
Ist ein Spreadsheet der beste REPL, den die meisten Menschen je benutzen werden, und sollten Programmierwerkzeuge mehr wie eins aussehen?
Ist einem KI-Agenten ein REPL lieber als eine Codebasis? Ich vermute ja, aber ich weiß es noch nicht.

Code, Setup-Anleitung und die Demo: https://github.com/benjamin-asdf/gasbb

Generiert von Claude Code im Auftrag von Benjamin Schwerdtner.

Fußnoten:

nbb: "Scripting in Clojure on Node.js using SCI", laut README "the same interpreter that powers babashka", https://github.com/babashka/nbb. scittle: "Execute Clojure(Script) directly from browser script tags via SCI", https://github.com/babashka/scittle. SCI nennt babashka als ersten Nutzer: https://github.com/babashka/sci

"Joyride is Powered by SCI (Small Clojure Interpreter)." https://github.com/BetterThanTomorrow/joyride

plv8: "V8 Engine Javascript Procedural Language add-on for PostgreSQL", https://github.com/plv8/plv8. Figma: "Figma plugins are written using primarily JavaScript and HTML", https://developers.figma.com/docs/plugins/how-plugins-run/. Für Apps Script gibt es Vorarbeiten, die ClojureScript vorab kompilieren, z. B. https://github.com/whitecoop/cljs-apps-script (2016). Einen Interpreter, den man live aus einer Zelle benutzen kann, habe ich nicht gefunden.

⁴

"Apps Script is now supported by the V8 runtime that powers Chrome and Node.js." https://developers.google.com/apps-script/guides/v8-runtime. V8, nicht Node: kein npm, keine Node-APIs. Die alte Rhino-Runtime ist seit dem 31. Januar 2026 abgekündigt: https://developers.google.com/apps-script/guides/v8-runtime/migration

⁵

"A script project has one or more script files which can either be code files (having a .gs extension) or HTML files (a .html extension)." Dazu das Manifest appsscript.json. https://developers.google.com/apps-script/guides/projects

⁶

createHtmlOutputFromFile "creates a new HtmlOutput object from a file in the code editor", https://developers.google.com/apps-script/reference/html/html-service; getContent() liefert dessen Inhalt, https://developers.google.com/apps-script/reference/html/html-output. Scriptlets werden auf diesem Weg nicht ausgewertet. Im Selbsttest von gasbb in Apps Script kam Clojure-Quelltext unverändert zurück.

⁷

"Apps Script automatically determines required scopes by scanning the code for function calls." https://developers.google.com/apps-script/concepts/scopes. Aufrufe aus Clojure tauchen in diesem Scan nicht auf, deshalb trägt die Setup-Anleitung von gasbb sie von Hand in oauthScopes ein.

⁸

Der Selbsttest von gasbb prüft beide Hälften über wiederholte Läufe in Apps Script: Ein globaler Zähler, wie oft seine Datei ausgewertet wurde, steht jedes Mal auf 1, und eine globale Variable und ein Clojure-def vom Ende eines Laufs sind im nächsten weg.

⁹

Gemessen mit dem Selbsttest von gasbb, der über die Apps Script API in Apps Script läuft (scripts/gas.py test im Repo): erstes Auswerten inklusive Aufbau des SCI-Kontexts ~8 ms, eine .clj-Datei mit einem geladenen Namespace ~20 ms, ein CLJ-Aufruf ~9 ms. Ein Lauf, am 26.10.2026. Nicht enthalten: Start der Ausführung, Parsen des Bundles, der Weg vom Browser und zurück.

¹⁰

"A custom function call must return within 30 seconds. If it doesn't, the cell displays #ERROR!" Eigene Funktionen "never ask users to authorize access to personal data. Consequently, they can only call services that don't have access to personal data." https://developers.google.com/apps-script/guides/sheets/functions

¹¹

Der Selbsttest von gasbb prüft das in Apps Script: typeof setTimeout ist "undefined". Zum Warten gibt es Utilities.sleep, aber keine Timer und keine Event-Loop, auf der man Callbacks planen könnte.

Datum: 2026-10-26 Mon 14:00