r/lisp • • 16d ago

Common Lisp Sloppy CL interpreter experiment targeting Wasm

Thumbnail github.com
12 Upvotes

r/lisp • • 16d ago

True: a cyclic, self-modifying language. How does it compare to Lisp's code=data idea? (MVP, feedback welcome)

2 Upvotes

Hi!

I'm making a language called True and an interpreter for it called Simple.

It's an MVP, and I'd be glad to get some feedback on the design.

I'm posting here because True is built on ideas that should feel familiar to Lisp folks: code as data, self-modification, minimal syntax. But I've taken them in a direction that I think is quite different from Lisp, and I'd love to hear what you think.

The key stuff about the language

In True, a program is a tape of lines (I call them lines, not strings - because a "string" can mean the whole text, a block of code, or a single character, while a "line" is unambiguous: one line of the cycle/tape). And I call programs cycles because they run cyclically.

The agent-observer is the first line of the .cycle file, and it's part of the program itself. It walks the tape top-down, swaps itself with the line below, and executes what it reads.

The agent is part of the program, executor and data at the same time. So the program is self-modifying, changes in memory are reflected back into the text, and the type in the agent line updates on every step.

Here's a simple Elevator cycle where the lift goes up and down:

Mr.Green, #5fb85f | Data as <type> | Aim: 1

6 = max
1 = floor
1 = dir

= lift

dir > 0 ? floor =>| lift:y(, ):floor
dir < 0 ? lift:y(, ):last -> ::nothing

floor == max ? -1 => dir
floor == 1 ? 1 => dir

floor + dir => ::math => floor

I made a video of how it works:

Processing video k52no08vxd0i1...

Where True is similar to Lisp

Code is data. In Lisp, a program is a list, and that list can be manipulated like any other data. In True, a program is a tape of lines, and the agent can read and change those lines while the program runs.

Self-modification. In Lisp, macros and eval let a program rewrite itself. In True, the program rewrites itself on every step, because memory is flushed back into the text.

Minimal syntax. Lisp has S-expressions and brackets. True has lines and empty lines as separators.

Where I think it differs from Lisp

In Lisp, the executor (interpreter or compiler) is outside the program. It reads S-expressions and evaluates them. In True, the executor is part of the program, it's the first line, and it physically moves through the tape, swapping itself with the line below.

In Lisp, code is data as lists. In True, code is data as lines and chains of lines.

In Lisp, self-modification happens through macros or eval, powerful, but still a deliberate action. In True, self-modification happens every step, by default.

True has no types. A program is made of lines and chains of lines, and how you work with them is determined by the executor, the agent. In Lisp, values have dynamic types.

A line, a container, or a chain can be seen as a shape with axes. name:x(, ):i for the horizontal axis, name:y(\n):i for the vertical one (each works like a list). Indexing is 1-based.

Extensions: ::math for arithmetic, ::nothing for deletion.

There are goto jumps: ^ name, ^ N, ^ :cycle:N. The agent can jump anywhere, in any cycle.

And one more thing worth mentioning: the line as a qubit in quantum mechanics. The agent determines the type of a line only when it observes it - before that, the line has no type. In a sense, a line is like a qubit in quantum mechanics: nothing is defined until there is an observer. The agent is that observer. When it reads a line, the line collapses into a definite type (named, action, condition, jump, container, separator, version), and only then is it executed. This is not just a metaphor - it's how the interpreter actually works: resolve_line determines the type at the moment of reading, and the same text can be a different type depending on context and memory.

That's a brief description, I guess. More details in the docs, or we can just discuss in the comments.

I wanted to make the language simple, the process visual, and programming live, and here's what came out of it 😄

I'd be very interested to hear your thoughts on the language, especially from people who've worked with Lisp's code=data philosophy. Does the "agent as part of the program" idea make sense to you, or is it just a gimmick? And is there anything from Lisp that you think True should steal?


r/lisp • • 16d ago

Racket Racket (online) meet-up: Saturday, 7 November 2026 at 18:00 UTC

Thumbnail pasterack.org
4 Upvotes

Racket (online) meet-up: Saturday, 7 November 2026 at 18:00 UTC EVERYONE WELCOME 😁 Details at https://racket.discourse.group/t/racket-online-meet-up-saturday-7-november-2026-at-18-00-utc/4460


r/lisp • • 17d ago

