gnu: lisp: Sort packages.

* gnu/packages/lisp.scm: Sort packages.

Change-Id: I5841189c04be6eff3af77e1e72b100db1b1bbf40

1 files changed, 976 insertions, 977 deletions

diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 70b7bf307f..ccc931c185 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -106,6 +106,267 @@
   #:use-module (ice-9 match)
   #:use-module (srfi srfi-1))
 
+(define-public buildapp
+  (package
+    (name "buildapp")
+    (version "1.5.6")
+    (source
+     (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/xach/buildapp")
+             (commit (string-append "release-" version))))
+       (file-name (git-file-name name version))
+       (sha256
+        (base32 "020ipjfqa3l8skd97cj5kq837wgpj28ygfxnkv64cnjrlbnzh161"))))
+    (build-system gnu-build-system)
+    (native-inputs
+     (list sbcl))
+    (arguments
+     `(#:tests? #f
+       #:make-flags
+       (list (string-append "DESTDIR=" (assoc-ref %outputs "out")))
+       #:strip-binaries? #f
+       #:phases
+       (modify-phases %standard-phases
+         (delete 'configure)
+         (add-after 'unpack 'set-home
+           (lambda _
+             (setenv "HOME" "/tmp")
+             #t))
+         (add-before 'install 'create-target-directory
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let* ((bin (string-append (assoc-ref outputs "out") "/bin")))
+               (mkdir-p bin)
+               #t))))))
+    (home-page "https://www.xach.com/lisp/buildapp/")
+    (synopsis "Makes easy to build application executables with SBCL")
+    (description
+     "Buildapp is an application for SBCL or CCL that configures and saves an
+executable Common Lisp image.  It is similar to cl-launch and hu.dwim.build.")
+    (license license:bsd-2)))
+
+(define-public carp
+  ;; Release 0.5.5 does not support GHC 9.2.
+  (let ((commit "339722325ec607091f6035866ebedea2b69080fe")
+        (revision "1"))
+    (package
+      (name "carp")
+      (version (git-version "0.5.5" revision commit))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/carp-lang/Carp")
+                      (commit commit)))
+                (file-name (git-file-name name version))
+                (sha256
+                 (base32
+                  "0w0j3imi4270dsmrh96spsc9xllsk5rrh817l80q1nyay9p53xwd"))))
+      (build-system haskell-build-system)
+      (arguments
+       (list #:phases
+             #~(modify-phases %standard-phases
+                 ;; Carp looks inside the sources checkout to know where to
+                 ;; find its core libraries and other files.
+                 ;; Carp emits C code and tries to compile it with an external
+                 ;; C compiler. On Linux it defaults to Clang.
+                 (add-after 'install 'wrap-programs
+                   (lambda* (#:key inputs #:allow-other-keys)
+                     (define (wrap-carp-program program)
+                       (wrap-program (string-append
+                                      #$output "/bin/" program)
+                         `("CARP_DIR" prefix
+                           (#$(package-source this-package)))
+                         `("PATH" prefix
+                           ,(list (dirname
+                                   (search-input-file inputs "bin/clang"))
+                                  (dirname
+                                   (search-input-file inputs "bin/ld"))))
+                         `("C_INCLUDE_PATH" prefix
+                           ,(list (dirname
+                                   (search-input-directory
+                                    inputs "include/linux"))
+                                  (dirname
+                                   (search-input-file
+                                    inputs "include/stdlib.h"))))))
+
+                     (for-each wrap-carp-program
+                               (list "carp"
+                                     "carp-header-parse")))))))
+      (inputs
+       (list bash-minimal
+             clang
+             ghc-blaze-markup
+             ghc-blaze-html
+             ghc-split
+             ghc-ansi-terminal
+             ghc-cmark
+             ghc-edit-distance
+             ghc-hashable
+             ghc-open-browser
+             ghc-optparse-applicative))
+      (native-inputs
+       (list ghc-hunit))
+      (home-page "https://carp-lang.org/")
+      (synopsis "Statically typed Lisp without a garbage collector")
+      (description
+       "@code{carp} is a Lisp-like programming language that compiles to
+C.  It features inferred static typing, macros, automatic memory
+management without a garbage collector, a REPL, and straightforward
+integration with code written in C.")
+      (license license:asl2.0))))
+
+(define-public ccl
+  ;; Warning: according to upstream, CCL is not bootstrappable.
+  ;; See https://github.com/Clozure/ccl/issues/222 from 2019-09-02:
+  ;;
+  ;;     "As far as I know, there is no way to build CCL without an existing
+  ;;     running CCL image. It was bootstrapped back in 1986 or so as
+  ;;     Macintosh Common Lisp, by Gary Byers, I believe, who is no longer on
+  ;;     the planet to tell us the story. It SHOULD be possible to port the
+  ;;     CCL compiler to portable Common Lisp, so that ANY lisp could build
+  ;;     it, as is the case for SBCL, but I know of no attempt to do so."
+  (package
+    (name "ccl")
+    ;; XXX When updating this package, check whether we can simply append
+    ;; VERSION to the ccl-bootstrap URL again, instead of per architecture.
+    (version "1.12.1")
+    (source (origin
+              (method git-fetch)
+              (uri (git-reference
+                    (url "https://github.com/Clozure/ccl/")
+                    (commit (string-append "v" version))))
+              (file-name (git-file-name "ccl" version))
+              (sha256
+               (base32
+                "1zz291lvsrr7pps8wfl2kdxsnzjngqi4v3mil14pga4r5zanmsi7"))))
+    (build-system gnu-build-system)
+    ;; CCL consists of a "lisp kernel" and "heap image", both of which are
+    ;; shipped in precompiled form in source tarballs.  The former is a C
+    ;; program which we can rebuild from scratch, but the latter cannot be
+    ;; generated without an already working copy of CCL, and is platform
+    ;; dependent, so we need to fetch the correct tarball for the platform.
+    (inputs
+     `(("ccl-bootstrap"
+        ,(origin
+           (method url-fetch)
+           (uri (string-append
+                 "https://github.com/Clozure/ccl/releases/download/v"
+                 (match (%current-system)
+                   ("armhf-linux" "1.12/linuxarm")
+                   ;; XXX: This source only works on x86, but provide it as a
+                   ;; catch-all to prevent errors when querying this package
+                   ;; on unsupported platforms.
+                   (_ "1.12.1/linuxx86"))
+                 ".tar.gz"))
+           (sha256
+            (base32
+             (match (%current-system)
+               ("armhf-linux"
+                "0x4bjx6cxsjvxyagijhlvmc7jkyxifdvz5q5zvz37028va65243c")
+               (_ "0ll017ajcfsyx8f7zsy4394y8xxvz40iz0gcsmznp0n3mf0xi67c"))))))))
+    (native-inputs
+     (list cl-asdf m4))
+    (arguments
+     `(#:tests? #f                      ;no 'check' target
+       #:modules ((ice-9 match)
+                  (srfi srfi-26)
+                  (guix build utils)
+                  (guix build gnu-build-system))
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'unpack-image
+           (lambda* (#:key inputs #:allow-other-keys)
+             (invoke "tar" "xzvf" (assoc-ref inputs "ccl-bootstrap"))))
+         (add-after 'unpack 'replace-asdf
+           ;; Use system ASDF instead of bundled one.
+           (lambda* (#:key inputs #:allow-other-keys)
+             (let* ((cl-asdf (assoc-ref inputs "cl-asdf"))
+                    (guix-asdf (string-append
+                                cl-asdf
+                                "/share/common-lisp/source/asdf/asdf.lisp"))
+                    (contrib-asdf "tools/asdf.lisp"))
+               (delete-file contrib-asdf)
+               (copy-file guix-asdf contrib-asdf))))
+         (delete 'configure)
+         (add-before 'build 'pre-build
+           ;; Enter the source directory for the current platform's lisp
+           ;; kernel, and run 'make clean' to remove the precompiled one.
+           (lambda* (#:key system #:allow-other-keys)
+             (substitute* "lisp-kernel/m4macros.m4"
+               (("/bin/pwd") (which "pwd")))
+             (chdir (string-append
+                     "lisp-kernel/"
+                     (match system
+                       ("i686-linux" "linuxx8632")
+                       ("x86_64-linux" "linuxx8664")
+                       ("armhf-linux" "linuxarm")
+                       (_ (string-append "unknown system: " system)))))
+             (substitute* '("Makefile")
+               (("/bin/rm") "rm"))
+             (setenv "CC" "gcc")
+             (invoke "make" "clean")))
+         ;; XXX Do we need to recompile the heap image as well for Guix?
+         ;; For now just use the one we already got in the tarball.
+         (replace 'install
+           (lambda* (#:key outputs inputs system #:allow-other-keys)
+             ;; The lisp kernel built by running 'make' in lisp-kernel/$system
+             ;; is put back into the original directory, so go back.  The heap
+             ;; image is there as well.
+             (chdir "../..")
+             (let* ((out (assoc-ref outputs "out"))
+                    (libdir (string-append out "/lib/"))
+                    (bindir (string-append out "/bin/"))
+                    (wrapper (string-append bindir "ccl"))
+                    (bash (assoc-ref inputs "bash"))
+                    (kernel
+                     (match system
+                       ("i686-linux" "lx86cl")
+                       ("x86_64-linux" "lx86cl64")
+                       ("armhf-linux" "armcl")
+                       ;; Unlikely to work, but try it anyway...
+                       (_ system)))
+                    (heap (string-append kernel ".image")))
+               (install-file kernel libdir)
+               (install-file heap libdir)
+
+               (let ((dirs `("lib" "library" "examples" "tools" "objc-bridge"
+                             ,@(match system
+                                 ("x86_64-linux"
+                                  '("x86-headers64"))
+                                 ("i686-linux"
+                                  '("x86-headers"))
+                                 (_ '())))))
+                 (for-each copy-recursively
+                           dirs
+                           (map (cut string-append libdir <>) dirs)))
+
+               (mkdir-p bindir)
+               (with-output-to-file wrapper
+                 (lambda ()
+                   (display
+                    (string-append
+                     "#!" bash "/bin/sh\n"
+                     "export CCL_DEFAULT_DIRECTORY=" libdir "\n"
+                     "exec -a \"$0\" " libdir kernel " \"$@\"\n"))))
+               (chmod wrapper #o755))
+             #t)))))
+    (native-search-paths
+     (list (search-path-specification
+            (variable "XDG_DATA_DIRS")
+            (files '("share")))
+           (search-path-specification
+            (variable "XDG_CONFIG_DIRS")
+            (files '("etc")))))
+    (supported-systems '("i686-linux" "x86_64-linux" "armhf-linux"))
+    (home-page "https://ccl.clozure.com/")
+    (synopsis "Common Lisp implementation")
+    (description "Clozure CL (often called CCL for short) is a Common Lisp
+implementation featuring fast compilation speed, native threads, a precise,
+generational, compacting garbage collector, and a convenient foreign-function
+interface.")
+    (license license:asl2.0)))
+
 (define-public cl-asdf
   (package
     (name "cl-asdf")
@@ -149,6 +410,276 @@ Definition Facility.")
     ;; MIT License
     (license license:expat)))
 
+(define-public clisp
+  (package
+    (name "clisp")
+    (version "2.49-92")
+    (source
+     (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://gitlab.com/gnu-clisp/clisp")
+             (commit "clisp-2.49.92-2018-02-18")))
+       (file-name (git-file-name name version))
+       (sha256
+        (base32 "0k2dmgl0miz3767iks4p0mvp6xw0ysyxhjpklyh11j010rmh6hqb"))))
+    (build-system gnu-build-system)
+    (native-inputs
+     (list cl-asdf))
+    (inputs (list libffcall ncurses readline libsigsegv))
+    (arguments
+     `(#:configure-flags '(,@(if (string-prefix? "armhf-linux"
+                                                 (or (%current-system)
+                                                     (%current-target-system)))
+                                 '("CFLAGS=-falign-functions=4")
+                                 '())
+                           ,@(if (target-x86-64?)
+                                 '("--enable-portability"
+                                   "--with-threads=POSIX_THREADS")
+                                 '())
+                            "--with-dynamic-ffi"
+                            "--with-dynamic-modules"
+                            "--with-ffcall"
+                            "--with-readline"
+                            "--with-sigsegv"
+                            "--with-module=asdf"
+                            "--with-module=rawsock")
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'patch-sh-and-pwd
+           (lambda _
+             ;; The package is very messy with its references to "/bin/sh" and
+             ;; some other absolute paths to traditional tools.  These appear in
+             ;; many places where our automatic patching misses them.  Therefore
+             ;; we do the following, in this early (post-unpack) phase, to solve
+             ;; the problem from its root.
+             (substitute* '("src/clisp-link.in"
+                            "src/unix.d"
+                            "src/makemake.in")
+               (("/bin/sh") (which "sh")))
+             (substitute* (find-files "." "configure|Makefile")
+               (("/bin/sh") "sh"))
+             (substitute* '("src/clisp-link.in")
+               (("/bin/pwd") "pwd"))
+             #t))
+         (add-after 'unpack 'replace-asdf
+           ;; Use system ASDF instead of bundled one.
+           (lambda* (#:key inputs #:allow-other-keys)
+             (let* ((cl-asdf (assoc-ref inputs "cl-asdf"))
+                    (guix-asdf (string-append
+                                cl-asdf
+                                "/share/common-lisp/source/asdf/asdf.lisp"))
+                    (contrib-asdf "modules/asdf/asdf.lisp"))
+               (delete-file contrib-asdf)
+               (copy-file guix-asdf contrib-asdf)))))))
+    (native-search-paths
+     (list (search-path-specification
+            (variable "XDG_DATA_DIRS")
+            (files '("share")))
+           (search-path-specification
+            (variable "XDG_CONFIG_DIRS")
+            (files '("etc")))))
+    (home-page "https://clisp.sourceforge.io/")
+    (synopsis "Common Lisp implementation")
+    (description
+     "GNU CLISP is an implementation of ANSI Common Lisp.  Common Lisp is a
+high-level, object-oriented functional programming language.  CLISP includes
+an interpreter, a compiler, a debugger, and much more.")
+    (license license:gpl2+)))
+
+(define-public confusion-mdl
+  (let* ((commit "12a055581fc262225272df43287dae48281900f5"))
+    (package
+      (name "confusion-mdl")
+      (version "0.2")
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url (string-append "https://gitlab.com/emacsomancer/" name))
+                      (commit commit)))
+                (sha256
+                 (base32
+                  "1zi8kflzvwqg97ha1sa5xjisbjs5z1mvbpa772vfxiv5ksnpxp0d"))
+                (file-name (git-file-name name version))))
+      (build-system gnu-build-system)
+      (arguments
+       `(#:tests? #f                    ; there are no tests
+         #:phases
+         (modify-phases %standard-phases
+           (delete 'configure)
+           (replace 'build
+             (lambda* (#:key (make-flags '()) #:allow-other-keys)
+               (apply invoke "make" "CC=gcc" make-flags)))
+           (replace 'install
+             (lambda* (#:key outputs #:allow-other-keys)
+               (let* ((out (assoc-ref outputs "out"))
+                      (bin (string-append out "/bin")))
+                 (install-file "mdli" bin)
+                 #t))))))
+      (native-inputs
+       (list perl))
+      (inputs
+       (list libgc))
+      (synopsis "Interpreter for the MIT Design Language (MDL)")
+      (description "MDL (the MIT Design Language) is a descendant of Lisp.  It
+was originally developed in 1971 on the PDP-10 computer under the Incompatible
+Timesharing System (ITS) to provide high level language support for the
+Dynamic Modeling Group at MIT's Project MAC.  Infocom built the original
+PDP-10 Zork in MDL and their later ZIL (Zork Implementation Language) was
+based on a subset of MDL.  Confusion is a MDL interpreter that works just well
+enough to play the original mainframe Zork all the way through.")
+      (home-page "http://www.russotto.net/git/mrussotto/confusion/src/master/src/README")
+      (license license:gpl3+))))
+
+(define-public ecl
+  (package
+    (name "ecl")
+    (version "24.5.10")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append
+             "https://ecl.common-lisp.dev/static/files/release/"
+             name "-" version ".tgz"))
+       (sha256
+        (base32 "0av2prf474cg0glr37fgsfb4w0dxfg38pykb72ay9q3132xnbsp4"))))
+    (build-system gnu-build-system)
+    ;; src/configure uses 'which' to confirm the existence of 'gzip'.
+    (native-inputs
+     (list cl-asdf which texinfo))
+    (inputs (list bash-minimal))
+    ;; When ECL is embedded in a program that wants to use Common Lisp as an
+    ;; extension language, libgmp, libatomic-ops, libgc and libffi must be
+    ;; present when compiling the program because they are required by ECL's
+    ;; header file.
+    ;; Therefore we put these libraries in 'propagated-inputs' instead
+    ;; of 'inputs'.
+    (propagated-inputs
+     (list gmp libatomic-ops libgc libffi))
+    (arguments
+     `(#:configure-flags '("--without-rt")
+       #:parallel-tests? #f
+       #:phases
+       (modify-phases %standard-phases
+         ;; FIXME: As of version 20.4.24, we pass 17995 tests and fail 7.
+         ;; 2-3 tests may be due to FHS assumptions.
+         (delete 'check)
+         (add-after 'unpack 'replace-asdf
+           ;; Use system ASDF instead of bundled one.
+           (lambda* (#:key inputs #:allow-other-keys)
+             (let* ((cl-asdf (assoc-ref inputs "cl-asdf"))
+                    (guix-asdf (string-append
+                                cl-asdf
+                                "/share/common-lisp/source/asdf/asdf.lisp"))
+                    (contrib-asdf "contrib/asdf/asdf.lisp"))
+               (copy-file guix-asdf contrib-asdf))))
+         (add-after 'install 'remove-build-stamp
+           (lambda* (#:key outputs #:allow-other-keys)
+             (delete-file (string-append (assoc-ref outputs "out")
+                                         "/lib/ecl-" ,version "/build-stamp"))))
+         (add-after 'remove-build-stamp 'wrap
+           (lambda* (#:key inputs outputs #:allow-other-keys)
+             (let* ((ecl (assoc-ref outputs "out"))
+                    (input-path (lambda (lib path)
+                                  (string-append
+                                   (assoc-ref inputs lib) path)))
+                    (libraries '("gmp" "libatomic-ops" "libgc" "libffi" "libc"))
+                    (binaries  '("gcc" "ld-wrapper" "binutils"))
+                    (library-directories
+                     (map (lambda (lib) (input-path lib "/lib"))
+                          libraries)))
+               (wrap-program (string-append ecl "/bin/ecl")
+                 `("PATH" prefix
+                   ,(map (lambda (binary)
+                           (input-path binary "/bin"))
+                         binaries))
+                 `("CPATH" suffix
+                   ,(map (lambda (lib)
+                           (input-path lib "/include"))
+                         `("kernel-headers" ,@libraries)))
+                 `("LIBRARY_PATH" suffix ,library-directories)
+                 `("LD_LIBRARY_PATH" suffix ,library-directories)))))
+         (add-after 'wrap 'check (assoc-ref %standard-phases 'check))
+         (add-before 'check 'fix-path-to-ecl
+           (lambda _
+             (substitute* "build/tests/Makefile"
+               (("\\$\\{exec_prefix\\}/") "")))))))
+    (native-search-paths
+     (list (search-path-specification
+            (variable "XDG_DATA_DIRS")
+            (files '("share")))
+           (search-path-specification
+            (variable "XDG_CONFIG_DIRS")
+            (files '("etc")))))
+    (home-page "https://ecl.common-lisp.dev/")
+    (synopsis "Embeddable Common Lisp")
+    (supported-systems (delete "i586-gnu" %supported-systems))
+    (description "ECL is an implementation of the Common Lisp language as
+defined by the ANSI X3J13 specification.  Its most relevant features are: a
+bytecode compiler and interpreter, being able to compile Common Lisp with any
+C/C++ compiler, being able to build standalone executables and libraries, and
+supporting ASDF, Sockets, Gray streams, MOP, and other useful components.")
+    ;; Note that the file "Copyright" points to some files and directories
+    ;; which aren't under the lgpl2.1+ and instead contain many different,
+    ;; non-copyleft licenses.
+    ;; See https://common-lisp.net/project/ecl/posts/ECL-license.html.
+    (license license:lgpl2.1+)))
+
+(define-public eisl
+  (package
+    (name "eisl")
+    (version "3.50")
+    (source
+     (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/sasagawa888/eisl")
+             (commit (string-append "v" version))))
+       (file-name (git-file-name name version))
+       (sha256
+        (base32 "18alxwpvkcjfm63bc5kp6nn8351fl0p0ccxc8j9a7nb3fmg4fvyb"))))
+    (build-system gnu-build-system)
+    (inputs
+     (list bash-minimal freeglut gdbm libiconv ncurses tcl tk))
+    (native-inputs
+     (list cppcheck))
+    (arguments
+     (list #:make-flags
+           #~(list (string-append "PREFIX=" #$output)
+                   (string-append "CC=" #$(cc-for-target)))
+           #:phases
+           #~(modify-phases %standard-phases
+               (add-after 'unpack 'fix-paths
+                 (lambda* (#:key inputs #:allow-other-keys)
+                   (substitute* "library/compiler.lsp"
+                     (("\"cc ")
+                      "\"gcc "))
+                   (substitute* "library/tcltk.lsp"
+                     (("include <tcl/tcl\\.h>")
+                      "include <tcl.h>")
+                     (("c-option \"-ltcl -ltk\" linux")
+                      "c-option \"-ltcl8.6 -ltk8.6\" linux"))))
+               (delete 'configure)
+               (add-after 'install 'wrap
+                 (lambda* (#:key inputs #:allow-other-keys)
+                   (wrap-program (string-append #$output "/bin/eisl")
+                     `("PATH" prefix
+                       ,(map (lambda (bin)
+                               (string-append (assoc-ref inputs bin) "/bin"))
+                             '("binutils" "coreutils" "gcc" "ld-wrapper")))
+                     `("LIBRARY_PATH" suffix
+                       ,(map (lambda (lib)
+                               (string-append (assoc-ref inputs lib) "/lib"))
+                             '("libc")))))))))
+    (home-page "https://github.com/sasagawa888/eisl")
+    (synopsis "Implementation of ISLisp")
+    (description "Easy ISLISP (eisl) is an implementation of ISLisp which
+includes a compiler as well as an interpreter.")
+    (license (list license:bsd-2 ;; documents/license.txt
+                   license:expat ;; cii/LICENSE
+                   license:gpl2+ ;; nana/gdb/test.c and others under nana/
+                   license:bsd-3)))) ;; bench/*
+
 (define-public gcl
   (package
     (name "gcl")
@@ -269,177 +800,474 @@ stratified garbage collection strategy, a source-level debugger and a built-in
 interface to the Tk widget system.")
     (license license:lgpl2.0+)))
 
-(define-public ecl
+(define-public janet
   (package
-    (name "ecl")
-    (version "24.5.10")
+    (name "janet")
+    (version "1.33.0")
     (source
      (origin
-       (method url-fetch)
-       (uri (string-append
-             "https://ecl.common-lisp.dev/static/files/release/"
-             name "-" version ".tgz"))
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/janet-lang/janet")
+             (commit (string-append "v" version))))
+       (file-name (git-file-name name version))
        (sha256
-        (base32 "0av2prf474cg0glr37fgsfb4w0dxfg38pykb72ay9q3132xnbsp4"))))
+        (base32 "16wgljca7hp29fz5p2dnvy2cbscjx4imf85rhjwc1jkgdjswjxli"))))
     (build-system gnu-build-system)
-    ;; src/configure uses 'which' to confirm the existence of 'gzip'.
-    (native-inputs
-     (list cl-asdf which texinfo))
-    (inputs (list bash-minimal))
-    ;; When ECL is embedded in a program that wants to use Common Lisp as an
-    ;; extension language, libgmp, libatomic-ops, libgc and libffi must be
-    ;; present when compiling the program because they are required by ECL's
-    ;; header file.
-    ;; Therefore we put these libraries in 'propagated-inputs' instead
-    ;; of 'inputs'.
-    (propagated-inputs
-     (list gmp libatomic-ops libgc libffi))
     (arguments
-     `(#:configure-flags '("--without-rt")
-       #:parallel-tests? #f
+     (list #:make-flags
+           #~(list
+              (string-append "DESTDIR=" #$output)
+              (string-append "PREFIX=")
+              (string-append "CC=" #$(cc-for-target)))
+           #:test-target "test"
+           #:phases
+           #~(modify-phases %standard-phases
+               (delete 'configure))))
+    (home-page "https://janet-lang.org/")
+    (synopsis "Functional, imperative and embeddable programming language")
+    (description
+     "Janet is a functional and imperative programming language.  It can be
+used for rapid prototyping, dynamic systems, and other domains where dynamic
+languages shine.  You can also add Janet scripting to an application by
+embedding a single C file and two headers.  It can be easily ported to new
+platforms.  The entire language (core library, interpreter, compiler,
+assembler, PEG) is less than 1MB.")
+    (license license:expat)))
+
+(define-public lisp-repl-core-dumper
+  (package
+    (name "lisp-repl-core-dumper")
+    (version "0.8.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://gitlab.com/ambrevar/lisp-repl-core-dumper.git")
+             (commit version)))
+       (file-name (git-file-name name version))
+       (sha256
+        (base32 "04c12gi5izpkv8ha98z9qdkbmyrsq6ga060adrx53da8z31gnhk1"))))
+    (build-system copy-build-system)
+    (arguments
+     '(#:install-plan
+       '(("lisp-repl-core-dumper" "bin/"))
        #:phases
        (modify-phases %standard-phases
-         ;; FIXME: As of version 20.4.24, we pass 17995 tests and fail 7.
-         ;; 2-3 tests may be due to FHS assumptions.
-         (delete 'check)
-         (add-after 'unpack 'replace-asdf
-           ;; Use system ASDF instead of bundled one.
+         (add-before 'install 'fix-utils-path
            (lambda* (#:key inputs #:allow-other-keys)
-             (let* ((cl-asdf (assoc-ref inputs "cl-asdf"))
-                    (guix-asdf (string-append
-                                cl-asdf
-                                "/share/common-lisp/source/asdf/asdf.lisp"))
-                    (contrib-asdf "contrib/asdf/asdf.lisp"))
-               (copy-file guix-asdf contrib-asdf))))
-         (add-after 'install 'remove-build-stamp
-           (lambda* (#:key outputs #:allow-other-keys)
-             (delete-file (string-append (assoc-ref outputs "out")
-                                         "/lib/ecl-" ,version "/build-stamp"))))
-         (add-after 'remove-build-stamp 'wrap
-           (lambda* (#:key inputs outputs #:allow-other-keys)
-             (let* ((ecl (assoc-ref outputs "out"))
-                    (input-path (lambda (lib path)
-                                  (string-append
-                                   (assoc-ref inputs lib) path)))
-                    (libraries '("gmp" "libatomic-ops" "libgc" "libffi" "libc"))
-                    (binaries  '("gcc" "ld-wrapper" "binutils"))
-                    (library-directories
-                     (map (lambda (lib) (input-path lib "/lib"))
-                          libraries)))
+             (let* ((cat (search-input-file inputs "/bin/cat"))
+                    (paste (search-input-file inputs "/bin/paste"))
+                    (sort (search-input-file inputs "/bin/sort"))
+                    (basename (search-input-file inputs "/bin/basename"))
+                    (sed (search-input-file inputs "/bin/sed")))
+               (substitute* "lisp-repl-core-dumper"
+                 (("\\$\\(basename") (string-append "$(" basename))
+                 (("\\<cat\\>") cat)
+                 (("\\<paste\\>") paste)
+                 (("\\<sed\\>") sed)
+                 (("\\<sort\\>") sort))))))))
+    (inputs
+     `(("coreutils" ,coreutils-minimal)
+       ("sed" ,sed)))
+    (home-page "https://gitlab.com/ambrevar/lisp-repl-core-dumper")
+    (synopsis "Generate REPL-optimized Lisp cores on demand")
+    (description
+     "This tool generates Lisp images that can embed the provided systems
+and make for REPLs that start blazing fast.
 
-               (wrap-program (string-append ecl "/bin/ecl")
-                 `("PATH" prefix
-                   ,(map (lambda (binary)
-                           (input-path binary "/bin"))
-                         binaries))
-                 `("CPATH" suffix
-                   ,(map (lambda (lib)
-                           (input-path lib "/include"))
-                         `("kernel-headers" ,@libraries)))
-                 `("LIBRARY_PATH" suffix ,library-directories)
-                 `("LD_LIBRARY_PATH" suffix ,library-directories)))))
-         (add-after 'wrap 'check (assoc-ref %standard-phases 'check))
-         (add-before 'check 'fix-path-to-ecl
-           (lambda _
-             (substitute* "build/tests/Makefile"
-               (("\\$\\{exec_prefix\\}/") "")))))))
-    (native-search-paths
-     (list (search-path-specification
-            (variable "XDG_DATA_DIRS")
-            (files '("share")))
-           (search-path-specification
-            (variable "XDG_CONFIG_DIRS")
-            (files '("etc")))))
-    (home-page "https://ecl.common-lisp.dev/")
-    (synopsis "Embeddable Common Lisp")
-    (supported-systems (delete "i586-gnu" %supported-systems))
-    (description "ECL is an implementation of the Common Lisp language as
-defined by the ANSI X3J13 specification.  Its most relevant features are: a
-bytecode compiler and interpreter, being able to compile Common Lisp with any
-C/C++ compiler, being able to build standalone executables and libraries, and
-supporting ASDF, Sockets, Gray streams, MOP, and other useful components.")
-    ;; Note that the file "Copyright" points to some files and directories
-    ;; which aren't under the lgpl2.1+ and instead contain many different,
-    ;; non-copyleft licenses.
-    ;; See https://common-lisp.net/project/ecl/posts/ECL-license.html.
+@itemize
+@item It’s portable and should work with any compiler.
+@item It works for any REPL.
+@item It allows you to include arbitrary libraries.
+@end itemize\n")
+    (license license:gpl3+)))
+
+(define-public lush2
+  (package
+    (name "lush2")
+    (version "2.0.1")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "mirror://sourceforge/lush/lush2/lush-"
+                           version ".tar.gz"))
+       (modules '((guix build utils)))
+       (snippet
+        '(begin
+           (substitute* "src/unix.c"
+             (("\\{ \"LUSH_DATE\", __DATE__ \\},") "")
+             (("\\{ \"LUSH_TIME\", __TIME__ \\},") ""))
+           (substitute* "src/main.c"
+             (("\" \\(built \" __DATE__ \"\\)\"") ""))
+           #t))
+       (sha256
+        (base32
+         "02pkfn3nqdkm9fm44911dbcz0v3r0l53vygj8xigl6id5g3iwi4k"))))
+    (build-system gnu-build-system)
+    (arguments
+     `(;; We have to add these LIBS so that they are found.
+       #:configure-flags (list "LIBS=-lz"
+                               "X_EXTRA_LIBS=-lfontconfig"
+                               "--with-x")
+       #:tests? #f)) ; No make check.
+    (native-inputs (list intltool))
+    (inputs
+     `(("alsa-lib" ,alsa-lib)
+       ("sdl" ,sdl)
+       ("sdl-image" ,sdl-image)
+       ("sdl-mixer" ,sdl-mixer)
+       ("sdl-net" ,sdl-net)
+       ("sdl-ttf" ,sdl-ttf)
+       ("libxft" ,libxft)
+       ("fontconfig" ,fontconfig)
+       ("gsl" ,gsl)
+       ("openblas" ,openblas)
+       ("glu" ,glu)
+       ("mesa" ,mesa)
+       ("mesa-utils" ,mesa-utils)
+       ("binutils" ,binutils)
+       ("libiberty" ,libiberty)
+       ("readline" ,readline)
+       ("zlib" ,zlib)
+       ("gettext-minimal" ,gettext-minimal)))
+    (synopsis "Lisp Universal Shell")
+    (description
+     "Lush is an object-oriented Lisp interpreter/compiler with features
+designed to please people who want to prototype large numerical
+applications.  Lush includes an extensive library of
+vector/matrix/tensor manipulation, numerous numerical libraries
+(including GSL, LAPACK, and BLAS), a set of graphic functions, a
+simple GUI toolkit, and interfaces to various graphic and multimedia
+libraries such as OpenGL, SDL, Video4Linux, and ALSA (video/audio
+grabbing), and others.  Lush is an ideal frontend script language for
+programming projects written in C or other languages.  Lush also has
+libraries for Machine Learning, Neural Nets and statistical estimation.")
+    (home-page "https://lush.sourceforge.net/")
     (license license:lgpl2.1+)))
 
-(define-public clisp
+(define picolisp32
   (package
-    (name "clisp")
-    (version "2.49-92")
+    (name "picolisp32")
+    (version "19.12")
     (source
      (origin
-       (method git-fetch)
-       (uri (git-reference
-             (url "https://gitlab.com/gnu-clisp/clisp")
-             (commit "clisp-2.49.92-2018-02-18")))
-       (file-name (git-file-name name version))
+       (method url-fetch)
+       (uri (string-append "https://software-lab.de/picoLisp-" version ".tgz"))
        (sha256
-        (base32 "0k2dmgl0miz3767iks4p0mvp6xw0ysyxhjpklyh11j010rmh6hqb"))))
+        (base32 "10np0mhihr47r3201617zccrvzpkhdl1jwvz7zimk8kxpriydq2j"))
+       (modules '((guix build utils)))
+       (snippet '(begin
+                   ;; Delete the pre-compiled jar file.
+                   (delete-file "ersatz/picolisp.jar")
+                   #t))))
     (build-system gnu-build-system)
-    (native-inputs
-     (list cl-asdf))
-    (inputs (list libffcall ncurses readline libsigsegv))
+    (inputs
+     `(("openssl" ,openssl)))
     (arguments
-     `(#:configure-flags '(,@(if (string-prefix? "armhf-linux"
-                                                 (or (%current-system)
-                                                     (%current-target-system)))
-                                 '("CFLAGS=-falign-functions=4")
-                                 '())
-                           ,@(if (target-x86-64?)
-                                 '("--enable-portability"
-                                   "--with-threads=POSIX_THREADS")
-                                 '())
-                            "--with-dynamic-ffi"
-                            "--with-dynamic-modules"
-                            "--with-ffcall"
-                            "--with-readline"
-                            "--with-sigsegv"
-                            "--with-module=asdf"
-                            "--with-module=rawsock")
+     `(#:system ,(match (%current-system)
+                   ((or "armhf-linux" "aarch64-linux")
+                    "armhf-linux")
+                   (_
+                    "i686-linux"))
        #:phases
        (modify-phases %standard-phases
-         (add-after 'unpack 'patch-sh-and-pwd
+         (delete 'configure)
+         (add-after 'unpack 'fix-paths
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let* ((out (assoc-ref outputs "out"))
+                    (shebang-line (string-append
+                                   "#!" out "/bin/picolisp "
+                                   out "/lib/picolisp/lib.l")))
+               (substitute* '("bin/pil"
+                              "bin/pilIndent"
+                              "bin/pilPretty"
+                              "bin/psh"
+                              "bin/replica"
+                              "bin/vip"
+                              "bin/watchdog"
+                              "games/xchess"
+                              "misc/bigtest"
+                              "misc/calc"
+                              "misc/chat"
+                              "misc/mailing"
+                              "src/mkVers")
+                 (("#\\!bin/picolisp lib.l")
+                  shebang-line)
+                 (("#\\!\\.\\./bin/picolisp \\.\\./lib.l")
+                  shebang-line)
+                 (("#\\!/usr/bin/picolisp /usr/lib/picolisp/lib.l")
+                  shebang-line)))
+             #t))
+         (add-after 'fix-paths 'make-build-reproducible
            (lambda _
-             ;; The package is very messy with its references to "/bin/sh" and
-             ;; some other absolute paths to traditional tools.  These appear in
-             ;; many places where our automatic patching misses them.  Therefore
-             ;; we do the following, in this early (post-unpack) phase, to solve
-             ;; the problem from its root.
-             (substitute* '("src/clisp-link.in"
-                            "src/unix.d"
-                            "src/makemake.in")
-               (("/bin/sh") (which "sh")))
-             (substitute* (find-files "." "configure|Makefile")
-               (("/bin/sh") "sh"))
-             (substitute* '("src/clisp-link.in")
-               (("/bin/pwd") "pwd"))
+             (substitute* "src64/lib/asm.l"
+               (("\\(prinl \"/\\* \" \\(datSym \\(date\\)\\) \" \\*/\\)")
+                ""))
              #t))
-         (add-after 'unpack 'replace-asdf
-           ;; Use system ASDF instead of bundled one.
-           (lambda* (#:key inputs #:allow-other-keys)
-             (let* ((cl-asdf (assoc-ref inputs "cl-asdf"))
-                    (guix-asdf (string-append
-                                cl-asdf
-                                "/share/common-lisp/source/asdf/asdf.lisp"))
-                    (contrib-asdf "modules/asdf/asdf.lisp"))
-               (delete-file contrib-asdf)
-               (copy-file guix-asdf contrib-asdf)))))))
-    (native-search-paths
-     (list (search-path-specification
-            (variable "XDG_DATA_DIRS")
-            (files '("share")))
-           (search-path-specification
-            (variable "XDG_CONFIG_DIRS")
-            (files '("etc")))))
-    (home-page "https://clisp.sourceforge.io/")
-    (synopsis "Common Lisp implementation")
+         (add-after 'make-build-reproducible 'fix-permissions
+           (lambda _
+             (for-each make-file-writable
+                       '("doc/family.tgz"
+                         "doc/family64.tgz"
+                         "lib/map"
+                         "src64/tags"))
+             #t))
+         (replace 'build
+           (lambda _
+             (invoke "make" "-C" "src" "picolisp" "tools" "gate")))
+         (add-before 'check 'set-home-for-tests
+           (lambda _
+             (setenv "HOME" "/tmp")
+             #t))
+         (replace 'check
+           (lambda _
+             (invoke "./pil" "test/lib.l" "-bye" "+")))
+         (replace 'install
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let* ((out (assoc-ref outputs "out"))
+                    (bin (string-append out "/bin"))
+                    (man (string-append out "/share/man"))
+                    (picolisp (string-append out "/lib/picolisp")))
+               (copy-recursively "man" man)
+               (copy-recursively "." picolisp)
+               (for-each (lambda (name)
+                           (let ((path (string-append picolisp "/" name)))
+                             (delete-file-recursively path)))
+                         '("CHANGES" "COPYING" "CREDITS" "cygwin"
+                           "INSTALL" "man" "pil" "README" "src" "src64"
+                           "test"))
+               (mkdir-p bin)
+               (symlink (string-append picolisp "/bin/picolisp")
+                        (string-append bin "/picolisp"))
+               (symlink (string-append picolisp "/bin/pil")
+                        (string-append bin "/pil")))
+             #t)))))
+    (synopsis "Interpreter for the PicoLisp programming language")
     (description
-     "GNU CLISP is an implementation of ANSI Common Lisp.  Common Lisp is a
-high-level, object-oriented functional programming language.  CLISP includes
-an interpreter, a compiler, a debugger, and much more.")
-    (license license:gpl2+)))
+     "PicoLisp is a programming language, or really a programming system,
+including a built-in database engine and a GUI system.")
+    (home-page "https://picolisp.com/wiki/?home")
+    (license license:expat)))
+
+(define-public picolisp
+  (match (%current-system)
+    ((or "aarch64-linux" "x86_64-linux")
+     (package
+       ;; Use the 32-bit picolisp to generate the assembly files required by
+       ;; the 64-bit picolisp.
+       (inherit picolisp32)
+       (name "picolisp")
+       (native-inputs
+        (list picolisp32 which))
+       (arguments
+        (substitute-keyword-arguments (package-arguments picolisp32)
+          ((#:system _ "") (%current-system))
+          ((#:phases phases)
+           `(modify-phases ,phases
+              (delete 'fix-paths)
+              (add-before 'build 'fix-paths
+                ;; This must run after the other shebang-patching phases,
+                ;; or they will override our changes.
+                (lambda* (#:key inputs outputs #:allow-other-keys)
+                  (let* ((picolisp32 (assoc-ref inputs "picolisp32"))
+                         (out (assoc-ref outputs "out"))
+                         (shebang-line (string-append
+                                        "#!" out "/bin/picolisp "
+                                        out "/lib/picolisp/lib.l")))
+                    (substitute* '("bin/pil"
+                                   "bin/pilIndent"
+                                   "bin/pilPretty"
+                                   "bin/psh"
+                                   "bin/replica"
+                                   "bin/vip"
+                                   "bin/watchdog"
+                                   "games/xchess"
+                                   "misc/bigtest"
+                                   "misc/calc"
+                                   "misc/chat"
+                                   "misc/mailing"
+                                   "src/mkVers")
+                      (("#\\!.*picolisp32.*/bin/picolisp .*lib\\.l")
+                       shebang-line))
+                    (substitute* "src64/mkAsm"
+                      (("/usr/bin/")
+                       (string-append picolisp32 "/bin/"))))
+                  #t))
+              (replace 'build
+                (lambda _
+                  (invoke "make" "-C" "src" "tools" "gate")
+                  (invoke "make" "-C" "src64" "CC=gcc" "picolisp")))))))))
+    (_
+     (package
+       (inherit picolisp32)
+       (name "picolisp")))))
+
+(define-public roswell
+  (package
+   (name "roswell")
+   (version "23.10.14.114")
+   (home-page "https://github.com/roswell/roswell")
+   (source
+    (origin
+     (method git-fetch)
+     (uri (git-reference
+           (url "https://github.com/roswell/roswell")
+           (commit (string-append "v" version))))
+     (file-name (git-file-name name version))
+     (sha256
+      (base32 "05w5sjh1bfy2wnblc09cb9qs8h7hxkx5hcqlbgpn7md32b0m4h7g"))))
+   (build-system gnu-build-system)
+   (arguments
+    (list #:configure-flags #~(list (string-append "--prefix=" #$output))
+          #:tests? #f))
+   (native-inputs
+    (list autoconf automake intltool))
+   (inputs
+    (list curl))
+   (propagated-inputs
+    ;; Has to be propagated in order to be found during setup.
+    (list gnu-make patchelf))
+   (synopsis "Common Lisp implementation manager, launcher, and more")
+   (description
+    "Roswell started out as a command-line tool with the aim to make
+installing and managing Common Lisp implementations really simple and easy.
+Roswell has now evolved into a full-stack environment for Common Lisp
+development, and has many features that makes it easy to test, share, and
+distribute your Lisp applications.
+
+Roswell is still in beta.  Despite this, the basic interfaces are stable and
+not likely to change.")
+   (license license:expat)))
+
+(define-public s7-bootstrap
+  ;; Need s7-bootstrap to build libc_s7.so (for the REPL) and run tests
+  (let ((commit "23a64facfac06c4bc23a7de8f04691c55f88bd40") ;no releases
+        (revision "0"))
+    (hidden-package
+     (package
+       (name "s7-bootstrap")
+       (version (git-version "24.1" revision commit))
+       (source (origin
+                 (method git-fetch)
+                 (uri (git-reference
+                       (url "https://cm-gitlab.stanford.edu/bil/s7.git")
+                       (commit commit)))
+                 (file-name (git-file-name name version))
+                 (sha256
+                  (base32
+                   "0fiw8lb7rswglixvn271la2q2hgwszrf2ckykhr6jjxdvmb9a7d0"))
+                 (patches (search-patches "s7-flint-3.patch"))))
+       (build-system gnu-build-system)
+       (arguments
+        (list #:tests? #f ;no tests in bootstrap
+              #:phases #~(modify-phases %standard-phases
+                           (delete 'configure) ;no configure
+                           (replace 'build
+                             (lambda _
+                               ;; using build commands from s7 home page
+                               (display "[BUILD] repl\n")
+                               (invoke #$(cc-for-target) "s7.c" "-o" "repl"
+                                       "-I." "-O2" "-g"
+                                       "-DWITH_MAIN"
+                                       (string-append
+                                        "-DS7_LOAD_PATH=\""
+                                        #$output "/share/s7/scm\"")
+                                       "-ldl" "-lm"
+                                       "-Wl,-export-dynamic")
+                               (display "[BUILD] nrepl\n")
+                               (invoke #$(cc-for-target) "s7.c" "-o" "nrepl"
+                                       "-I." "-O2" "-g"
+                                       "-DWITH_MAIN" "-DWITH_NOTCURSES"
+                                       (string-append
+                                        "-DS7_LOAD_PATH=\""
+                                        #$output "/share/s7/scm\"")
+                                       "-ldl" "-lm" "-lnotcurses-core"
+                                       "-Wl,-export-dynamic")
+                               (display "[BUILD] libarb_s7.so\n")
+                               (invoke #$(cc-for-target) "libarb_s7.c"
+                                       "-I." "-O2" "-g"
+                                       "-shared" "-o" "libarb_s7.so"
+                                       "-lflint" "-lmpc" "-fPIC")
+                               (display "[BUILD] libnotcurses_s7.so\n")
+                               (invoke #$(cc-for-target) "notcurses_s7.c"
+                                       "-I." "-O2" "-g"
+                                       "-shared" "-o" "libnotcurses_s7.so"
+                                       "-lnotcurses-core" "-fPIC")
+                               ;; Need s7.o and ffitest for tests
+                               (display "[BUILD] s7.o\n")
+                               (invoke #$(cc-for-target) "-c" "s7.c" "-o"
+                                       "s7.o" "-I." "-O2"  "-ldl" "-lm")
+                               (display "[BUILD] ffitest\n")
+                               (invoke #$(cc-for-target) "-o" "ffitest"
+                                       "ffitest.c" "-g2" "s7.o" "-lm" "-I."
+                                       "-ldl" "-Wl,-export-dynamic")))
+                           (add-before 'check 'install-scm
+                             ;; scm files need to be installed before testing
+                             (lambda _
+                               (for-each (lambda (x)
+                                           (install-file
+                                            x (string-append
+                                               #$output "/share/s7/scm/")))
+                                         (find-files "." "\\.scm"))))
+                           (replace 'install
+                             (lambda _
+                               (let ((bin (string-append #$output "/bin"))
+                                     (share (string-append #$output
+                                                           "/share/s7/"))
+                                     (doc (string-append #$output
+                                                         "/share/doc/s7/"))
+                                     (lib (string-append #$output "/lib"))
+                                     (inc (string-append #$output "/include/")))
+                                 (install-file "repl" bin)
+                                 (install-file "nrepl" bin)
+                                 (install-file "ffitest" bin)
+                                 (install-file "libarb_s7.so" lib)
+                                 (install-file "libnotcurses_s7.so" lib)
+                                 (install-file "s7.c" share)
+                                 (install-file "s7.h" inc)
+                                 (install-file "s7.html" doc)))))))
+       (inputs (list flint mpc notcurses))
+       (home-page "https://ccrma.stanford.edu/software/snd/snd/s7.html")
+       (synopsis "Scheme interpreter intended as an extension language")
+       (description
+        "s7 is a Scheme interpreter intended as an extension language for
+other applications.  It exists as just two files, @code{s7.c} and @code{s7.h},
+that may be copied into the source tree of another application.  There are no
+libraries, no run-time init files, and no configuration scripts.  It can also
+be built as a stand-alone REPL interpreter.")
+       (license license:bsd-0)))))
+
+(define-public s7
+  (package
+    (inherit s7-bootstrap)
+    (name "s7")
+    (arguments
+     (substitute-keyword-arguments
+       (strip-keyword-arguments
+         '(#:tests?)
+         (package-arguments s7-bootstrap))
+       ((#:phases phases)
+        #~(modify-phases #$phases
+            (add-after 'unpack 'patch
+              (lambda _
+                (substitute* "s7.c"
+                  (("libc_s7.so")
+                   (string-append #$output "/lib/libc_s7.so")))))
+            (add-after 'build 'build-full
+              (lambda _
+                (invoke "repl" "./libc.scm")))
+            (replace 'check
+              (lambda* (#:key tests? #:allow-other-keys)
+                (when tests?
+                  (invoke "repl" "./s7test.scm"))))
+            (add-after 'install 'install-full
+              (lambda _
+                (install-file "libc_s7.so"
+                              (string-append #$output "/lib/"))
+                (delete-file (string-append #$output "/bin/ffitest"))))))))
+    (native-inputs (list s7-bootstrap))
+    (properties (alist-delete 'hidden? (package-properties s7-bootstrap)))))
 
 (define-public sbcl
   (package
@@ -684,264 +1512,6 @@ statistical profiler, a code coverage tool, and many other extensions.")
     (license (list license:public-domain license:bsd-2
                    (license:x11-style "file://src/code/loop.lisp")))))
 
-(define-public ccl
-  ;; Warning: according to upstream, CCL is not bootstrappable.
-  ;; See https://github.com/Clozure/ccl/issues/222 from 2019-09-02:
-  ;;
-  ;;     "As far as I know, there is no way to build CCL without an existing
-  ;;     running CCL image. It was bootstrapped back in 1986 or so as
-  ;;     Macintosh Common Lisp, by Gary Byers, I believe, who is no longer on
-  ;;     the planet to tell us the story. It SHOULD be possible to port the
-  ;;     CCL compiler to portable Common Lisp, so that ANY lisp could build
-  ;;     it, as is the case for SBCL, but I know of no attempt to do so."
-  (package
-    (name "ccl")
-    ;; XXX When updating this package, check whether we can simply append
-    ;; VERSION to the ccl-bootstrap URL again, instead of per architecture.
-    (version "1.12.1")
-    (source (origin
-              (method git-fetch)
-              (uri (git-reference
-                    (url "https://github.com/Clozure/ccl/")
-                    (commit (string-append "v" version))))
-              (file-name (git-file-name "ccl" version))
-              (sha256
-               (base32
-                "1zz291lvsrr7pps8wfl2kdxsnzjngqi4v3mil14pga4r5zanmsi7"))))
-    (build-system gnu-build-system)
-    ;; CCL consists of a "lisp kernel" and "heap image", both of which are
-    ;; shipped in precompiled form in source tarballs.  The former is a C
-    ;; program which we can rebuild from scratch, but the latter cannot be
-    ;; generated without an already working copy of CCL, and is platform
-    ;; dependent, so we need to fetch the correct tarball for the platform.
-    (inputs
-     `(("ccl-bootstrap"
-        ,(origin
-           (method url-fetch)
-           (uri (string-append
-                 "https://github.com/Clozure/ccl/releases/download/v"
-                 (match (%current-system)
-                   ("armhf-linux" "1.12/linuxarm")
-                   ;; XXX: This source only works on x86, but provide it as a
-                   ;; catch-all to prevent errors when querying this package
-                   ;; on unsupported platforms.
-                   (_ "1.12.1/linuxx86"))
-                 ".tar.gz"))
-           (sha256
-            (base32
-             (match (%current-system)
-               ("armhf-linux"
-                "0x4bjx6cxsjvxyagijhlvmc7jkyxifdvz5q5zvz37028va65243c")
-               (_ "0ll017ajcfsyx8f7zsy4394y8xxvz40iz0gcsmznp0n3mf0xi67c"))))))))
-    (native-inputs
-     (list cl-asdf m4))
-    (arguments
-     `(#:tests? #f                      ;no 'check' target
-       #:modules ((ice-9 match)
-                  (srfi srfi-26)
-                  (guix build utils)
-                  (guix build gnu-build-system))
-       #:phases
-       (modify-phases %standard-phases
-         (add-after 'unpack 'unpack-image
-           (lambda* (#:key inputs #:allow-other-keys)
-             (invoke "tar" "xzvf" (assoc-ref inputs "ccl-bootstrap"))))
-         (add-after 'unpack 'replace-asdf
-           ;; Use system ASDF instead of bundled one.
-           (lambda* (#:key inputs #:allow-other-keys)
-             (let* ((cl-asdf (assoc-ref inputs "cl-asdf"))
-                    (guix-asdf (string-append
-                                cl-asdf
-                                "/share/common-lisp/source/asdf/asdf.lisp"))
-                    (contrib-asdf "tools/asdf.lisp"))
-               (delete-file contrib-asdf)
-               (copy-file guix-asdf contrib-asdf))))
-         (delete 'configure)
-         (add-before 'build 'pre-build
-           ;; Enter the source directory for the current platform's lisp
-           ;; kernel, and run 'make clean' to remove the precompiled one.
-           (lambda* (#:key system #:allow-other-keys)
-             (substitute* "lisp-kernel/m4macros.m4"
-               (("/bin/pwd") (which "pwd")))
-             (chdir (string-append
-                     "lisp-kernel/"
-                     (match system
-                       ("i686-linux" "linuxx8632")
-                       ("x86_64-linux" "linuxx8664")
-                       ("armhf-linux" "linuxarm")
-                       (_ (string-append "unknown system: " system)))))
-             (substitute* '("Makefile")
-               (("/bin/rm") "rm"))
-             (setenv "CC" "gcc")
-             (invoke "make" "clean")))
-         ;; XXX Do we need to recompile the heap image as well for Guix?
-         ;; For now just use the one we already got in the tarball.
-         (replace 'install
-           (lambda* (#:key outputs inputs system #:allow-other-keys)
-             ;; The lisp kernel built by running 'make' in lisp-kernel/$system
-             ;; is put back into the original directory, so go back.  The heap
-             ;; image is there as well.
-             (chdir "../..")
-             (let* ((out (assoc-ref outputs "out"))
-                    (libdir (string-append out "/lib/"))
-                    (bindir (string-append out "/bin/"))
-                    (wrapper (string-append bindir "ccl"))
-                    (bash (assoc-ref inputs "bash"))
-                    (kernel
-                     (match system
-                       ("i686-linux" "lx86cl")
-                       ("x86_64-linux" "lx86cl64")
-                       ("armhf-linux" "armcl")
-                       ;; Unlikely to work, but try it anyway...
-                       (_ system)))
-                    (heap (string-append kernel ".image")))
-               (install-file kernel libdir)
-               (install-file heap libdir)
-
-               (let ((dirs `("lib" "library" "examples" "tools" "objc-bridge"
-                             ,@(match system
-                                 ("x86_64-linux"
-                                  '("x86-headers64"))
-                                 ("i686-linux"
-                                  '("x86-headers"))
-                                 (_ '())))))
-                 (for-each copy-recursively
-                           dirs
-                           (map (cut string-append libdir <>) dirs)))
-
-               (mkdir-p bindir)
-               (with-output-to-file wrapper
-                 (lambda ()
-                   (display
-                    (string-append
-                     "#!" bash "/bin/sh\n"
-                     "export CCL_DEFAULT_DIRECTORY=" libdir "\n"
-                     "exec -a \"$0\" " libdir kernel " \"$@\"\n"))))
-               (chmod wrapper #o755))
-             #t)))))
-    (native-search-paths
-     (list (search-path-specification
-            (variable "XDG_DATA_DIRS")
-            (files '("share")))
-           (search-path-specification
-            (variable "XDG_CONFIG_DIRS")
-            (files '("etc")))))
-    (supported-systems '("i686-linux" "x86_64-linux" "armhf-linux"))
-    (home-page "https://ccl.clozure.com/")
-    (synopsis "Common Lisp implementation")
-    (description "Clozure CL (often called CCL for short) is a Common Lisp
-implementation featuring fast compilation speed, native threads, a precise,
-generational, compacting garbage collector, and a convenient foreign-function
-interface.")
-    (license license:asl2.0)))
-
-(define-public lush2
-  (package
-    (name "lush2")
-    (version "2.0.1")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append "mirror://sourceforge/lush/lush2/lush-"
-                           version ".tar.gz"))
-       (modules '((guix build utils)))
-       (snippet
-        '(begin
-           (substitute* "src/unix.c"
-             (("\\{ \"LUSH_DATE\", __DATE__ \\},") "")
-             (("\\{ \"LUSH_TIME\", __TIME__ \\},") ""))
-           (substitute* "src/main.c"
-             (("\" \\(built \" __DATE__ \"\\)\"") ""))
-           #t))
-       (sha256
-        (base32
-         "02pkfn3nqdkm9fm44911dbcz0v3r0l53vygj8xigl6id5g3iwi4k"))))
-    (build-system gnu-build-system)
-    (arguments
-     `(;; We have to add these LIBS so that they are found.
-       #:configure-flags (list "LIBS=-lz"
-                               "X_EXTRA_LIBS=-lfontconfig"
-                               "--with-x")
-       #:tests? #f)) ; No make check.
-    (native-inputs (list intltool))
-    (inputs
-     `(("alsa-lib" ,alsa-lib)
-       ("sdl" ,sdl)
-       ("sdl-image" ,sdl-image)
-       ("sdl-mixer" ,sdl-mixer)
-       ("sdl-net" ,sdl-net)
-       ("sdl-ttf" ,sdl-ttf)
-       ("libxft" ,libxft)
-       ("fontconfig" ,fontconfig)
-       ("gsl" ,gsl)
-       ("openblas" ,openblas)
-       ("glu" ,glu)
-       ("mesa" ,mesa)
-       ("mesa-utils" ,mesa-utils)
-       ("binutils" ,binutils)
-       ("libiberty" ,libiberty)
-       ("readline" ,readline)
-       ("zlib" ,zlib)
-       ("gettext-minimal" ,gettext-minimal)))
-    (synopsis "Lisp Universal Shell")
-    (description
-     "Lush is an object-oriented Lisp interpreter/compiler with features
-designed to please people who want to prototype large numerical
-applications.  Lush includes an extensive library of
-vector/matrix/tensor manipulation, numerous numerical libraries
-(including GSL, LAPACK, and BLAS), a set of graphic functions, a
-simple GUI toolkit, and interfaces to various graphic and multimedia
-libraries such as OpenGL, SDL, Video4Linux, and ALSA (video/audio
-grabbing), and others.  Lush is an ideal frontend script language for
-programming projects written in C or other languages.  Lush also has
-libraries for Machine Learning, Neural Nets and statistical estimation.")
-    (home-page "https://lush.sourceforge.net/")
-    (license license:lgpl2.1+)))
-
-(define-public confusion-mdl
-  (let* ((commit "12a055581fc262225272df43287dae48281900f5"))
-    (package
-      (name "confusion-mdl")
-      (version "0.2")
-      (source (origin
-                (method git-fetch)
-                (uri (git-reference
-                      (url (string-append "https://gitlab.com/emacsomancer/" name))
-                      (commit commit)))
-                (sha256
-                 (base32
-                  "1zi8kflzvwqg97ha1sa5xjisbjs5z1mvbpa772vfxiv5ksnpxp0d"))
-                (file-name (git-file-name name version))))
-      (build-system gnu-build-system)
-      (arguments
-       `(#:tests? #f                    ; there are no tests
-         #:phases
-         (modify-phases %standard-phases
-           (delete 'configure)
-           (replace 'build
-             (lambda* (#:key (make-flags '()) #:allow-other-keys)
-               (apply invoke "make" "CC=gcc" make-flags)))
-           (replace 'install
-             (lambda* (#:key outputs #:allow-other-keys)
-               (let* ((out (assoc-ref outputs "out"))
-                      (bin (string-append out "/bin")))
-                 (install-file "mdli" bin)
-                 #t))))))
-      (native-inputs
-       (list perl))
-      (inputs
-       (list libgc))
-      (synopsis "Interpreter for the MIT Design Language (MDL)")
-      (description "MDL (the MIT Design Language) is a descendant of Lisp.  It
-was originally developed in 1971 on the PDP-10 computer under the Incompatible
-Timesharing System (ITS) to provide high level language support for the
-Dynamic Modeling Group at MIT's Project MAC.  Infocom built the original
-PDP-10 Zork in MDL and their later ZIL (Zork Implementation Language) was
-based on a subset of MDL.  Confusion is a MDL interpreter that works just well
-enough to play the original mainframe Zork all the way through.")
-      (home-page "http://www.russotto.net/git/mrussotto/confusion/src/master/src/README")
-      (license license:gpl3+))))
-
 (define man-for-txr
   (let ((commit "dfbf19b9a96474b8c1bacac85e43605e5691ceb2")
         ;; Number of additional commits since the last tag (see the output of
@@ -1077,574 +1647,3 @@ command line, to data scanning and extracting scripts, to full application
 development in a wide-range of areas.")
     (home-page "https://www.nongnu.org/txr/")
     (license license:bsd-2)))
-
-(define picolisp32
-  (package
-    (name "picolisp32")
-    (version "19.12")
-    (source
-     (origin
-       (method url-fetch)
-       (uri (string-append "https://software-lab.de/picoLisp-" version ".tgz"))
-       (sha256
-        (base32 "10np0mhihr47r3201617zccrvzpkhdl1jwvz7zimk8kxpriydq2j"))
-       (modules '((guix build utils)))
-       (snippet '(begin
-                   ;; Delete the pre-compiled jar file.
-                   (delete-file "ersatz/picolisp.jar")
-                   #t))))
-    (build-system gnu-build-system)
-    (inputs
-     `(("openssl" ,openssl)))
-    (arguments
-     `(#:system ,(match (%current-system)
-                   ((or "armhf-linux" "aarch64-linux")
-                    "armhf-linux")
-                   (_
-                    "i686-linux"))
-       #:phases
-       (modify-phases %standard-phases
-         (delete 'configure)
-         (add-after 'unpack 'fix-paths
-           (lambda* (#:key outputs #:allow-other-keys)
-             (let* ((out (assoc-ref outputs "out"))
-                    (shebang-line (string-append
-                                   "#!" out "/bin/picolisp "
-                                   out "/lib/picolisp/lib.l")))
-               (substitute* '("bin/pil"
-                              "bin/pilIndent"
-                              "bin/pilPretty"
-                              "bin/psh"
-                              "bin/replica"
-                              "bin/vip"
-                              "bin/watchdog"
-                              "games/xchess"
-                              "misc/bigtest"
-                              "misc/calc"
-                              "misc/chat"
-                              "misc/mailing"
-                              "src/mkVers")
-                 (("#\\!bin/picolisp lib.l")
-                  shebang-line)
-                 (("#\\!\\.\\./bin/picolisp \\.\\./lib.l")
-                  shebang-line)
-                 (("#\\!/usr/bin/picolisp /usr/lib/picolisp/lib.l")
-                  shebang-line)))
-             #t))
-         (add-after 'fix-paths 'make-build-reproducible
-           (lambda _
-             (substitute* "src64/lib/asm.l"
-               (("\\(prinl \"/\\* \" \\(datSym \\(date\\)\\) \" \\*/\\)")
-                ""))
-             #t))
-         (add-after 'make-build-reproducible 'fix-permissions
-           (lambda _
-             (for-each make-file-writable
-                       '("doc/family.tgz"
-                         "doc/family64.tgz"
-                         "lib/map"
-                         "src64/tags"))
-             #t))
-         (replace 'build
-           (lambda _
-             (invoke "make" "-C" "src" "picolisp" "tools" "gate")))
-         (add-before 'check 'set-home-for-tests
-           (lambda _
-             (setenv "HOME" "/tmp")
-             #t))
-         (replace 'check
-           (lambda _
-             (invoke "./pil" "test/lib.l" "-bye" "+")))
-         (replace 'install
-           (lambda* (#:key outputs #:allow-other-keys)
-             (let* ((out (assoc-ref outputs "out"))
-                    (bin (string-append out "/bin"))
-                    (man (string-append out "/share/man"))
-                    (picolisp (string-append out "/lib/picolisp")))
-               (copy-recursively "man" man)
-               (copy-recursively "." picolisp)
-               (for-each (lambda (name)
-                           (let ((path (string-append picolisp "/" name)))
-                             (delete-file-recursively path)))
-                         '("CHANGES" "COPYING" "CREDITS" "cygwin"
-                           "INSTALL" "man" "pil" "README" "src" "src64"
-                           "test"))
-               (mkdir-p bin)
-               (symlink (string-append picolisp "/bin/picolisp")
-                        (string-append bin "/picolisp"))
-               (symlink (string-append picolisp "/bin/pil")
-                        (string-append bin "/pil")))
-             #t)))))
-    (synopsis "Interpreter for the PicoLisp programming language")
-    (description
-     "PicoLisp is a programming language, or really a programming system,
-including a built-in database engine and a GUI system.")
-    (home-page "https://picolisp.com/wiki/?home")
-    (license license:expat)))
-
-(define-public picolisp
-  (match (%current-system)
-    ((or "aarch64-linux" "x86_64-linux")
-     (package
-       ;; Use the 32-bit picolisp to generate the assembly files required by
-       ;; the 64-bit picolisp.
-       (inherit picolisp32)
-       (name "picolisp")
-       (native-inputs
-        (list picolisp32 which))
-       (arguments
-        (substitute-keyword-arguments (package-arguments picolisp32)
-          ((#:system _ "") (%current-system))
-          ((#:phases phases)
-           `(modify-phases ,phases
-              (delete 'fix-paths)
-              (add-before 'build 'fix-paths
-                ;; This must run after the other shebang-patching phases,
-                ;; or they will override our changes.
-                (lambda* (#:key inputs outputs #:allow-other-keys)
-                  (let* ((picolisp32 (assoc-ref inputs "picolisp32"))
-                         (out (assoc-ref outputs "out"))
-                         (shebang-line (string-append
-                                        "#!" out "/bin/picolisp "
-                                        out "/lib/picolisp/lib.l")))
-                    (substitute* '("bin/pil"
-                                   "bin/pilIndent"
-                                   "bin/pilPretty"
-                                   "bin/psh"
-                                   "bin/replica"
-                                   "bin/vip"
-                                   "bin/watchdog"
-                                   "games/xchess"
-                                   "misc/bigtest"
-                                   "misc/calc"
-                                   "misc/chat"
-                                   "misc/mailing"
-                                   "src/mkVers")
-                      (("#\\!.*picolisp32.*/bin/picolisp .*lib\\.l")
-                       shebang-line))
-                    (substitute* "src64/mkAsm"
-                      (("/usr/bin/")
-                       (string-append picolisp32 "/bin/"))))
-                  #t))
-              (replace 'build
-                (lambda _
-                  (invoke "make" "-C" "src" "tools" "gate")
-                  (invoke "make" "-C" "src64" "CC=gcc" "picolisp")))))))))
-    (_
-     (package
-       (inherit picolisp32)
-       (name "picolisp")))))
-
-(define-public janet
-  (package
-    (name "janet")
-    (version "1.33.0")
-    (source
-     (origin
-       (method git-fetch)
-       (uri (git-reference
-             (url "https://github.com/janet-lang/janet")
-             (commit (string-append "v" version))))
-       (file-name (git-file-name name version))
-       (sha256
-        (base32 "16wgljca7hp29fz5p2dnvy2cbscjx4imf85rhjwc1jkgdjswjxli"))))
-    (build-system gnu-build-system)
-    (arguments
-     (list #:make-flags
-           #~(list
-              (string-append "DESTDIR=" #$output)
-              (string-append "PREFIX=")
-              (string-append "CC=" #$(cc-for-target)))
-           #:test-target "test"
-           #:phases
-           #~(modify-phases %standard-phases
-               (delete 'configure))))
-    (home-page "https://janet-lang.org/")
-    (synopsis "Functional, imperative and embeddable programming language")
-    (description
-     "Janet is a functional and imperative programming language.  It can be
-used for rapid prototyping, dynamic systems, and other domains where dynamic
-languages shine.  You can also add Janet scripting to an application by
-embedding a single C file and two headers.  It can be easily ported to new
-platforms.  The entire language (core library, interpreter, compiler,
-assembler, PEG) is less than 1MB.")
-    (license license:expat)))
-
-(define-public carp
-  ;; Release 0.5.5 does not support GHC 9.2.
-  (let ((commit "339722325ec607091f6035866ebedea2b69080fe")
-        (revision "1"))
-    (package
-      (name "carp")
-      (version (git-version "0.5.5" revision commit))
-      (source (origin
-                (method git-fetch)
-                (uri (git-reference
-                      (url "https://github.com/carp-lang/Carp")
-                      (commit commit)))
-                (file-name (git-file-name name version))
-                (sha256
-                 (base32
-                  "0w0j3imi4270dsmrh96spsc9xllsk5rrh817l80q1nyay9p53xwd"))))
-      (build-system haskell-build-system)
-      (arguments
-       (list #:phases
-             #~(modify-phases %standard-phases
-                 ;; Carp looks inside the sources checkout to know where to
-                 ;; find its core libraries and other files.
-                 ;; Carp emits C code and tries to compile it with an external
-                 ;; C compiler. On Linux it defaults to Clang.
-                 (add-after 'install 'wrap-programs
-                   (lambda* (#:key inputs #:allow-other-keys)
-                     (define (wrap-carp-program program)
-                       (wrap-program (string-append
-                                      #$output "/bin/" program)
-                         `("CARP_DIR" prefix
-                           (#$(package-source this-package)))
-                         `("PATH" prefix
-                           ,(list (dirname
-                                   (search-input-file inputs "bin/clang"))
-                                  (dirname
-                                   (search-input-file inputs "bin/ld"))))
-                         `("C_INCLUDE_PATH" prefix
-                           ,(list (dirname
-                                   (search-input-directory
-                                    inputs "include/linux"))
-                                  (dirname
-                                   (search-input-file
-                                    inputs "include/stdlib.h"))))))
-
-                     (for-each wrap-carp-program
-                               (list "carp"
-                                     "carp-header-parse")))))))
-      (inputs
-       (list bash-minimal
-             clang
-             ghc-blaze-markup
-             ghc-blaze-html
-             ghc-split
-             ghc-ansi-terminal
-             ghc-cmark
-             ghc-edit-distance
-             ghc-hashable
-             ghc-open-browser
-             ghc-optparse-applicative))
-      (native-inputs
-       (list ghc-hunit))
-      (home-page "https://carp-lang.org/")
-      (synopsis "Statically typed Lisp without a garbage collector")
-      (description
-       "@code{carp} is a Lisp-like programming language that compiles to
-C.  It features inferred static typing, macros, automatic memory
-management without a garbage collector, a REPL, and straightforward
-integration with code written in C.")
-      (license license:asl2.0))))
-
-(define-public lisp-repl-core-dumper
-  (package
-    (name "lisp-repl-core-dumper")
-    (version "0.8.0")
-    (source
-     (origin
-       (method git-fetch)
-       (uri (git-reference
-             (url "https://gitlab.com/ambrevar/lisp-repl-core-dumper.git")
-             (commit version)))
-       (file-name (git-file-name name version))
-       (sha256
-        (base32 "04c12gi5izpkv8ha98z9qdkbmyrsq6ga060adrx53da8z31gnhk1"))))
-    (build-system copy-build-system)
-    (arguments
-     '(#:install-plan
-       '(("lisp-repl-core-dumper" "bin/"))
-       #:phases
-       (modify-phases %standard-phases
-         (add-before 'install 'fix-utils-path
-           (lambda* (#:key inputs #:allow-other-keys)
-             (let* ((cat (search-input-file inputs "/bin/cat"))
-                    (paste (search-input-file inputs "/bin/paste"))
-                    (sort (search-input-file inputs "/bin/sort"))
-                    (basename (search-input-file inputs "/bin/basename"))
-                    (sed (search-input-file inputs "/bin/sed")))
-               (substitute* "lisp-repl-core-dumper"
-                 (("\\$\\(basename") (string-append "$(" basename))
-                 (("\\<cat\\>") cat)
-                 (("\\<paste\\>") paste)
-                 (("\\<sed\\>") sed)
-                 (("\\<sort\\>") sort))))))))
-    (inputs
-     `(("coreutils" ,coreutils-minimal)
-       ("sed" ,sed)))
-    (home-page "https://gitlab.com/ambrevar/lisp-repl-core-dumper")
-    (synopsis "Generate REPL-optimized Lisp cores on demand")
-    (description
-     "This tool generates Lisp images that can embed the provided systems
-and make for REPLs that start blazing fast.
-
-@itemize
-@item It’s portable and should work with any compiler.
-@item It works for any REPL.
-@item It allows you to include arbitrary libraries.
-@end itemize\n")
-    (license license:gpl3+)))
-
-(define-public buildapp
-  (package
-    (name "buildapp")
-    (version "1.5.6")
-    (source
-     (origin
-       (method git-fetch)
-       (uri (git-reference
-             (url "https://github.com/xach/buildapp")
-             (commit (string-append "release-" version))))
-       (file-name (git-file-name name version))
-       (sha256
-        (base32 "020ipjfqa3l8skd97cj5kq837wgpj28ygfxnkv64cnjrlbnzh161"))))
-    (build-system gnu-build-system)
-    (native-inputs
-     (list sbcl))
-    (arguments
-     `(#:tests? #f
-       #:make-flags
-       (list (string-append "DESTDIR=" (assoc-ref %outputs "out")))
-       #:strip-binaries? #f
-       #:phases
-       (modify-phases %standard-phases
-         (delete 'configure)
-         (add-after 'unpack 'set-home
-           (lambda _
-             (setenv "HOME" "/tmp")
-             #t))
-         (add-before 'install 'create-target-directory
-           (lambda* (#:key outputs #:allow-other-keys)
-             (let* ((bin (string-append (assoc-ref outputs "out") "/bin")))
-               (mkdir-p bin)
-               #t))))))
-    (home-page "https://www.xach.com/lisp/buildapp/")
-    (synopsis "Makes easy to build application executables with SBCL")
-    (description
-     "Buildapp is an application for SBCL or CCL that configures and saves an
-executable Common Lisp image.  It is similar to cl-launch and hu.dwim.build.")
-    (license license:bsd-2)))
-
-(define-public eisl
-  (package
-    (name "eisl")
-    (version "3.50")
-    (source
-     (origin
-       (method git-fetch)
-       (uri (git-reference
-             (url "https://github.com/sasagawa888/eisl")
-             (commit (string-append "v" version))))
-       (file-name (git-file-name name version))
-       (sha256
-        (base32 "18alxwpvkcjfm63bc5kp6nn8351fl0p0ccxc8j9a7nb3fmg4fvyb"))))
-    (build-system gnu-build-system)
-    (inputs
-     (list bash-minimal freeglut gdbm libiconv ncurses tcl tk))
-    (native-inputs
-     (list cppcheck))
-    (arguments
-     (list #:make-flags
-           #~(list (string-append "PREFIX=" #$output)
-                   (string-append "CC=" #$(cc-for-target)))
-           #:phases
-           #~(modify-phases %standard-phases
-               (add-after 'unpack 'fix-paths
-                 (lambda* (#:key inputs #:allow-other-keys)
-                   (substitute* "library/compiler.lsp"
-                     (("\"cc ")
-                      "\"gcc "))
-                   (substitute* "library/tcltk.lsp"
-                     (("include <tcl/tcl\\.h>")
-                      "include <tcl.h>")
-                     (("c-option \"-ltcl -ltk\" linux")
-                      "c-option \"-ltcl8.6 -ltk8.6\" linux"))))
-               (delete 'configure)
-               (add-after 'install 'wrap
-                 (lambda* (#:key inputs #:allow-other-keys)
-                   (wrap-program (string-append #$output "/bin/eisl")
-                     `("PATH" prefix
-                       ,(map (lambda (bin)
-                               (string-append (assoc-ref inputs bin) "/bin"))
-                             '("binutils" "coreutils" "gcc" "ld-wrapper")))
-                     `("LIBRARY_PATH" suffix
-                       ,(map (lambda (lib)
-                               (string-append (assoc-ref inputs lib) "/lib"))
-                             '("libc")))))))))
-    (home-page "https://github.com/sasagawa888/eisl")
-    (synopsis "Implementation of ISLisp")
-    (description "Easy ISLISP (eisl) is an implementation of ISLisp which
-includes a compiler as well as an interpreter.")
-    (license (list license:bsd-2 ;; documents/license.txt
-                   license:expat ;; cii/LICENSE
-                   license:gpl2+ ;; nana/gdb/test.c and others under nana/
-                   license:bsd-3)))) ;; bench/*
-
-(define-public s7-bootstrap
-  ;; Need s7-bootstrap to build libc_s7.so (for the REPL) and run tests
-  (let ((commit "23a64facfac06c4bc23a7de8f04691c55f88bd40") ;no releases
-        (revision "0"))
-    (hidden-package
-     (package
-       (name "s7-bootstrap")
-       (version (git-version "24.1" revision commit))
-       (source (origin
-                 (method git-fetch)
-                 (uri (git-reference
-                       (url "https://cm-gitlab.stanford.edu/bil/s7.git")
-                       (commit commit)))
-                 (file-name (git-file-name name version))
-                 (sha256
-                  (base32
-                   "0fiw8lb7rswglixvn271la2q2hgwszrf2ckykhr6jjxdvmb9a7d0"))
-                 (patches (search-patches "s7-flint-3.patch"))))
-       (build-system gnu-build-system)
-       (arguments
-        (list #:tests? #f ;no tests in bootstrap
-              #:phases #~(modify-phases %standard-phases
-                           (delete 'configure) ;no configure
-                           (replace 'build
-                             (lambda _
-                               ;; using build commands from s7 home page
-                               (display "[BUILD] repl\n")
-                               (invoke #$(cc-for-target) "s7.c" "-o" "repl"
-                                       "-I." "-O2" "-g"
-                                       "-DWITH_MAIN"
-                                       (string-append
-                                        "-DS7_LOAD_PATH=\""
-                                        #$output "/share/s7/scm\"")
-                                       "-ldl" "-lm"
-                                       "-Wl,-export-dynamic")
-                               (display "[BUILD] nrepl\n")
-                               (invoke #$(cc-for-target) "s7.c" "-o" "nrepl"
-                                       "-I." "-O2" "-g"
-                                       "-DWITH_MAIN" "-DWITH_NOTCURSES"
-                                       (string-append
-                                        "-DS7_LOAD_PATH=\""
-                                        #$output "/share/s7/scm\"")
-                                       "-ldl" "-lm" "-lnotcurses-core"
-                                       "-Wl,-export-dynamic")
-                               (display "[BUILD] libarb_s7.so\n")
-                               (invoke #$(cc-for-target) "libarb_s7.c"
-                                       "-I." "-O2" "-g"
-                                       "-shared" "-o" "libarb_s7.so"
-                                       "-lflint" "-lmpc" "-fPIC")
-                               (display "[BUILD] libnotcurses_s7.so\n")
-                               (invoke #$(cc-for-target) "notcurses_s7.c"
-                                       "-I." "-O2" "-g"
-                                       "-shared" "-o" "libnotcurses_s7.so"
-                                       "-lnotcurses-core" "-fPIC")
-                               ;; Need s7.o and ffitest for tests
-                               (display "[BUILD] s7.o\n")
-                               (invoke #$(cc-for-target) "-c" "s7.c" "-o"
-                                       "s7.o" "-I." "-O2"  "-ldl" "-lm")
-                               (display "[BUILD] ffitest\n")
-                               (invoke #$(cc-for-target) "-o" "ffitest"
-                                       "ffitest.c" "-g2" "s7.o" "-lm" "-I."
-                                       "-ldl" "-Wl,-export-dynamic")))
-                           (add-before 'check 'install-scm
-                             ;; scm files need to be installed before testing
-                             (lambda _
-                               (for-each (lambda (x)
-                                           (install-file
-                                            x (string-append
-                                               #$output "/share/s7/scm/")))
-                                         (find-files "." "\\.scm"))))
-                           (replace 'install
-                             (lambda _
-                               (let ((bin (string-append #$output "/bin"))
-                                     (share (string-append #$output
-                                                           "/share/s7/"))
-                                     (doc (string-append #$output
-                                                         "/share/doc/s7/"))
-                                     (lib (string-append #$output "/lib"))
-                                     (inc (string-append #$output "/include/")))
-                                 (install-file "repl" bin)
-                                 (install-file "nrepl" bin)
-                                 (install-file "ffitest" bin)
-                                 (install-file "libarb_s7.so" lib)
-                                 (install-file "libnotcurses_s7.so" lib)
-                                 (install-file "s7.c" share)
-                                 (install-file "s7.h" inc)
-                                 (install-file "s7.html" doc)))))))
-       (inputs (list flint mpc notcurses))
-       (home-page "https://ccrma.stanford.edu/software/snd/snd/s7.html")
-       (synopsis "Scheme interpreter intended as an extension language")
-       (description
-        "s7 is a Scheme interpreter intended as an extension language for
-other applications.  It exists as just two files, @code{s7.c} and @code{s7.h},
-that may be copied into the source tree of another application.  There are no
-libraries, no run-time init files, and no configuration scripts.  It can also
-be built as a stand-alone REPL interpreter.")
-       (license license:bsd-0)))))
-
-(define-public s7
-  (package
-    (inherit s7-bootstrap)
-    (name "s7")
-    (arguments
-     (substitute-keyword-arguments
-       (strip-keyword-arguments
-         '(#:tests?)
-         (package-arguments s7-bootstrap))
-       ((#:phases phases)
-        #~(modify-phases #$phases
-            (add-after 'unpack 'patch
-              (lambda _
-                (substitute* "s7.c"
-                  (("libc_s7.so")
-                   (string-append #$output "/lib/libc_s7.so")))))
-            (add-after 'build 'build-full
-              (lambda _
-                (invoke "repl" "./libc.scm")))
-            (replace 'check
-              (lambda* (#:key tests? #:allow-other-keys)
-                (when tests?
-                  (invoke "repl" "./s7test.scm"))))
-            (add-after 'install 'install-full
-              (lambda _
-                (install-file "libc_s7.so"
-                              (string-append #$output "/lib/"))
-                (delete-file (string-append #$output "/bin/ffitest"))))))))
-    (native-inputs (list s7-bootstrap))
-    (properties (alist-delete 'hidden? (package-properties s7-bootstrap)))))
-
-(define-public roswell
-  (package
-   (name "roswell")
-   (version "23.10.14.114")
-   (home-page "https://github.com/roswell/roswell")
-   (source
-    (origin
-     (method git-fetch)
-     (uri (git-reference
-           (url "https://github.com/roswell/roswell")
-           (commit (string-append "v" version))))
-     (file-name (git-file-name name version))
-     (sha256
-      (base32 "05w5sjh1bfy2wnblc09cb9qs8h7hxkx5hcqlbgpn7md32b0m4h7g"))))
-   (build-system gnu-build-system)
-   (arguments
-    (list #:configure-flags #~(list (string-append "--prefix=" #$output))
-          #:tests? #f))
-   (native-inputs
-    (list autoconf automake intltool))
-   (inputs
-    (list curl))
-   (propagated-inputs
-    ;; Has to be propagated in order to be found during setup.
-    (list gnu-make patchelf))
-   (synopsis "Common Lisp implementation manager, launcher, and more")
-   (description
-    "Roswell started out as a command-line tool with the aim to make
-installing and managing Common Lisp implementations really simple and easy.
-Roswell has now evolved into a full-stack environment for Common Lisp
-development, and has many features that makes it easy to test, share, and
-distribute your Lisp applications.
-
-Roswell is still in beta.  Despite this, the basic interfaces are stable and
-not likely to change.")
-   (license license:expat)))