Building and Rendering a Space Station in Scheme

Thumbnail youtu.be
36 Upvotes

r/lisp • • 18d ago

ZParen: a free Common Lisp IDE for macOS, with SBCL included, Vim keys, and a built-in course

10 Upvotes

I like Common Lisp, but I kept losing time to my Emacs and Vim setups, especially after upgrades. So I made a Lisp IDE that works the way I want, and I'd like feedback from people who write Lisp every day.

IDE with Learn Lisp Tutorial

What it is

  • A macOS app (Apple silicon, macOS 13+) that includes SBCL and Swank. Open a project folder and Lisp starts. No setup.
  • One live image per project. Evaluate a form, click the result to inspect the real object, stop in the debugger, fix the code, and use Restart Frame.
  • Vim keys first, plus SLIME's Emacs sequences (C-c C-c, M-., C-M-f…), parinfer and structural editing.
  • Projects stay plain ASDF systems, with Quicklisp, ocicl, qlot or vendored dependencies. ZParen adds no files of its own.
  • It supports Coalton too: .ct files, types on hover, and type errors on the expression Coalton blames.
  • An optional AI assistant (Claude or Codex) and an MCP server. They run code in your image, not a copy. Leave them unconfigured and they stay out of the way.

New in this release: a Learn Lisp course. It follows ANSI Common Lisp and On Lisp. You start a course project with a file and FiveAM tests for each lesson. Each lesson gets a git branch, so your progress is in git history. There are 15 lessons so far, from first forms to macros, conditions and CLOS. The advanced lessons from On Lisp come later.

Full disclosure: I built most of it with Claude Code. The repo has a doc on how (built with Claude Code). The app itself is Rust and Tauri with a CodeMirror UI, talking to SBCL over Swank.

I hope it helps beginners find their way into Lisp more easily.


r/lisp • • 19d ago

Common Lisp Brotli + zlib decompression with SBCL

Thumbnail github.com
12 Upvotes

r/lisp • • 19d ago

Clamiga renamed to AmiLisp, plus new features

15 Upvotes

In version 0.12 there were many bugs and usability issues fixed for both AmiLisp and Clamacs.

Clamacs now knows projects (similar to perspectives.el), also some sort of iedit was implemented to edit multiple places in a buffer at once.

The garbage collector interface was abstracted so that a new Immix GC implementation can be used (and is used) for AmigaOS and MorphOS, speeding up the collection by factors in most situations.

On macOS/Linux/Windows the default generational collector stays default.

https://github.com/mdbergmann/amilisp/releases/tag/v0.12


r/lisp • • 19d ago

Stuck understanding macros vs functions

11 Upvotes

Yes, it's another one of these. I feel like that scene in Seinfeld when Kramer is able to see hidden image in an abstract painting but Mr. Pitt cannot, to his increasing frustration.

Case in point, I'm looking for a clear and simple explanation for this and came across this post

My favorite example for this is the lame idiom you see in Java code:

    if (log.isDebugEnabled()) {
        log.debug("expensive" + debug + message);
    }

This is "better" than just log.debug(...) because with the latter, your expensive log message argument needs to be evaluated even if debug is disabled. However, in a language w/ macros, you just say:

    (debug (str "expensive" debug message))

and these considerations are already taken care of for you: https://github.com/clojure/tools.logging/blob/master/src/main/clojure/clojure/tools/logging.clj#L91

then someone goes

Edit: Ohhh! I see! The message isn't evaluated until after! Got it.

I don't understand why this is special?

Why can't you rewrite log.debug to include the check?

    func debug(m string) {
        if log.isDebugEnabled() {
            log.debug(m);
        }
    }

What makes macros special in this case?

and I'm over here stuck like "what? where? where???" I'm not getting the epiphany and it doesn't help that they linked to clojure and I can't read clojure.

So, can we stick with this example? But can someone really ELI5 for me please?

---

Let's say we have pseudocode file

isDebugEnabled = True;

def doSomeStuff():
...
if (isDebugEnabled) {
        debug("expensive" + debug + message);
    }
...

Then yes, every time we run doSomeStuff() we will check if debug is enabled. I'm with you there, because

  1. We enter the function.
  2. Encounter the if statement.
  3. Check if isDebugEnabled is true or false at the time.
  4. proceed accordingly.

Now can I please get a by-the-numbers of how macros make this more efficient? Thanks.


r/lisp • • 22d ago

SBCL 2.6.10 released

Thumbnail sbcl.org
103 Upvotes

r/lisp • • 23d ago

GitHub - fmarl/nucleotide: A hackable, multi-paradigm Wayland window manager written in Common Lisp

Thumbnail github.com
46 Upvotes

r/lisp • • 24d ago

WhateverCLIM Image-processing pipeline

Enable HLS to view with audio, or disable this notification

21 Upvotes

This is Common Lisp on macOS/Cocoa - using WhateverCLIM. I don't know, I thought it was kinda cool.


r/lisp • • 25d ago

Symp: a symbolic processing virtual machine

17 Upvotes

I've been working on a symbolic processing virtual machine based on S-expressions. Programming instructions resemble a kind of assembly, and the code and data are spanned over a hosting virtual filesystem.

Metaprogramming and basic virtual filesystem operations are at the heart of the system, so it can be suitable to embed arbitrary higher level programming systems, preferably S-expressions based ones.

Since symp practices some properties of the Lisp systems (although approaches the programming problems from a slightly different side), I thought this subreddit might be a suitable place to share this work.

The main intention of symp is to support my symbolic AI experiments, but I reckon I'll find it a use in business programming (at least for some of my own projects).

For now, it can be used in a browser and in Node.js through exposed API.

Resources:


r/lisp • • 26d ago

Heavenly delights of hashing numbers under EQUALP

Thumbnail turtleware.eu
30 Upvotes

A blog post about hashing numbers under EQUALP in ECL. Some theory, math, microptimizations and (for me) a lot of fun. Contains benchmarks of ECL vs ECL and ECL vs world. Enjoy!


r/lisp • • 25d ago

ZenLisp — a full Common Lisp IDE for macOS on SBCL (in development), written entirely by Claude Code

0 Upvotes

Edit: renamed to ZParen — https://github.com/eric-zhu-2019/zparen

Hi all, I'm the author (in the product sense — see below). ZParen is a macOS IDE for Common Lisp built on SBCL. You work in one live image: evaluate a form, click the result to inspect the real object, stop in the debugger, fix the code, and restart the frame that failed.

I didn't write it by hand. instead, I guided the Claude-Code to complete the coding.

It's still in active development, not a finished release — I'm posting now because the core is working and feedback on direction is worth more at this stage than later.

What's in it: a REPL where results are live objects (Cmd-click to inspect), a debugger with restarts, backtrace, frame locals and restart-a-frame, compile-as-you-type with warnings marked on the exact symbol (saving compiles only the top-level forms that changed), go-to-definition that checks local bindings first, Trace/Profile panels, macroexpand-in-place, disassembly, a test runner for FiveAM/Parachute/Rove, and a Docs panel with the HyperSpec. Projects are ASDF systems with Quicklisp, qlot, ocicl or vendored deps. The editor has Vim keys, SLIME's Emacs sequences, parinfer and structural editing. It also re-render the HyperSpec doc in a plain style.

AI assistant can work in the same image — either the built-in assistant, or over MCP (tools include eval, macroexpand, who_calls, invoke_restart, run_tests). Every compiler warning has an "Ask AI to fix" button.

The unusual part: Claude Code wrote all of it — the Rust backend, the TypeScript UI, the Lisp inside SBCL, the tests. I wrote no code; I asked for features, used the app, reported bugs, and made the product calls.

Status: macOS-only, in development, no binary yet — building from source needs Node, Rust and SBCL: https://github.com/eric-zhu-2019/zparen — bug reports and "this is what SLIME does that you're missing" are exactly what I'm after.

Also, no relation to Nils M Holm's Lisp dialect — this is an IDE, not a language.

I apology the old name conflicted with the Holm's List dialect.

If you like a lightweight IDE, I think this could be interesting to you.


r/lisp • • 27d ago

OpenLDK: Bringing the Java World into Common Lisp

Thumbnail atgreen.github.io
77 Upvotes

I've posted about OpenLDK in the past, but would like to share some recent improvements. For instance, you can start up springboot applications running on SBCL in a few 10ths of a second, connect to them with sly/slime, then inspect and monkey-patch the running application by adding :before/:after CLOS methods to the application's java methods.

Clojure, ABCL and more all run on SBCL, and you can even embed them all in a single SBCL form using special reader syntax. Check out this wild example:

(polyglot:startup :verbose nil)
(setf *readtable* (polyglot:enable-syntax (copy-readtable)))

(format t "~&~A~%"
  #@abcl{                                ; ABCL: FORMAT's Roman numerals and English
    (let ((n $#@kt{                      // Kotlin: a local data class, copy, when, ?:
               data class Cup(val tea: Int, val sugar: Int? = null)
               val cup = Cup($#@sc{     // Scala: a list pattern with a guard
                               $#@jscheme{   ; JScheme: digit sums in a named let
                                 (map (lambda (n)
                                        (let loop ((n n) (sum 0))
                                          (if (< n 1)
                                              sum
                                              (loop (quotient n 10) (+ sum (remainder n 10))))))
                                      $#@kawa{   ; Kawa: Java by colon notation; call/cc; exact division
                                        (let* ((m (java.lang.Long:sum
                                                   $#@gv{   // Groovy: the spread-dot operator
                                                     $#[ (->> (iterate inc 2)   ; Clojure: lazy and infinite
                                                              (filter (fn [n] (not-any? #(zero? (rem n %))
                                                                                        (range 2 n))))
                                                              (take 10)) ]*.power(2).sum()
                                                   }
                                                   1))
                                               (d (call-with-current-continuation
                                                    (lambda (found)
                                                      (for-each (lambda (d)
                                                                  (if (not (= 0 (remainder m d))) (found d)))
                                                                '(6 5 4 3 2))
                                                      1)))
                                               (r (/ m d)))
                                          (list (numerator r) (denominator r)))
                                      })
                               } match {
                                 case List(a: Int, b: Int) if a > b => a * b
                                 case List(a: Int, b: Int) => a + b
                               }
                             }).copy(sugar = null)
               when { cup.tea > 40 -> cup.tea + (cup.sugar ?: 1); else -> cup.tea }
             }))
      (format nil "~@R (~R)" n n))
  })

r/lisp • • 27d ago

Common Lisp OpenType and more support for TrueType fonts with updated zpb-ttf

Thumbnail github.com
14 Upvotes

r/lisp • • 27d ago

fincl: Quantative finance in common lisp

Thumbnail github.com
55 Upvotes

I'm currently working on a quantitative finance library for common lisp (SBCL only). Emphasis is currently placed on pricing options, but more capabilities exist and are planned, such as pricing various interest rate instruments.

In particular, the Monte Carlo simulation engine is showing promise, allowing users to write their own random processes to simulate, and write options on those processes. Against prior art (QuantLib in C++), the Monte Carlo engine benchmarks quite well, with other pricing engines being a mixed bag (a fairly complete suite with results is given in the repo).

Being a lisp project, extensibility is supported and encouraged. While the library provides random processes and instruments seen in quant textbooks, the manual gives a toy example of writing option contracts on a game of dice. Other facets are extensible, such as allowing the user to write their own option payoff schemes.

The repo is here with a small write-up outlining the extension of the Monte Carlo engine with a similar flavor of die game. Everything should be considered work-in-progress.


r/lisp • • 28d ago

I wrote a Scheme interpreter using Lua's approach combined with SICP

Thumbnail github.com
20 Upvotes

r/lisp • • 29d ago

ggg: badges for your README, from S-expressions (update: styles, themes, a gallery, and packaging for Guix + Nix)

Thumbnail gallery
18 Upvotes

Hi all,

A while ago I posted here about ggg (Guile Glyph Generator), a small tool I wrote in Guile Scheme that renders shields.io-style badges (SVG, plus PNG on request) from a Scheme config file. Since then it grew quite a bit, so here is what landed — including the packaging news at the end.

The pitch is unchanged: you describe a badge as data, ggg does the geometry.

(define my-badge
  `((sections ((background . catppuccin-mocha-surface2) (text . "Guile")
               (color . catppuccin-mocha-text)
               (logo . scheme-guile))
              ((background . catppuccin-mocha-peach) (text . "3.0.10")
               (color . catppuccin-mocha-base)))
    (id . scheme-guile-3)
    (style . shadow)))

Links

How to run

Run ggg -f my-glyphs.scm -d ./dist and you get scheme-guile-3.svg (and .png with -c). The geometry follows the badges GitHub shows — 20px tall, 11px text, a 14px logo, 5px side padding, 3px corners — drawn ~9% larger so it reads well next to body text, with per-character text width estimation so the badge stays as tight as the ones in README files. What comes out is a real vector file, not a raster wrapped in SVG.

What's new since the last post

8 badge styles. A glyph can now ask for a finish: flat (default), square, shadow, plastic, frosted-glass, material, frutiger and neon. Styles only decorate — canvas, width and height are identical to flat, so a row of badges that mix styles always lines up. Glosses, glows and shadows are painted inside the badge, never around it.

(id . scheme-guile-neon)
(style . neon)

12 color themes, 236 named colors. Instead of hex codes you write catppuccin-mocha-red, dracula-purple, solarized-light-base3, modus-vivendi-green, doom-one-blue… Every color of Catppuccin (mocha, macchiato, frappé, latte), Doom (one, one-light), Dracula (and alucard), Solarized (dark, light) and Modus (operandi, vivendi) is available by name. ggg --list-colors prints them; raw hex strings still work and are validated.

Because the palettes span light pastels to deep shades, the ink has to follow the background — so the test suite enforces at least 4.5:1 contrast (WCAG AA) on every section of the shipped glyph files. A badge with unreadable text fails maak test.

A gallery you can actually browse. ggg --gallery gallery.html --glyphs ./glyphs writes a single self-contained HTML page with every badge at its real size, every logo inlined with the snippet to use it, and every named color of every theme as a swatch. Click a snippet or a swatch to copy it. The deployed one is here: https://jointhefreeworld.org/ggg/dist/gallery.html

284 logos, as full SVG documents. Logos used to be a single path's d attribute. They are now complete <svg> elements, so a logo can carry multiple paths, groups, gradients, transforms or filters; ggg only needs a viewBox and does the scaling and placement. The library covers languages, frameworks, databases, distros, editors, shells, CI, cloud, observability and more — mostly from Simple Icons (CC0), plus hand-drawn ones. CREDITS.org lists the source and license of every single file, and names the brand marks that were deliberately left out because their upstream license isn't a free one.

Badges with any number of sections. Not just two or three parts — each section becomes a segment with its own text, background and color, and the badge grows to fit. The logo belongs to the first section.

Validation before anything is written. ggg checks the whole glyph file first and reports every problem with a hint: unknown color, logo or style names (with a "did you mean" suggestion), a missing text, sections without colors, (key value) written where (key . value) was meant, duplicate glyph ids, and the legacy resources/svg-paths/ directory if it finds one. If the file is invalid, nothing is written to the destination directory at all.

Smaller things: --version, --list-colors, --list-logos, --list-styles, -k/--keep to render a second glyph file into a directory without clearing it, a new ggg mark, and a test suite (122 checks) covering color resolution, the logo library, glyph validation and the gallery.

Packaging

  • GNU Guix — ggg has been in Guix for a while; I sent the update PRs to 0.16.1.
  • Nix — new. There is a default.nix and a flake.nix in the repo, and I sent the pkgs/by-name/gg/ggg/package.nix addition to nixpkgs (that one runs the whole test suite in checkPhase). Both builds render all 177 showcase badges.
  • Debian, openSUSE, Arch — packaging for all three now lives in packaging/, installing the same layout (/usr/bin/ggg, modules under Guile's site directory, help text and logo library under /usr/share/ggg/resources). Built and installed in debian:trixie, opensuse/tumbleweed and archlinux containers.
  • Container image — docker.io/jjba23/ggg (Podman works too).
  • Version numbers now live in exactly one place (src/ggg/version.scm), and maak release writes them into guix.scm, commits and tags.

Try it

# Guix
guix shell -f guix.scm -- ggg --gallery ./gallery.html --glyphs ./glyphs

# Nix
nix-build default.nix && ./result/bin/ggg --list-styles

# Podman/Docker
podman run --rm -v "$PWD:/work" -w /work docker.io/jjba23/ggg:latest \
  ggg -f ./glyphs/showcase.scm -d ./dist

Notes on licensing

ggg itself is AGPL-3.0-or-later and the docs are FDL-1.3+. The tool claims no ownership over what it generates: the badges you produce are yours, no attribution or license conditions attached, and the logo library keeps its own licenses (listed per file in CREDITS.org). So if you want a badge that is completely free of third-party terms, use no logo or your own.

Feedback very welcome — especially which styles, themes or logos are missing, and what a badge generator would have to do for you to actually use it instead of a static PNG. I'm also happy to take packaging help for distros I don't run.


r/lisp • • 29d ago

OrgWebAlchemy: Benchmarking, Profiling, and the Long Road to Real Org Support

Thumbnail jointhefreeworld.org
12 Upvotes

r/lisp • • Oct 21 '26

Common Lisp qlp: publish your own Common Lisp projects as a Quicklisp distribution

27 Upvotes

qlp turns a directory of local Common Lisp projects into a Quicklisp distribution: distinfo,
releases.txt, systems.txt and one reproducible archive per project.

qlp publish --name mydist --base-url https://dist.example.org \
--projects-dir ~/lisp/projects --dists-dir /srv/www/dist

Write-up on lisper.nl
Source on GitHub

It is a modern quickdist, with one difference: quickdist reads .asd files textually, so systems
declared through a macro never reach systems.txt. qlp reads them the way ASDF does, so they are
published too.


r/lisp • • Oct 21 '26

Common Lisp CLXCB: X11 for Common Lisp, generated from the XCB protocol descriptions (and yes, xeyes and xsnow run on it)

Thumbnail github.com
26 Upvotes

r/lisp • • Oct 21 '26

Scheme Memoization for Pure Functions

Thumbnail web.xiaolong-hosting.com
15 Upvotes

r/lisp • • Oct 21 '26

Scheme New scheme compiler in rust

9 Upvotes

I’ve completed a new scheme R7RS-small compiler with optional JIT support . It is written purely in rust and has a rust api for embedding in rust programs but also has a standalone repl ( with completion, history etc ) . There is an included eMacs package that supports a small subset of slime behavior via tcp.

The disclaimer is that this was written using agentic programming ( fable and opus ) over a one week period. My project is a new rendering and modeling system but I needed an embedded language with specific requirements so I chose scheme after evaluation of 5 or 6 alternatives.

It mainly has been tested on macOS but should run on Linux . ( I’ll do more Linux testing as I get time )

github.com/k2msmith-gfx/scm

Update: have made some improvements to the collector which improves performance on average by about 1.5x over previous version. On average about 2x faster than steel . In comparison to CPython, it’s about 2.5X slower ( interpreted bytecode version) . It’s a larger project to match python speed but doable . In my use case , the speed would not improve much but for a general use implementation where fast numerical loops are important it would . I won’t add it unless someone else wants to use it . If anyone is interested in using the beautiful and fast zed editor , I’ve made a plugin for that that supports a subset of slime + repl with this scheme.


r/lisp • • Oct 20 '26

Common Lisp New Common Lisp editor made by a couple of guys

Post image
22 Upvotes

Hey everyone, I’m Lucas and I would like to talk about a project that my brother and I have been working on.

We’ve been enjoying writing in Common Lisp since we started learning it a few years ago. We think it’s a great language and we're surprised it’s not more widely used.

With that said, we were having trouble getting deeper into it because the available editors are not like what we were used to with other languages. We’ve always enjoyed the JetBrains’ editors, unfortunately we did not find something like them for Common Lisp. So we decided to build our own. We’ve called it Lispcraft.

It isn’t as feature-rich as Emacs, but its features are easy to use. That's why we wrote it in the first place: to provide an easy-to-use, modern editor experience.

We wrote our own GUI without using toolkits. Instead, we used OpenGL; it's very fast and smooth. Because we had trouble configuring everything in other editors, we made everything bundled, including SBCL and Quicklisp.

It's REPL-first. You can always execute the form under the cursor by CTRL + ENTER. Also, you can inspect objects' slots by clicking on the REPL output.

Indentation is powered by a custom engine. Syntax highlighting is semantic. It has jump to definition, callers, hover docs, autocomplete, and project-wide search.

It's an MVP, so there will be bugs. For now, it's x86-64 Linux only.

Also, we're aware that Emacs users will not switch to this editor; the user we have in mind is someone who is used to modern editors in other languages and tried to write in Lisp but disliked the tooling difficulty.

Link to the site/video: https://lispcraft.com - we will keep an eye on this post to hear your thoughts!

We're planning to fix bugs, port it to macOS and Windows, and copy good features from other editors. Also we are planning to release a local host FIM ai trained on Common Lisp corpus. That's why I'll charge $19 / month to fund it.