Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

awesome-cl

A curated list of awesome Common Lisp frameworks, libraries and other shiny stuff.
https://github.com/CodyReichert/awesome-cl

Last synced: about 13 hours ago
JSON representation

  • Sublime Text ##

  • Java ##

    • cl+j - A JNI-based interface to a JVM via CFFI. Not available on Quicklisp. Does not reliably work with all implementations. [Expat][14].
    • open-ldk - A Java JIT Compiler and Runtime in Common Lisp. [GPL3.0][89]. (Work In Progress)
    • cl+j - A JNI-based interface to a JVM via CFFI. Not available on Quicklisp. Does not reliably work with all implementations. [Expat][14].

  • Miscellaneous ##

    • Foil - A foreign object interface; works with the JVM and CLI. Not available on Quicklisp. [CPL 1.0][47].
    • Kandria
    • trivial-gamekit
    • Vecto - Simple vector drawing library. [FreeBSD][39].
    • zpng - A library for creating PNG files. [FreeBSD][39].
    • pngload-fast - A PNG (Portable Network Graphics) image format decoder in portable Common Lisp with an emphasis on speed. [MIT][200].
    • okra - CFFI bindings to Ogre. Not available on Quicklisp. [3-clause BSD][15].
    • the Cookbook/GUI
    • LispWork's CAPI - A portable GUI toolkit, with mobile runtime. Proprietary, but comes with a free version.
    • Allegro's Common Graphics - a library of functions for writing windowized GUIs for Windows, Mac and Linux. Proprietary with a free version.
    • runs in the browser
    • ltk - A binding for the Tk toolkit. [LLGPL][8] or [GNU LGPL2.1][11].
    • tk custom themes - ttk-theme](https://github.com/rdbende/Forest-ttk-theme).
    • Learn Common Lisp by Example: GTK GUI with SBCL
    • ceramic - a wrapper around simpler tools to create and build an Electron app for Common Lisp. It is currently broken and unmaintained, but some tools are workth having a look at.
    • good documentation and a tutorial
    • McCLIM - An implementation of the Common Lisp Interface Manager, version II. [GNU LGPL2.1][11].
    • eql, eql5, eql5-android - Embedded Qt4 and Qt5 Lisp, embedded in ECL, embeddable in Qt. Port of EQL5 to the Android platform. [MIT][200].
    • LispWork's mobile runtime - Android and iOs. Proprietary.
    • SBCL - Steel Bank Common Lisp. A fork of CMUCL; compiles to efficient machine code. [Standard compliance][13]. Public domain, with some parts under [Expat][14] and [3-clause BSD][15].
    • ECL - Embeddable Common Lisp; compiles to C. [GNU LGPL2.1][11].
    • ABCL - Armed Bear Common Lisp; targets the JVM, compiles to bytecode. [Standard conformance][4]. [GNU GPL3][2] with [Classpath exception][3].
    • LispWorks - an integrated cross-platform development tool for Common Lisp.
    • Allegro CL - provides the full ANSI Common Lisp standard with many extensions.
    • MOCL - CL as a library for mobile devices (iOS & Android) and OSX.
    • GNU CLISP - A GNU implementation; contains a compiler and an interpreter. [Standard conformance][6]. [GNU GPL3][2]. They develop [on Gitlab](https://gitlab.com/gnu-clisp/clisp).
    • alexandria - A general-purpose utility library. Public domain.
    • anaphora - A collection of anaphoric macros. Public domain.
    • portability.cl/
    • cl-2dsyntax - An indentation-sensitive reader system. Not available on Quicklisp. Public domain.
    • mstrings - a reader macro to provide visually appealing multiline blocks. An M-string trims leading whitespace, concatenates lines together, etc. [BSD_3Clause][15].
    • closer-mop - A compatibility layer that rectifies many absent or incorrect MOP features. [Expat][14].
    • cl-advice - an attempt of portable layer advice library for SBCL, CCL, LispWorks and Allegro. Not in Quicklisp.
    • iterate - An iteration construct for Common Lisp which is extensible and Lispier. [MIT][200].
    • series - Functional style without any runtime penalty at all. [MIT][200].
    • gtwiwtg - A lazy sequences library. Similar to 'series' but not as complete. However it has a 'modern' API with stuff like `take`, `filter`, `for`, `fold`, etc. that is easy to use.
    • gmap - A concise and extensible iteration facility that has the advantage of integrating well with FSet (see the Data Structures section), as it was written by the same author. In Quicklisp as part of `misc-extensions`. Public domain.
    • f-underscore - a tiny library of functional programming utils. `(f_ (+ _ _)) -> (lambda (_) (+ _ _))`. Public domain.
    • Blog post
    • defstar - a collection of macros for easy inclusion of type declarations for arguments in lambda lists. [GNU GPL3][2]
    • ACL2 - a logic and programming language in which you can model computer systems, together with a tool to help you prove properties of those models.
    • ACL2 Sedan
    • Using ACL2 to teach students about software testing
    • PVS
    • CCL - Clozure Common Lisp; compiler-only implementation, generates native code. [LLGPL][8].
    • nodgui - Bindings for the Tk toolkit, based on Ltk, with syntax sugar and additional widgets. [LLGPL][8].
    • source
    • Xelf - Extensible game library. Not available on Quicklisp. [GNU LGPL2.1][11].
    • PELTADOT - PELTADOT Extends Lisp’s Types And Dispatches Over Them.
    • SBCL on Chocolatey for Windows
    • pngload-fast - A PNG (Portable Network Graphics) image format decoder in portable Common Lisp with an emphasis on speed. [MIT][200].
    • trivial-gamekit
    • cl-liballegro - Interface and bindings to the Allegro 5 game programming library. [zlib][33].
    • cl-cffi-gtk - Binding for GTK+3. [GNU LGPL2.1][11].
    • bodge-nuklear - Wrapper over the [Nuklear](https://github.com/Immediate-Mode-UI/Nuklear) immediate mode GUI library. [MIT][200].
    • Queen.lisp - Chess Utilities For Common Lisp. MIT.
    • cl-opengl - CFFI bindings to OpenGL, GLU and GLUT APIs. [3-clause BSD][15].
    • trivial-gamekit
    • cl-sdl2 - Bindings for SDL2 using C2FFI. [Expat][14].
    • Cells - an implementation of the dataflow programming paradigm, reactive spreadsheet-like expressiveness for CLOS. Used to build an [algebra learning system](http://tiltontec.com/). With [documentation](https://github.com/stefano/cells-doc/). Lisp LGPL.
    • lisp-magick-wand - ImageMagick bindings. [BSD][15]. Not in Quicklisp.
    • Sketch - A CL framework for the creation of electronic art, graphics, and lots more. [MIT][200].
    • dufy - exact color manipulation and conversion in various color models. [MIT][200].
    • Varjo - Lisp to GLSL translator. [BSD_2Clause][17].
    • Corman Lisp - a Common Lisp development environment for Microsoft Windows running on Intel platforms. [MIT][200].
    • inlined-generic-function
    • arrow-macros - Clojure-like threading macros. [MIT][200].
    • opticl - a library for representing and processing images. [BSD_2Clause][17].
    • cl-cuda - A library to use NVIDIA CUDA in Common Lisp programs. [LLGPL][8].
    • Trial - Trial is an OpenGL game engine with a heavy focus on modularity. It is supposed to provide a large toolkit of useful bits and pieces from which you can create a game. [zlib][33].
    • virality - A component-based game engine written in Common Lisp [MIT][200].
    • cl-gamepad - Access to gamepads and joysticks on Windows, Mac OS, and Linux. [zlib][33].
    • cl-mpg123 - out123](https://shirakumo.github.io/cl-out123), bindings libraries for libmpg123 and libout123 respectively, giving you fast and easy to use mp3 decoding and cross-platform audio output. [zlib][33].
    • cl-svg - A basic library for producing SVG files. [Expat][14].
    • Electron-lisp-boilerplate - a rudimentary boilerplate for building Electron apps that start a Lisp process.
    • ACL2-kernel
    • doplus
    • quid-pro-quo - a contract
    • AP5 - allows users to program in a model of first order logic or a relational database. 1989, updated 2024. Public domain.
    • imago - image manipulation library for Common Lisp.
    • Temperance - logic programming. [MIT][200]. A focus on performance, with General Game Playing in mind.
    • nhooks - an enhanced implementation of hooks (extension points) with crucial improvements.
    • eclweb - of-concept REPL inside a browser](https://repl.chee.party/) using Web Assembly (WASM).
    • algebraic-data-types - defining algebraic data types in a similar spirit to Haskell or Standard ML, as well as for operating on them. [BSD_3Clause][15].
    • fn - a couple of lambda shorthand macros. `(fn* (+ _ _)) --> (lambda (_) (+ _ _))`. Public domain.
    • lwcells - Light Weight Cells.
    • cl-gtk4 - GTK4/Libadwaita/WebKit binding for Common Lisp. [LGPL3][9].
    • SBCL Windows builds supporting Windows 7+
    • fast-generic-functions - Seal your generic functions for an extra boost in performance. [MIT][200].
    • coalton-threads - primitive thread and concurrency operations for Coalton.
    • Barium - an X widget toolkit, directly accessing the X client library and other platform libraries (OpenGL, Cairo). [MIT][200].
    • clogframe - an executable wrapper for webview.h, allowing to display any web application served by a Common Lisp server.
    • ECL - Embeddable Common Lisp; compiles to C. [GNU LGPL2.1][11].
    • generic-cl - Generic function interface to standard Common Lisp functions (equality, comparison, arithmetic, objects, iterator, sequences,…). [MIT][200].
    • pythonic-string-reader - A simple and unobtrusive read table modification inspired by Python's three quote strings. [BSD_3Clause][15].
    • cl-reader - A utility library intended at providing reader macros for lambdas, mapping, accessors, hash-tables and hash-sets. [MIT][200].
    • iterate - An iteration construct for Common Lisp which is extensible and Lispier. [MIT][200].
    • for - A concise, lispy and extensible iteration macro. It is extensible and sensible, and unlike iterate it does not require code-walking and is easier to extend. [zlib][33].
    • cl-transducers - Ergonomic, efficient data processing. [LGPL3][9].
    • Trial - Trial is an OpenGL game engine with a heavy focus on modularity. It is supposed to provide a large toolkit of useful bits and pieces from which you can create a game. Custom: [zlib][33] with a political clause added.
    • claw-raylib - Fully auto-generated Common Lisp bindings to Raylib and Raygui using claw and cffi-object. Apache 2.0.
    • raylib - Hand-written bindings to Raylib for improved performance and smaller dependency footprint. [MPL-2.0][211].
    • trivial-svg - render SVG images to PNG using Vecto and zpb-ttf. 0BSD.
    • glfw - An up-to-date Common Lisp bindings library to the most recent GLFW OpenGL context management library.
    • common-cv - the OpenCV (Open Source Computer Vision Library) binding library for CommonLisp. No license specified.
    • cl-cairo2 - Cairo bindings. [Boost 1.0][54]
    • cl-gd - A library providing an interface to the GD graphics library. [FreeBSD][39].
    • cl-horde3d - FFI bindings to the Horde3D graphics library. Not available on Quicklisp. [EPL 1.0][59]
    • cl-jpeg - Baseline JPEG encoder and decoder library. [3-clause BSD][15].
    • CLinch - Common Lisp 2D/3D graphics engine for OpenGL. [FreeBSD][39].
    • donuts - Graphviz interface for Common Lisp. [Expat][14].
    • lispbuilder-sdl - A set of bindings for SDL. [Expat][14].
    • Qtools - A Qt toolkit, based on CommonQt. [zlib][33] Also [Qtools-ui](https://codeberg.org/shinmera/qtools-ui) (premade UI components), with [videos](https://www.youtube.com/watch?v=KwASFOhYta4&index=7&list=PLkDl6Irujx9Mh3BWdBmt4JtIrwYgihTWp).
    • CommonQt - A Common Lisp binding for Qt4 via QtSmoke. [FreeBSD][39].
    • CommonQt5 - bindings for Qt5.
    • ltk - A binding for the Tk toolkit. [LLGPL][8] or [GNU LGPL2.1][11].
    • LTk Examples - Provides LTk examples for the tkdocs tutorial.
    • LTk Plotchart - A wrapper around the tklib/plotchart library to work with LTk. This includes over 20 different chart types (xy-plots, gantt charts, 3d-bar charts etc...).
    • CocoaInterface
    • McCLIM - An implementation of the Common Lisp Interface Manager, version II. [GNU LGPL2.1][11].
    • discussion
    • Anathema
    • cl-webkit - A binding to WebKitGTK+. Also adds web browsing capabilities to an application, leveraging the full power of the WebKit browsing engine. [MIT][200].
    • ftw - A Win32 GUI library. [MIT][200].
    • EQL5 on the Android store
    • vk - Common Lisp/CFFI bindings for the Vulkan API. [MIT][200].
    • cl-vulkan - supports Vulkan 1.0 and 1.2, including compute pipelines. Vulkan 1.1 and 1.3 are coming soon©. MIT.
    • file-select - A library to invoke the native system file dialog to select or create files. Zlib.
    • demo to use Java Swing from ABCL
    • Three web views for Common Lisp
    • LQML - a lightweight ECL binding to QML (both Qt5 and Qt6) derived from EQL5. LGPL and public domain.
    • sbcl-termux-build - Prebuilt SBCL binary for Android (Termux).
    • hello-alien
    • SBCL - Steel Bank Common Lisp. A fork of CMUCL; compiles to efficient machine code. [Standard compliance][13]. Public domain, with some parts under [Expat][14] and [3-clause BSD][15].
    • sbcl-librarian - Dynamic library delivery tools for SBCL. Create shared libraries that can be called from C or Python. MIT. [Blog post](https://mstmetent.blogspot.com/2022/04/using-lisp-libraries-from-other.html). [Tutorial](https://lispcookbook.github.io/cl-cookbook/dynamic-libraries.html).
    • SBCL-GOODIES - Distributing binaries with Common Lisp and foreign libraries: libssl, libcrypto and libfixposix are statically baked in. [MIT][200].
    • Nightly Windows builds of SBCL - Nightly builds of SBCL using MSYS2 UCRT64. See also [Roswell's SBCL MSI builds](https://github.com/roswell/sbcl_bin/releases/).
    • WIP, 2021
    • NLNET grant in 2025
    • abcl-memory-compiler - a way to compile Java source code to create Java classes at runtime with ABCL. [Apache2][89].
    • open-source libraries
    • cl-all - A script to run Lisp snippets in multiple implementations. This allows you to quickly compare implementation behaviour and differences. [zlib][33].
    • alexandria - A general-purpose utility library. Public domain.
    • rutils - radical yet reasonable syntactic utilities for Common Lisp. [MIT][200].
    • equals
    • anaphora - A collection of anaphoric macros. Public domain.
    • hu.dwim.walker - a code walker and unwalker (aka AST parser and unparser). [BSD][15]. See also [this blog post](http://40ants.com/lisp-project-of-the-day/2020/04/0044-hu.dwim.walker.html).
    • trivial-arguments - A portable library to retrieve the arguments list of a function. [zlib][33].
    • definitions - a general definitions introspection library. It gives you the ability to retrieve definitions or bindings associated with designators such as symbols, packages, and names in general. [zlib][33].
    • dissect - when a lot of projects use the “trivial-backtrace” system that just gives them a string with a backtrace, Dissect allows you to capture, step, and completely inspect the stack trace on a variety of Lisp implementations. Also very useful for logging and other situations where execution is automatically continued, but the information of the current stack is still useful to store somewhere. [zlib][33].
    • cl-annot - Python-like annotations for Common Lisp. [LLGPL][8].
    • cl-annot-revisit - re-implementation of cl-annot. WTFPL.
    • clamp - Arc language's brevity and conciseness to Common Lisp. [Artistic License 2.0][51].
    • arc-compat - Arc compatible package. Perl Foundation's Artistic Licence 2.0.
    • cl-interpol - A set of reader modifications to allow string interpolation. [BSD][15].
    • f-string
    • cl-heredoc - a ["heredocs"](https://github.com/outergod/cl-heredoc) dispatcher. [GPL3][2]. Allows to write: `#>eof>Write whatever (you) "want", no matter what characters, until the magic end sequence has been reached.eof`
    • Moonly - Algol-style syntax that transpiles to Common Lisp.
    • closer-mop - A compatibility layer that rectifies many absent or incorrect MOP features. [Expat][14].
    • specialization-store - generic functions based on types. Simplified BSD License variant.
    • filtered-functions - enable the use of arbitrary predicates for selecting and applying methods. [MIT][200].
    • static-dispatch - allows standard generic function dispatch to be performed statically (at compile time) rather than dynamically (runtime). This is similar to what is known as "overloading" in languages such as C++ and Java. [MIT][200].
    • dynamic-mixins - simple, dynamic class combination. [BSD_2Clause][17].
    • polymorphic functions - A function type to dispatch on types instead of classes with partial support for dispatching on optional and keyword argument types. Still experimental (May, 2021). [MIT][200].
    • defclass-std - a shortcut macro to write DEFCLASS and PRINT-OBJECT forms quickly. [LLGPL][8].
    • nclasses - Syntactic sugar for class and generic function declarations. Features type inference, automatic accessors, inline initform syntax, automatic exports, and other conveniences. [BSD][15].
    • slot-extra-options - lets you build a metaclass which in turn lets you specify extra slot options in its classes. [LGPL3][9].
    • method-hooks - When CLOS method combination allow only one hook per method, this library allows an arbitrary number of them. Mozilla Public Licence.
    • Khazern - An implementation of CL:LOOP that can be used in any CL implementation without replacing the core CL:LOOP, is extensible and has a "batteries included" extension system with many useful iteration constructs.
    • snakes - Python style generators for Common Lisp. Includes a port of itertools. [Apache2][89].
    • picl - An (almost) complete port of Python's itertools package, complete with laziness where applicable, and not relying on cl-cont. [MIT][200].
    • cl-prolog2 - Common Interface to ISO Prolog implementations from Common Lisp. [MIT][200].
    • Screamer - augment Common
    • Screamer+ - increasing the expressiveness of SCREAMER. [MIT][200].
    • dual numbers - lang.github.io/reference/#coalton-library/math/hyperdual-package),
    • tokyo-tojo-json - a JSON parser implemented in Coalton.
    • coalton-io - Functional IO interfaces. Includes terminal IO, file system IO, random variables, mutable variables, multithreading, and safely sharing state between threads.
    • Lem editor mode for Coalton - syntax highlighting, code completion, autodoc, interactive compilation commands (`coalton-compile-defun`, `C-c C-c`).
    • Coalton.app playground - a web-based REPL for Coalton. [blog post announce](https://abacusnoir.com/2025/08/12/coalton-playground-type-safe-lisp-in-your-browser/).
    • trivial-types - provides missing but important type definitions such as `proper-list`, `association-list`, `property-list` and `tuple`. [LLGPL][8].
    • typo - A portable type inference library for Common Lisp. [MIT][200].
    • Proceedings of the 19th International Workshop on the ACL2 theorem prover and its applications, 2025 (PDF)
    • IUP - CFFI bindings to the [IUP](https://www.tecgraf.puc-rio.br/iup/) Portable User Interface library (pre-ALPHA).
    • generic-cl - Generic function interface to standard Common Lisp functions (equality, comparison, arithmetic, objects, iterator, sequences,…). [MIT][200].
    • trivia - Optimized pattern-matching library. [LLGPL][8].
    • trivial-do - Additional dolist style macros for Common Lisp. [MIT][200].
    • cl-transducers - Ergonomic, efficient data processing. [LGPL3][9].
    • raylib - Hand-written bindings to Raylib for improved performance and smaller dependency footprint. [MPL-2.0][211].
    • lisp-magick-wand - ImageMagick bindings. [BSD][15]. Not in Quicklisp.
    • CommonQt5 - bindings for Qt5.
    • CocoaInterface
    • equals
    • specialization-store - generic functions based on types. Simplified BSD License variant.
    • cl-punch - Scala-like anonymous lambda literals. `(mapcar ^(* 2 _) '(1 2 3 4 5))`. [MIT][200].
    • cl-prolog2 - Common Interface to ISO Prolog implementations from Common Lisp. [MIT][200].
    • live-cells - A reactive programming library for Lisp. BSD_3Clause.
    • typo - A portable type inference library for Common Lisp. [MIT][200].
    • Proofpad
    • eon - An easy-to-use but flexible game framework based on Raylib for Common Lisp. Apache2.0.

  • Emacs Lisp

    • CLOCC's elisp.lisp - Emacs Lisp in Common Lisp.
    • CEDAR - an advance interactive development environment aiming to be Emacs compatible with all the features that come with it. Stalled.

  • Expert Systems

    • extensive comparison - ov-file#json-benchmarks).
    • CLM - Common Lisp Music is a music synthesis and signal processing package in the Music V family. It provides much the same functionality as Stk, Csound, SuperCollider, PD, CMix, cmusic, and Arctic — a collection of functions that create and manipulate sounds, aimed primarily at composers (in CLM's case anyway).
    • AllegroGraph - a high-performance, multi-model (document and graph), entity-event knowledge graph technology.
    • roadmap
    • xlsx - a basic reader for Excel files.
    • pgloader - a data loading tool for PostgreSQL. [PostgreSQL Licence][205].
    • csound - A sound and music computing system. Includes CFFI and FFI interfaces for Common Lisp.
    • screenshotbot-oss
    • with-c-syntax - a fun package which introduces the C language syntax into Common Lisp. (Yes, this package is not for practical coding, I think.) WTFPL Licence.
    • cl-redis - Redis client. [Expat][14].
    • asdf-linguist - Extensions for ASDF for compiling various languages and running various preprocessing tools on files in your project. [Expat][14].
    • April - The APL programming language (a subset thereof) compiling to Common Lisp. Replace hundreds of lines of number-crunching code with a single line of APL. [Apache2][89].
    • cl-permutation - Permutations and permutation groups in Common Lisp. [BSD_3Clause][15].
    • cl-collider - A [SuperCollider](http://supercollider.github.io/) client for CommonLisp. With a [tutorial](https://github.com/defaultxr/cl-collider-tutorial) and [live coding demos](https://www.youtube.com/watch?v=xzTH_ZqaFKI). Public domain.
    • bit-smasher - Common Lisp library for handling bit vectors, bit vector arithmetic, and type conversions. [MIT][200].
    • auto-text - automatic (encoding, end of line, column width, csv delimiter etc) detection for text files. [MIT][200]. See also [inquisitor](https://github.com/t-sin/inquisitor) for detection of asian and far eastern languages.
    • base-lisp-image - base
    • Ironclad - A library of crypto functions for Common Lisp. Not considered secure, but is still useful for the message digest functions. [Expat][14].
    • cl-yacclyaml - a pure lisp YAML processor (loader, but not yet dumper). [GPL3][2].
    • endatabas - Schemaless SQL document database with full history. [AGPL-3.0][89].
    • mito - An ORM for Common Lisp with migrations, relationships and PostgreSQL support [BSD_3Clause][15].
    • Software-Evolution-Library - The SEL enables the programmatic modification and evaluation of software (C/C++ support using Clang, compiled assembler, and linked ELF binaries). [GPL3][2].
    • C-mera - a source-to-source compiler that utilizes Lisp's macro system for meta programming of C-like languages. [GPL3][2].
    • cl-duckdb - Common Lisp CFFI wrapper around the DuckDB C API. [MIT][200].
    • sycamore - a fast, purely functional data structure library. [BSD_3Clause][15].
    • str - a modern, simple and consistent string manipulation library. [MIT][200].
    • cl-openal - bindings for the OpenAL audio library. Public domain.
    • asdf-viz - a tool to visualize the library dependencies of ASDF systems, the call graph of a function and the class inheritances. [LLGPL][8].
    • FSet vs. Sycamore
    • cl-dbi - A database-independent interface for Common Lisp. [LLGPL][8].
    • sxql - A DSL for generating SQL. [3-clause BSD][15].
    • mitho-auth
    • mito-attachment
    • JOSE - A JSON Object Signing and Encryption (JOSE) implementation for Common Lisp. BSD_2Clause.
    • datafly - A lightweight database library. [3-clause BSD][15].
    • peercoin-vote - A voting system based on data from the blockchain (addresses and balances). [GPL3][2]. Not in Quicklisp.
    • peercoin-calculator - This program gives you the probability of generating a POS or POW block within 10 minutes, 24 hours, 31 days, 90 days and 1 year, as well as the reward that can be expected. GUI in Qt. [GPL3][2]. Not in Quicklisp.
    • peercoin-blockchain-parser - parse the blockchain contained in a file and export some of its data to a text file, a SQL script or a database. It can also create a database using the RPC of a Peercoin daemon as source of data instead of a blockchain file. LGPL3. Not in Quicklisp.
    • nonempty - Non-empty collections for Common Lisp. [LGPL3][9].
    • osc - an implementation of the Open Sound Protocol. [LGPL2.1][11].
    • NJSON - Parser-agnostic JSON indexing (with JSON Pointer support), destructuring, and validation framework. [BSD][15].
    • cl-containers - an extensive library of data structures and utilities - queues, trees, heaps, doubly-linked lists, sets, bags,... [MIT][200]
    • shasht - Common Lisp JSON reading and writing for the Kzinti. [MIT][14].
    • archlinux-cl - Docker Arch Linux image with Common Lisp implementations (7 to this day). MIT.
    • xmls - A small, simple, non-validating XML parser. [3-clause BSD][15].
    • rope - Immutable Ropes for Common Lisp. MIT.
    • easy-audio - a collection of audio decoders and metadata readers.
    • cl-bunny - Common Lisp RabbitMQ client based on IOLib. MIT.
    • docker-lisp-gamedev - A Docker image containing tools necessary for Common Lisp game development and deployment. Comes in Linux and Windows variety. Thoroughly tested via CI.
    • 40ants/setup-lisp - GitHub Action to Setup Common Lisp tools.
    • Trial's CI
    • Lisa - a production-quality, forward-chaining expert system shell featuring an optimized implementation of Charles Forgy's Rete algorithm, a highly efficient solution to the difficult many-to-many pattern matching problem. MIT.
    • rq - a library for rhythm transcription in OpenMusic (version 6.10 and later). [demo video](https://www.youtube.com/watch?v=XVEllB0TtVs). [GPL3][2].
    • cl-jwk - Common Lisp system for decoding public JSON Web Keys (JWK). BSD License.
    • cl-migratum - a system which provides facilities for performing database schema migrations, designed to work with various databases. [BSD_3Clause][15].
    • cl-ssh-keys - Common Lisp system for generating and parsing of OpenSSH keys. [BSD_3Clause][15].
    • cl-bcrypt - Common Lisp system for parsing and generating bcrypt password hashes. [BSD_3Clause][15].
    • bitfield - Efficiently represent several finite sets or small integers as a single non-negative integer. [MIT][200].
    • cl-ctrie
    • coalton-zmq - ZeroMQ interface for Coalton.
    • pantry - client library for the [Pantry JSON storage service](https://getpantry.cloud/). BSD.
    • jfon - an attempt at porting JZON (JSON parsing library) to FSet.
    • Common Music - the repository of an
    • cl-rethinkdb - RethinkDB client. [Expat][14].
    • access - Consistent and nested access to most common data structures. [BSD_3Clause][15].
    • common-tones - a fork of CLM5 with modern Lisp (ASDF, cffi…). [BSD_3Clause][15].
    • cm-incudine - extends Common Music 2 with realtime capabilities. GPL2.
    • cl-patterns - a system for composing music via Lisp code, heavily inspired by SuperCollider’s patterns system, with aims to implement much of it, but in a more robust, expressive, consistent, reflective, and lispy way. Audio output through SuperCollider, with preliminary support for Incudine, and MIDI through ALSA.
    • Music - A framework for musical expression in Lisp with a focus on music theory (built from scratch, unrelated to Common Music).
    • Harmony - A real-time sound processing and playback system. [zlib][33].
    • cl-mixed
    • scheduler - The time based musical event scheduler for Common Lisp. [Apache2.0][89].
    • Common Music Notation - Common Music Notation (CMN) provides a package of functions to hierarchically describe a musical score. Public domain.
    • cl-mpg123 - opus](https://github.com/Shirakumo/cl-opus) (OGG/Opus), [cl-vorbis](https://github.com/Shirakumo/cl-vorbis) (OGG/Vorbis), [cl-SoLoud](https://github.com/Shirakumo/cl-soloud), [cl-out123](https://github.com/Shirakumo/cl-out123) (libout123), [cl-flac](https://github.com/Shirakumo/cl-flac)
    • ASDF - Another System Definition Facility; a build system for Common Lisp. [Expat][14]. Quicklisp (see [library manager](#library-manager)) uses ASDF under the hood.
    • modularize - A modularization framework for Common Lisp. [zlib][33].
    • lispc - a powerful "lispsy" macrolanguage for C. [MIT][200].
    • ecrepl - an interactive REPL for the C language. [BSD_2Clause][17].
    • vacietis - C to Common Lisp compiler. [LGPL3][9].
    • crypto-shortcuts - Collection of common crypto shortcuts. [zlib][33].
    • gpgme
    • bitcoin-core-rpc - a (hopefully) complete Bitcoin Core RPC client. [AGPL-3.0+][agpl3]
    • bp - Bitcoin Protocol components in Common Lisp. [MIT][200].
    • stacks-api - a Stacks API client. [AGPL-3.0][89]
    • legochain - generation blockchain with an innovative natural-language approach to smart contracts built in Common Lisp (stopped).
    • postmodern - A library for interacting with PostgreSQL. [zlib][33].
    • composable query builder - class values that can be derived, combined, and reused without side effects.
    • cl-yesql - SQL statements live in their own files, in SQL syntax, and are imported into Lisp as functions. You are not limited to the features a DSL supports. Based on Clojure's Yesql. [MIT][200].
    • clsql - An SQL database with a Common Lisp interface. [LLGPL][8].
    • dbd-oracle - an Oracle database driver for CL-DBI. [LLGPL][8].
    • bknr.datastore - a CLOS-based lisp-only database in RAM with transaction logging persistence. [Manual](https://www.common-lisp.net/project/bknr/html/documentation.html). [licence][208].
    • good introductory blog post
    • bknr.cluster - available replicated version of bknr.datastore.
    • ubiquitous - A library providing easy-to-use persistent configuration storage. [zlib][33].
    • cl-prevalence - in-memory database system. Implementation of Object Prevalence, in which business objects are kept live in memory and transactions are journaled for system recovery. [github fork](https://github.com/40ants/cl-prevalence). [LLGPL][8].
    • cl-prevalence-multimaster - prevalence systems state.
    • hosted version
    • cl-agraph
    • neo4cl - a library for interacting with Neo4J. Sends Cypher queries to a Neo4J server, and decodes the responses into something useful for processing in CL. [Apache2][89].
    • cl-neo4j - a thin neo4j RESTFUL client interface.
    • vivace-graph - graph database & Prolog implementation. Takes design inspiration from CouchDB, neo4j and AllegroGraph. It implements an ACID-compliant object graph model with user-defined indexes and map-reduce views. It also implements a master / slave replication scheme for redundancy and horizontal read scaling. Querying the graph is accomplished via a number of Lisp methods or via a Prolog-like query language. [MIT][200].
    • restagraph - an app that dynamically generates REST APIs for a Neo4j database, using a schema defined within the database. [GPL3][2].
    • cl-memcached - Fast, thread-safe interface to the Memcached object caching system. [Expat][14].
    • cl-disque - Disque client. [3-clause BSD][15].
    • cl-mango - A minimalist CouchDB 2.x database client. BSD_3Clause.
    • clouchdb - Library for interacting with CouchDB. [FreeBSD][39].
    • lmdb - Bindings to [LMDB](http://www.lmdb.tech/doc/), the Lightning Memory-mapped Database, an ACID key-value database with MultiVersion Concurrency Control.
    • cl-ndbapi - bindings to the C++ NDB API of [RonDB](https://www.rondb.com/), "the world's fastest key value store", by [Dydra](https://dydra.com/home). GPLv2.
    • postmodern-passenger-pigeon - a migration manager for postmodern. No licence specified.
    • dyna - an AWS DynamoDB ORM. [MIT][200].
    • pzmq - ZeroMQ 4.0+ Common Lisp bindings. Unlicense.
    • Why is pgloader so much faster? - written from Python to Common Lisp)
    • cl-csv - A library for parsing CSV files. [3-clause BSD][15].
    • documentation
    • example blog post
    • cl-decimals - Decimal number parser and formatter. Public domain.
    • csv-validator - Validates tabular CSV data using predefined validations, inspired from its Python homologue "Great Expectations". [BSD_3Clause][15].
    • lisp-stat's data-frames `read-csv` - csv](https://github.com/sirherrbatka/vellum-csv/) (data frames library), vellum-duckdb.
    • cl-json - A highly customizable JSON encoder and decoder. [MIT][14].
    • parcom/json - An extension to `parcom` for simple, fast, no-dependency JSON parsing.
    • json-mop - A metaclass for bridging CLOS and JSON objects. [MIT][200].
    • cl-json-pointer - A JSON Pointer implementation. [MIT][200].
    • clop - A 1.0-compliant TOML parser.
    • CXML - XML parser and serializer, with a range of extension libraries. [LLGPL][8].
    • FXML - formed or malicious XML, or if you need to use Klacks with namespaces.
    • xpath - lisp.net/project/plexippus-xpath/atdoc/index.html) - Implementation of the XML Path Language (XPath) Version 1.0. [BSD_2Clause][17].
    • s-xml - A basic parser. [LLGPL][8].
    • cl-feedparser - A Common Lisp (RSS, Atom) feed parser. [LLGPL][8]
    • Buildnode - A common lisp library to ease interaction with CXML-dom, such as building Excel spreadsheets. [BSD][15].
    • lisp-xl - Common Lisp Microsoft XLSX (Microsoft Excel) loader for arbitrarily-sized / big-size files. MIT.
    • cl-RemiYaml - in replacement.
    • nyaml - A lisp native YAML parser. MIT.
    • trivial-extensible-sequences - Portability library for the extensible sequences protocol ([SBCL documentation](http://www.sbcl.org/manual/#Extensible-Sequences)). [zlib][33].
    • listopia - a list manipulation library inspired by Haskell's Data.List. [LLGPL][8].
    • FSet - A functional, set-theoretic collections data structure library. [LLGPL][8].
    • jfon - an attempt at porting JZON (JSON parsing library) to FSet.
    • modf - a setf-like macro for functional programming.
    • cl-hash-util - Hash-table creation, access, and manipulation utilities. [MIT][200].
    • cl-competitive - Common Lisp algorithms collection for competitive programming. Public domain, CCO or MIT.
    • bst - Binary Search Tree. [GPL3][2].
    • pileup - a portable, performant, and thread-safe binary heap for Common Lisp. [MIT][200].
    • cl-freelock - thread-safe, lock-free queues optimized for different use cases and hardware. The library offers three queue types, each designed for specific concurrency patterns and performance requirements.
    • cl-data-structures - a portable collection of data structures (mutable and immutable) and streaming algorithms (aggregations, group-by and so on, mainly dicts and sequences, with some statistical functions). [BSD][15].
    • Pretty printing tree data structures in Common Lisp
    • cl-docker-images - Docker images for ABCL, CCL, ECL, and SBCL on Windows (amd64) and Alpine and Debian (amd64, arm64, arm/v7) [BSD_2Clause][17].
    • pileup - a portable, performant, and thread-safe binary heap for Common Lisp. [MIT][200].
    • cl-jsonpath - A JSONPath implementation for Common Lisp with 99% test compliance and complete real-world compatibility. MIT. With AI inside.
    • cl-remizmq - ZeroMQ sockets, messages, timers, atomics, and proxies.
    • WouldWork - solve classical planning and constraint satisfaction problems without extensive programming experience. BSD_3Clause.
    • ZeroMQ examples
    • Cicili - C generator macro-driven language. GPL3.0.
    • cl-sqlite - Bindings for SQLite. Public domain.
    • bknr.datastore - a CLOS-based lisp-only database in RAM with transaction logging persistence. [Manual](https://www.common-lisp.net/project/bknr/html/documentation.html). [licence][208].
    • cl-influxdb - an interface to the Time Series Database InfluxDB. [MIT][200].
    • hash-set - a convenience library implementing hash sets on top of CL hash tables [The Unlicense][5]
    • OpenMusic - aided composition environment. [GPL3][2]. Developped at [IRCAM](https://www.stms-lab.fr/team/representations-musicales/), France.
    • access - Consistent and nested access to most common data structures. [BSD_3Clause][15].
    • jzon - a correct, safe and fast JSON parser. [MIT][200].
    • asdf-dependency-traverser - a small utility for traversing the dependency tree of an ASDF system. Zlib.
    • OM7 - a new implementation of the OpenMusic visual programming and computer-aided composition environment including a number of improvements on graphical interface, computational mode, and connection to external software libraries. [GPL3][2].
    • gpgme lisp sources

  • Online ##

    • Learn X in Y minutes - Where X = Common Lisp - Small Common Lisp tutorial covering the essentials.
    • Common LISP: A Gentle Introduction to Symbolic Computation - A nice introduction into the language.
    • Successful Lisp - A good book for beginners with some programming background.
    • Lisp Quickstart - A good tutorial to get up and code Common Lisp quickly.
    • Casting SPELs in LISP - A fun way to learn LISP while reading a comic book.
    • Common Lisp Programming: from novice to effective developer - A learning video series on the Udemy platform (*full content under paid access*). By an active lisper and community contributor (@vindarel). [Github home](https://github.com/vindarel/common-lisp-course-in-videos/).
    • Lisp Tips - A blog with useful tips and tricks. A continuation of [Common Lisp tips](http://lisptips.com/).
    • Lisp project of the day - A blog showcasing many Lisp libraries.
    • On Lisp - Paul Graham's amazing book on Lisp macros (and other interesting things).
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Codewars - a code training platform, with Common Lisp support (SBCL).
    • Lisp for the Web - A book that walks you through building a voting web application in three tiers.
    • Lisp Web Tales - Simple tutorials using [hunchentoot](http://edicl.github.io/hunchentoot/), [cl-redis](https://github.com/vseloved/cl-redis), [restas](https://github.com/archimag/restas), [SEXML](https://github.com/madnificent/SEXML), [Postmodern](https://github.com/marijnh/Postmodern), and more.
    • Section on Web Development in The Common Lisp Cookbook - An introductory tutorial covering web server setup, routing, weblocks, templating, error handling, packaging, hot reloading, database connection, and deployment, amongst other topics in the current lisp web development ecosystem.
    • CL CommunitySpec - a rendition of the Common Lisp ANSI Specification draft.
    • novaspec - a modern rendition of the CL ANSI draft.
    • Common Lisp Quick Reference - A distilled, pocket-size version of the ANSI CL spec. Available for download as a PDF.
    • CLOS MOP specification - A modern public domain online version of chapters 5 and 6 of The Art of the Metaobject Protocol
    • Common Lisp Standard Draft (pdf) - The standard draft of the Common Lisp specifications, in a well formatted PDF with a sidebar.
    • Common Lisp the Language - The original standard for Common Lisp before the ANSI spec.
    • Simplified Common Lisp reference - The simplified version of CLHS.
    • CDR - Common Lisp Document Repository. a repository of documents that are of interest to the Common Lisp community. The most important property of a CDR document is that it will never change: if you refer to it, you can be sure that your reference will always refer to exactly the same document.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • dpans2texi - the standard draft converted to Texinfo and published as a well formatted PDF.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Zenodo
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • sbcl-wiki - an open wiki to document SBCL's internals.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • SBCL internals
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Loving Common Lisp, or the Savvy Programmer's Secret Weapon - Quick introduction to Common Lisp with many examples. A particular focus is on how to use Large Language Models (LLMs).
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Part 1 - gentle-introduction-to-compile-time-computing-part-2-cb0a46f6cfe8), [Part 3 (Safely dealing with scientific units of variables at compile time)](https://medium.com/@MartinCracauer/a-gentle-introduction-to-compile-time-computing-part-3-scientific-units-8e41d8a727ca)
    • Static type checking in the programmable programming language
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • CLHS - The Common Lisp HyperSpec; the ANSI CL standard, in hypertext form.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • The Common Lisp Cookbook
    • Web Apps in Lisp: Know-how - tutorial and reference material to build interactive web apps in Common Lisp. CC-BY.
    • a Firefox add-on: Practical-cl beautified
    • Chinese simplified
    • Common LISP: A Gentle Introduction to Symbolic Computation - A nice introduction into the language.
    • Successful Lisp - A good book for beginners with some programming background.
    • Casting SPELs in LISP - A fun way to learn LISP while reading a comic book.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Common Lisp Quick Reference - A distilled, pocket-size version of the ANSI CL spec. Available for download as a PDF.
    • CLtL2, in PDF format
    • Minispec - A friendlier, but less-complete, version of CLHS. Also contains documentation for some commonly-used CL libraries (such as Alexandria).
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • dpans2texi - the standard draft converted to Texinfo and published as a well formatted PDF.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Zenodo
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • Programming Algorithms in Lisp - Updated version of "[Programming Algorithms](https://leanpub.com/progalgs)"; A comprehensive guide to writing efficient programs with data structures and algorithms in Lisp.
    • On Lisp - Paul Graham's amazing book on Lisp macros (and other interesting things).

  • Offline ##

      • Land of Lisp - A fun, game-oriented introduction to Common Lisp.
      • ANSI Common Lisp - A thorough, practical covering of the entire language, with exercises. Not recommended as a starter text, due to [some caveats][20].
      • Common Lisp Recipes - **Common Lisp Recipes** is a collection of solutions to problems and answers to questions you are likely to encounter when writing real-world applications in Common Lisp. Published in 2015.
      • /r/Common_Lisp - subreddit about Common Lisp
      • /r/learnlisp - a subreddit to ask questions and get help about Lisp
      • common-lisp.net
      • lisp-lang.org
      • Lisp Discord Server
      • #commonlisp - main Common Lisp IRC channel.
      • #lisp - IRC channel for all Lisp dialects.
      • Planet Lisp - A meta blog that collects the contents of various Lisp-related blogs.
      • Common Lisp chat - Keybase team with well-defined rules and retention policies.
      • Quicklisp bundles - self-contained sets of systems that are exported from Quicklisp and loadable without involving Quicklisp.
      • CLPM - A package manager for Common Lisp that strives to cleanly separate the package manager process itself from the client image that uses it. [BSD_2Clause][17].
      • Ultralisp - A Quicklisp distribution which updates every 5 minutes and to which one can add his project in one click. [BSD][15].
      • Quicksys - install systems from multiple Quicklisp distributions. [MIT][200].
      • lisp-lang.org's style guide
      • Qlot - A project-local library installer, similar to Bundler or Virtualenv. [Expat][14].
      • Roswell - a Lisp implementation installer, script launcher and more. [MIT][200].
      • PAIP-lisp - Lisp code for the textbook "Paradigms of Artificial Intelligence Programming".
      • cl-software
      • https://norvig.github.io/paip-lisp/
      • ql-https - shell out to cURL and use HTTPS by default.
      • Norvig's Lisp style
      • print-licenses - print licenses used by a project and its dependencies. [MIT][200].
      • use it from the Lisp REPL
      • Quickutil - A utility manager, similar to Quicklisp, but for small utilities rather than whole libraries. [3-clause BSD][15].
      • vend - Just vendor your dependencies! [MPL-2.0][211].
      • ocicl - A modern dependency management tool with novel features. [MIT][200].
      • Land of Lisp - A fun, game-oriented introduction to Common Lisp.
      • Building Problem Solvers - Searchable.pdf)) by Ken Forbus and Johan de Kleer, made available for free by MIT Press - a unique book among standard artificial intelligence texts in combining science and engineering, theory and craft to describe the construction of AI reasoning systems, and including code illustrating the ideas.
      • Planet Lisp - A meta blog that collects the contents of various Lisp-related blogs.
      • Lisp Jabber/XMPP channel
      • trivial-system-loader - A system installation/loading abstraction for Common Lisp.
      • redist - facilities to produce Quicklisp distributions.
      • quick-patch - easily override quicklisp projects without using git submodules. [MPL-2.0][211].
      • asdf-dependency-graph - A minimal wrapper around `dot` to generate an image of the dependencies graph.
      • quick-patch - easily override quicklisp projects without using git submodules. [MPL-2.0][211].
      • lisp-screenshots.org
      • awesome-lisp-companies

    • Interfaces to other package managers

      • antik - a foundation for scientific and engineering computation in Common Lisp. GPL. Also [mgl-mat](https://github.com/melisgl/mgl-mat) and [LLA](https://github.com/tpapp/lla).
      • State of CL Ecosystem 2015
      • Cliki

    • Isomorphic web frameworks

      • Interactive SSR - ISSR allows you to make interactive web pages without writing client scripting. No knowledge about Javascript or DOM is necessary.
      • Parenscript - A translator from Common Lisp to Javascript. [3-clause BSD][15]. See [Trident-mode](https://github.com/johnmastro/trident-mode.el), an Emacs mode that provides live interaction with the browser.[unlicence][5].
      • CL-JavaScript - A translator from Javascript to Common Lisp. Not available on Quicklisp. [Expat][14].
      • parse-js - A package for parsing ECMAScript 3. [zlib][33].
      • Platform.sh - paas/languages-lisp/) through their Web PaaS partnership.
      • Heliohost

    • Third-party APIs

      • cl-irc - An IRC client library. [Expat][14].
      • stripe - a client for the Stripe payment system. [MIT][200].
      • maxima - Computer Algebra System. [GNU GPL3][2].
      • GSLL - GNU Scientific Library for Lisp; allows the use of the GSL from Common Lisp. [GNU LGPL2.1][11].
      • BordeauxThreads - Portable, shared-state concurrency. [Expat][14].
      • SBCL's timers - wide event schedulers.
      • lserver
      • Linedit - Readline-style

  • Interfaces to other package managers

      • this Youtube video - works-delivery and linux-packaging.
      • Clack - A web application environment inspired by Rack and WSGI. [LLGPL][8]. Provides a unified interface to a webserver of choice (default is Hunchentoot). With more [getting started guide](https://jasom.github.io/clack-tutorial/posts/getting-started-with-clack/).
      • woo - A fast non-blocking HTTP server on top of libev. [MIT][200].
      • cl-http2-protocol - a pure Common Lisp transport agnostic implementation of the HTTP/2 protocol at draft-14. [MIT][200].
      • wookie - Asynchronous HTTP server. [Expat][14].
      • asdf-sbcl
      • ql-to-deb - Update cl-* debian packages from Quicklisp releases. WTFPL.
      • dh-quicklisp-buildapp - debhelper utility to let you compile your quicklisp-based Common Lisp code into a buildapp binary in a .deb with almost no effort. [MIT][200].
      • qldeb - Quicklisp systems to debian packages, along with [deb-packager](https://github.com/ralt/deb-packager) (simply create a debian package by defining an s-expression). Both [MIT][200].
      • Dexador - An HTTP client, that aims at replacing Drakma. [MIT][200].
      • fast-http - A fast HTTP request/response parser for Common Lisp. [MIT][200].
      • cl-nix-lite - Common Lisp module for Nix, without Quicklisp. [AGPL-3.0][51]
      • linux-packaging - build .deb, .rpm or .pkg packages for your application with a single ASDF declaration. Uses fpm under the hood. [MIT][200].
      • cl-brewer - Homebrew formula builder for (command line) common lisp applications. Public domain.
      • flatpack-common-lisp - A BuildStream project for building Flatpak based runtime environments for Common Lisp applications.
      • alien-works-delivery - WIP system for delivering Common Lisp applications as executable bundles. For now it only supports AppImage format for Linux and MSIX for Windows, but .APK for Android and later MacOSX and iOS bundle formats are planned too.
      • Cliki
      • Carrier - A lightweight, async HTTP client built on top of cl-async and fast-http. [MIT][200].
      • http2 - HTTP/2 implementation in Common Lisp. [MIT][200].
      • portableaserve - an attempt to provide the functionality of Franz.com's [AllegroServe web server](https://github.com/franzinc/aserve) (open-source but tied to AllegroCL) to other lisp implementations.
      • Aserve documentation
      • zaserve - a portable fork of AllegroServe [LLGPL][8].
      • cl-brewer - Homebrew formula builder for (command line) common lisp applications. Public domain.
      • http2 - HTTP/2 implementation in Common Lisp. [MIT][200].

    • Clack plugins

      • Quickdocs
      • Caveman - A powerful web framework. [LLGPL][8].
      • Snooze - A RESTful web framework. Web server agnostic. Currently has support for Hunchentoot and Clack. Routes are just functions and HTTP conditions are just Lisp conditions. [LLGPL][8].
      • cl-rest-server - a library for writing REST web APIs. Features validation with schemas, annotations for logging, caching, permissions or authentication, documentation via Swagger, etc. [MIT][200].
      • ningle - A super-micro web framework. [LLGPL][8].
      • clack-errors - Error page middleware for Clack. Unmaintained. [LLGPL][8].
      • jingle - based on ningle, adds bells and whistles, such as middlewares.
      • tiny-routes - A tiny routing library for Common Lisp targeting Clack. [BSD_3Clause][15].
      • clath - a single sign-on
      • clack-pretend - a testing
      • hismetic - Security for Clack-based web applications. [Expat][14].
      • live-reload - Live reload prototype for clack. [LLGPL][8].
      • clack-static-asset-middleware - a cache-busting static asset middleware for the clack. [MIT][200].
      • lack-expression-cache - lack middleware for compressing and caching static resources. MIT.
      • lack-rerouter - lack middleware to reroute URIs of requests. MIT.
      • clack-cors - A Clack middleware to set CORS related HTTP headers. — Unlicense.
      • clack-promotheus - Clack middleware to serve stats in Prometheus format. Unlicense.
      • radiance - A web application environment and framework . [zlib][33].

    • Isomorphic web frameworks

      • JACL - an experimental Lisp system for the Web browser platform to explore new techniques for developing large Single Page Applications with Lisp.
      • Cloud Init file for SBCL - an init file for providers supporting the cloudinit format (DigitalOcean etc).
      • scrapycl - web scraping framework for writing crawlers in Common Lisp. Unlicense.
      • Djula - A port of Django's template engine to Common Lisp. [Expat][14].
      • CLOG - The Common Lisp Omnificent GUI. Uses web technology to produce graphical user interfaces for applications locally or remotely. [BSD_3Clause][15].
      • jscl-react - A web framework for writing react components in common lisp using jscl. No license specified.
      • common-lisp-heroku-example - Example of Common Lisp server on Heroku using Docker.
      • cl-react - Common Lisp (Parenscript) utilities for building web apps in ReactJs. MIT.
      • JSCL - A CL-to-JS compiler designed to be self-hosting from day one. GPL3.0.
      • Valtan - Common Lisp to JavaScript compiler.
      • TEN - the completness of Djula with the full usability of Common Lisp code in templates. [MIT][200].
      • quri - Another URI library for
      • trident-mode
      • cl-djula-tailwind - use TailwindCSS classe in your Djula templates without any JavaScript or Node.js tooling.
      • Weblocks (Reblocks) - A widgets-based framework with a built-in ajax update mechanism that "solves the JavaScript problem". [LLGPL][8].
      • cl-html5-parser - HTML5 parser for Common Lisp. GPL3.0.
      • Interactive SSR - ISSR allows you to make interactive web pages without writing client scripting. No knowledge about Javascript or DOM is necessary.
      • mold-desktop - a programmable desktop.
      • WIP - A moldable Common Lisp object inspector based on CLOG. The inspector is thus shown in a Web browser.
      • Plump
      • spinneret - Common Lisp HTML5 generator. [Expat][14].
      • cl-who - The venerable HTML generator. [FreeBSD][39].
      • djula-template-designer - a template designer tool.
      • cl-closure-template - Implementation of Google's Closure templates, where compiling a template creates a function that generates the result. [LLGPL][8].
      • hsx - An easily composable HTML5 generation library with the most simplistic syntax. [MIT][200].
      • clip - An HTML template processor where the templates are written in HTML. [zlib][33].
      • cl-slug - a small library to make slugs, mainly for URIs, transform in CamelCase, remove accentuation and punctuation, for english and beyond. [LLGPL][8].
      • netaddr - A network address manipulation library for Common Lisp. MIT.
      • paren6 - a set of ES6 macros for Parenscript.
      • paren-async
      • paren-jquery - Jquery-style macros for Parenscript. MIT.
      • ParenScript + Mithril demo
      • Building a Freecell game with ParenScript and Preact
      • tests - project/jscl/blob/master/tests/clos.lisp)), limited support of `format`([tests](https://github.com/jscl-project/jscl/blob/master/tests/format.lisp)).
      • live playground
      • remote-js - send JavaScript from Common Lisp to a browser. [MIT][200].
      • sigil - A Parenscript to Javascript command line compiler and REPL. [MIT][200].
      • SLip - an aspiring Common Lisp environment in the browser.
      • Ymacs
      • Live demo
      • Panic - lisp-example/examples/common-lisp-react/src/app.lisp).
      • Parenscriptx - Parenscript Macros to aid generating react code. [MIT][200].
      • deploy - A toolkit for binary deployment of Lisp applications, with extra support for foreign shared libraries. [zlib][33].
      • cube - Kubernetes client library for Common LISP generated from the Swagger specification. [MIT][200].
      • s2i-lisp - Source-to-Image builder image based on CentOS or alternatively RHEL7 for building Common LISP images for OpenShift (and also Docker). It features an up-to-date SBCL with Quicklisp installation, SLIME or SLY integration and allows customization via environment variables. [Apache2][89]
      • cl-aws-runtime-test - An example of using Common Lisp (SBCL) as a custom runtime on AWS lambda. WTFPL.
      • 40ants/ci - Highly opionated Github Actions workflow builder for Common Lisp projects.
      • make-common-lisp-program - GitHub action to build an executable Common Lisp program on Ubuntu, MacOS and Windows. MIT.
      • pull request
      • 40ants/ci - Highly opionated Github Actions workflow builder for Common Lisp projects.
      • make-common-lisp-program - GitHub action to build an executable Common Lisp program on Ubuntu, MacOS and Windows. MIT.
      • Ultralisp - c530-4e9d-b8be-7437b1f7200b)).
      • cl-sanitize-html - OWASP-style HTML sanitization library for Common Lisp, designed for safely rendering untrusted HTML content (like HTML emails or user-generated content). MIT.
      • reddit announce
      • lsx - Two JSX-like templating engines, where HTML tags are Common Lisp code. `markup` comes with an Emacs package.
      • Panic - lisp-example/examples/common-lisp-react/src/app.lisp).
      • datastar-cl - Datastar Common Lisp SDK.
      • live JupyterLite playground - kernel](https://github.com/wiki3-ai/jscl-kernel).
      • Datastar

    • Email

      • cl-smtp - CL-SMTP is a simple lisp smtp client.
      • sendgrid - send emails with Sendgrid's API. [MIT][200].
      • trivial-imap - tries to make easy some common cases of working with IMAP servers, like reading emails from the server. A thin wrapper over post-office library (which is a fork of Franz's cl-imap). [BSD][15].
      • mailgun - A thin wrapper to post HTML emails through mailgun.com. [unlicence][5].
      • parcom/email - types and parsers for RFC5322 email addresses. The implementation is RFC-compliant and particularly memory-efficient for well-behaved addresses.

    • Third-party APIs

      • cl-telegram-bot - Telegram bot API. [MIT][200].
      • SageMath - mode](https://gitlab.com/sasanidas/maxima) ([screenshot](https://community.linuxmint.com/img/screenshots/maxima-emacs.png)) and [maxima-interface](https://github.com/jmbr/maxima-interface) to ease the interface between Maxima and Common Lisp.
      • lisp-stat - an environment for statistical computing, conceptually similar to R, that is also suitable for front-line production deployments. "It grew out of a desire to have an environment for rapidly prototyping analytical and A.I. solutions, and move directly to production environments with minimal friction."
      • XLisp-Stat
      • Emotiq blockchain
      • CL Cookbook: running external programs
      • Consfigurator - Lisp declarative configuration management system. You can use it to configure hosts as root, deploy services as unprivileged users, build and deploy containers, produce disc images, operate on files and directories and more. [GPL3][2].
      • cmd - utility for running external programs. Protects against shell interpolation, built with multi-threaded programs in mind, Windows support. [MIT][200].
      • cl-unix-cybernetics - UNIX system administration in Common Lisp. [ISC][22].
      • kai - A high-level plotter library for Common Lisp. A wrapper around the [Plotly](https://plotly.com/javascript/) JS library. [MIT][200].
      • magicl - Matrix Algebra proGrams In Common Lisp based on BLAS/LAPACK and Expokit, by Rigetti Computing. [BSD_3Clause][15].
      • cl-ansi-term - print
      • numcl - Numpy clone in Common Lisp. [LGPL3][9].
      • Petalisp - an attempt to
      • wxMaxima
      • Aws-sign4 - Common Lisp library for Amazon Web Services signing version 4. [GNU GPL3][2].
      • cl-pushover - Common Lisp bindings to Pushover. [MIT][200].
      • kiln - an infrastructure (managing a hidden multicall binary) to make Lisp scripting efficient and ergonomic. [MIT][200].
      • lqn - query language and terminal utility for querying and transforming Lisp, JSON and other text files. written in Common Lisp. [MIT][200].
      • cl-coroutine - a coroutine library. It uses the CL-CONT continuations library in its implementation. [MIT][200].
      • avm - Efficient and expressive arrayed vector math library with multi-threading and CUDA support. [MIT][200].
      • chanl - Portable, channel-based concurrency. [Expat][14], with parts under [3-clause BSD][15].
      • STMX - High performance Transactional Memory for Common Lisp. [LLGPL][8].
      • eazy-gnuplot - a
      • psychiq - redis-based background job processing for Common Lisp applications. Inspired by Ruby's Sidekiq and compatible with its web UI. [LLGPL][8].
      • cl-readline - a set of
      • progressons
      • numericals - SIMD powered simple-math numerical operations on arrays for Common Lisp through CFFI [still experimental]. MIT.
      • dense-arrays - Numpy like array object for common lisp. MIT.
      • Maxima on Jupyter
      • cl-telegram-bot-auto-api - Alternative Telegram Bot API bindings, auto-generated from Telegram website. [3-clause BSD][15].
      • plotly-user - Use plotly in your browser to explore data from a Common Lisp REPL. [BSD_3Clause][15].
      • Clingon - a rich command-line options parser system.
      • cl-termbox2 - [Termbox2](https://github.com/termbox/termbox2) bindings.
      • swank-crew - distributed computation framework implemented using Swank Client. [BSD_3Clause][15].
      • cl-irc - An IRC client library. [Expat][14].
      • lfarm - distributing work across machines (on top of lparallel and usocket). [BSD_3Clause][15]
      • Moira - Monitor and restart background threads. In-lisp process supervisor. [MIT][200].
      • trivial-monitored-thread
      • cl-gearman - a library for the [Gearman](https://github.com/gearman/gearmand/) distributed job system. [LLGPL][8].
      • Sento - Sento (formerly cl-gserver) is a 'message passing' library/framework with actors similar to Erlang or Akka. It supports creating systems that should work reactive, require parallel computing and event based message handling. [Apache2][89].
      • cl-flow - Data-flowish computation tree library for non-blocking concurrent Common Lisp. [MIT][200].
      • event-glue - simple eventing abstraction. No dependencies. It can be used anywhere you need a generic event handling system. [MIT][200].
      • SBCL's timers - wide event schedulers.
      • cl-cron - A simple tool that provides cron like facilities. [GPL3][2].
      • clerk - a cron-like scheduler with sane DSL. [MIT][200].
      • one-more-re-nightmare - a fast-ish regular expression compiler in Common Lisp. [BSD_2Clause][17].
      • pirá - Unofficial AWS SDK for Common Lisp.
      • zs3 - A library for working with Amazon's Simple Storage
      • Ciao - an easy-to-use Common Lisp OAuth 2.0 client library. It is a port of the Racket OAuth 2.0 Client to Common Lisp. [LGPL3][9].
      • tooter - a client library implementing the full v1 REST API protocol for Mastodon. [zlib][33].
      • cl-mediawiki - a wrapper around the MediaWiki api. [MIT][200].
      • cl-openid - An implementation of OpenID. [LLGPL][8].
      • humbler - A Tumblr API interface. [zlib][33].
      • multiposter - post to multiple services simultaneously. [zlib][33].
      • stripe - a client for the Stripe payment system. [MIT][200].
      • lisp-pay - Wrappers around various payment processors: Paypal, Stripe, Coinpayments and BTCPayServer. [MIT][200].
      • lunamech-matrix-api - A complete wrapper over the Client -> Server Matrix API. [MIT][200].
      • new, POC - /tree/emscripten-port-deployed)
      • GSLL - GNU Scientific Library for Lisp; allows the use of the GSL from Common Lisp. [GNU LGPL2.1][11].
      • Xecto - A library for regular array parallelism. [3-clause BSD][15].
      • cl-ana - Common Lisp data analysis library with emphasis on modularity and conceptual clarity. It aims to be a general purpose framework for analyzing small and large scale datasets, including binned data analysis and visualization. [GNU GPL3][2].
      • array-operations - a collection of functions and macros for manipulating Common Lisp arrays and performing numerical calculations with them. [MIT][200].
      • cl-geometry - a system for two dimensional computational geometry for Common Lisp. [MIT][200].
      • Vellum - Data Frames for Common Lisp. BSD_2Clause.
      • linear-programming
      • shop3 - a Hierarchical Task Network (HTN) AI planner. Mozilla Public License.
      • Common Lisp numsci call for needs
      • lisp-matrix - A matrix package. [FreeBSD][39].
      • 3d-matrices - A library implementing common matrix calculations, with an emphasis on 2x2,3x3, and 4x4 matrices as commonly used in graphics. It provides some numerical functions as well, but those are not the focus. The library is heavily optimised, so it is not made of pretty code. [zlib][33].
      • clem - a matrix library. [BSD_2Clause][17].
      • common-lisp-stat
      • physical-quantities - a library that provides a numeric type with optional unit and/or uncertainty for computations with automatic error propagation. GPL2
      • plot (vega-lite) - a Vega-lite DSL. MS-PL.
      • emacs-vega-view - an Emacs plugin that allows to display a Vega plot from a lisp-stat expression in a buffer.
      • vgplot - an interface to the
      • cookbook
      • ADW-Charting - A simple chart drawing library written completely in Common Lisp. Also includes a backend to Google's chart service. BSD-like.
      • cl-text-plot - Plot with text in Common Lisp. No licence specified.
      • cl-spark - sparkline strings for the console: `(spark '(1 1 2 3 5 8))` => "▁▁▂▃▅▇". [MIT][200].
      • cmu-infix - A library for writing infix mathematical notation in Common Lisp. See also [polisher](https://github.com/mrcdr/polisher).
      • BordeauxThreads - Portable, shared-state concurrency. [Expat][14].
      • lparallel - A library for parallel programming. [3-clause BSD][15]. Originally on [lmj/lparallel](https://github.com/lmj/lparallel).
      • good documentation
      • calispel - [CSP](https://en.wikipedia.org/wiki/Communicating_sequential_processes)-like channels for common lisp. With blocking, optionally buffered channels and a "CSP select" statement. ISC-style.
      • cl-async - A library for general-purpose, non-blocking programming. [Expat][14].
      • Blackbird - a Promise implementation for Common Lisp [MIT][200].
      • promise - a basic promise datastructure, with timeouts. ZLIB.
      • cl-etcd - Run etcd as an asynchronous inferior process. [etcd](https://etcd.io/) is a strongly consistent, distributed key-value store. [AGPL-3.0][agpl3].
      • Actors
      • lisp-actors - world application".
      • simple-tasks - A very simple task scheduling framework. [zlib][33].
      • deeds - Deeds is an Extensible Event Delivery System. It allows for efficient event delivery to multiple handlers with a complex event filtering system. [zlib][33].
      • cl-ppcre - Portable, Perl-compatible regular expressions. [FreeBSD][39].
      • rexxparse - A string parsing tool inspired by the REXX PARSE construct. MIT.
      • ScriptL - Shell scripting made Lisp-like! Or, live-coding remote function calls for the shell. Write a command in the REPL, and run it instantly in the shell. [LLGPL][8].
      • lserver
      • clingon-scripter - define flags as simple `defvar` declarations.
      • cl-tuition - A Common Lisp library for building rich, responsive TUIs. MIT.
      • Linedit - Readline-style
      • cl-charms - an
      • cl-progress-bar - progress bars, just like in Quicklisp ! [MIT][200].
      • text-draw - Toolkit to draw graphics using pure Unicode text only: boxes, backgrounds, checkboxes and radio buttons, lines, arrows, tables, trees… zlib.
      • Lish - `lish` may someday be a lisp shell. [GPL3][2].
      • unix-in-lisp - Mount Unix system into Common Lisp image.
      • Clesh - extends Common Lisp to embed shell code in a manner similar to perl's backtick. [FreeBSD][39].
      • clawk - an AWK implementation embedded into Common Lisp, to search files for lines and perform specified actions on its fields. BSD-style.
      • WCL - allow hundreds of Lisp
      • paper
      • Parinfer - Parinfer is a way to edit lisp code that helps to keep both the indentation and the parenthesis balanced. It is easy to start with and yet it offers advanced features à la Paredit. It is available on many editors (Emacs, Vim, Neovim, Atom, Sublime Text, Visual Studio Code, LightTable, CodeMirror,…).
      • aws-sdk-lisp - Provides interfaces for each AWS services as individual systems. [BSD_2Clause][17].
      • Moira - Monitor and restart background threads. In-lisp process supervisor. [MIT][200].
      • cl-flow - Data-flowish computation tree library for non-blocking concurrent Common Lisp. [MIT][200].
      • one-more-re-nightmare - a fast-ish regular expression compiler in Common Lisp. [BSD_2Clause][17].
      • cookbook
      • CIEL - CIEL Is an Extended Lisp is a collection of dozens of libraries useful for mundane tasks (HTTP, JSON, regexps…). [unclear licence]
      • Adopt - A Damn OPTion parsing library. [MIT][200].
      • replic - helpers to turn existing code into a readline application, with a focus on defining the completion of the commands' arguments. Also comes as a ready to use executable, that transforms a user's lispy init file into readline commands. [MIT][200].
      • cl-progress-bar - progress bars, just like in Quicklisp ! [MIT][200].
      • old-norse - a low-latency, grid-based terminal graphics engine with an integrated event loop. MIT.
      • uncursed - cross-platform library for writing terminal interfaces with minimal dependencies. BSD_3Clause.
      • shcl - a POSIX-like shell in Common Lisp. [Apache2.0][89].
      • unix-in-lisp - Mount Unix system into Common Lisp image.
      • cl-geometry - a system for two dimensional computational geometry for Common Lisp. [MIT][200].
      • rtg-math - a selection of the math routines most commonly needed for making realtime graphics in lisp (2, 3 and 4 component vectors, 3x3 and 4x4 matrices, quaternions, spherical and polar coordinates). BSD_2Clause.
      • common-lisp-stat
      • cl-text-plot - Plot with text in Common Lisp. No licence specified.
      • cl-selfupdate - Self-update functionality for Common Lisp executables via GitHub/GitLab Releases. MIT.
      • maxima - Computer Algebra System. [GNU GPL3][2].
      • LLA - Lisp Linear Algebra. MS-PL.
      • cl-cancel - Cancellation propagation library for Common Lisp with deadlines and timeouts. MIT. *With LLM*.
      • cl-nats - A full-featured NATS messaging client for Common Lisp. MIT. *With LLM*.
      • pregexp - Portable Regular Expressions for Scheme and Common Lisp.
      • pregexp - Portable Regular Expressions for Scheme and Common Lisp.

    • Hosting platforms

    • OpenAPI, OData, OpenRPC

      • OpenRPC - OpenRPC implementation for Common Lisp. [BSD][15].
      • jsonrpc - JSON-RPC 2.0 server/client for Common Lisp. [BSD][15].
      • apispec - A Common Lisp library for handling Web API requests and responses. [BSD_3Clause][15].
      • openapi-generator - OpenAPI client code generator. [AGPL-3.0][51].
      • cl-odata-client - Common Lisp client library for accessing [OData services](https://www.odata.org). [MIT][200].

    • Hunchentoot plugins

      • easy-routes - a routes handling system on top of Hunchentoot. It supports dispatch based on HTTP method, arguments extraction from the url path, decorators, url generation from route name, etc. [MIT][200].
      • hunchentoot-errors - Augments Hunchentoot error pages and logs with request and session information. [MIT][200].
      • hunchentoot-cgi - a library for executing CGI scripts from the hunchentoot webserver. [BSD][207].
      • hunchentoot-multi-acceptor - Route multiple domains (virtual hosts) on a single hunchentoot acceptor using a single port. [Apache2.0][89].
      • cl-tbnl-gserver-tmgr - Hunchentoot Gserver-based taskmanager. cl-gserver is an actor-like message-passing library (see below in "Actors pattern"). Experimental.
      • hunchentoot-recycling-taskmaster - a taskmaster implementation for Hunchentoot, aiming to improve connection establishment efficiency through thread-pooling and flexible thread count adjustment. BSD_2Clause.
      • hunchentoot-stuck-connection-monitor - Monitors hunchentoot connections and logs the connections stuck in the same state for a long time.

    • Web project skeletons and generators

      • cl-webapp-seed - a simple web application boilerplate. Uses Hunchentoot, cl-who, deploys easily to Heroku. [MIT][200].
      • css-lite - A CSS grammar. [Expat][14].
      • cl-cookie - )cookie headers, compare cookies, optional cookie attribute sanity check. [MIT][200]
      • cl-cookieweb - a Cookiecutter template to start a web project. [BSD_3Clause][15]. Not in Quicklisp.
      • trivial-download - Download files.
      • mobiledetect - System for detecting mobile devices (including tablets) in User-Agent strings. MIT.
      • random-ua - Random User-Agent generator for Common Lisp. BSD_2Clause.
      • make-like - an application template builder for LIKE (Lisp In Kubernetes + Emacs) applications. [Apache2.0][51].
      • LASS - Lisp Augmented Style Sheets. Largely inspired by SASS. Zlib.
      • find-port - Programmatically find open ports. [MIT][200].
      • dns-client - DNS record client. See [documentation](https://shinmera.github.io/dns-client/). [zlib][33].
      • cl-wget - Makes retrieving large files or mirroring entire websites easy. [AGPL-3.0][51].

    • Form handling

      • cl-forms - Web forms handling library for Common lisp. [MIT][200].

    • Browser tests

    • User login and password management

      • cl-authentic - Password management for Common Lisp (web) applications. [LLGPL][8].
      • mito-email-auth - Helper to authenticate a website's users by sending them unique code by email.
      • cl-cas - A library to help [CAS authenticaton](https://en.wikipedia.org/wiki/Central_Authentication_Service) to Common Lisp web applications. Not in Quicklisp.
      • cas-middleware - CAS authenticaton middleware for Caveman.
      • cas-demo - a demo project.

    • Static site generators

  • Machine Learning

    • author
    • AI Challenge
    • MGL - a machine learning library for backpropagation neural networks, boltzmann machines, gaussian processes and more. [MIT][200].
    • llama.cl - implementation of Llama inference operations. MIT.
    • openai-openapi-client - semi-automatically generated Openapi client updated frequently from the [official Openapi specification](https://github.com/openai/openai-openapi/blob/master/openapi.yaml). AGPL-3.
    • cl-completions - LLM completions.
    • cl-embeddings - LLM embeddings.
    • cl-chroma - the vector DB interface.
    • Caten - Deep Learning Compiler based on Polyhedral Compiler and Light-weight IRs, and Optimizing Pattern Matcher, written in Common Lisp
    • clml - originally developed by Mathematicl Systems Inc., a Japanese company. With a [tutorial](https://mmaul.github.io/clml.tutorials//2015/08/08/CLML-Time-Series-Part-1.html). [LLGPL][8].
    • antik - a foundation for scientific and engineering computation in Common Lisp. GPL. Also [mgl-mat](https://github.com/melisgl/mgl-mat) and [LLA](https://github.com/tpapp/lla).
    • cl-rag-example - chat](https://github.com/atgreen/cl-chat), a LLM chat library and web UI.

  • Emacs ##

    • Third-party APIs

      • cl-devel2 - a Docker container for Common Lisp development environment. Ships SBCL, CCL, Roswell and Emacs25 with Slime.
      • sly-overlay - an extension for Sly that enables the overlay of Common Lisp evaluation results directly into the buffer in the spirit of CIDER (Clojure), Eros (Emacs Lisp) and the Lem editor.
      • Sly - SLY is a fork of SLIME and contains multiple changes and new features, such as Sly stickers.
      • Slime - Superior Lisp Interaction Mode for Emacs; a full-blown environment for Common Lisp inside of Emacs. Public domain.
      • Quicklisp systems - Search, browse and load Quicklisp systems from Emacs.
      • SLIME doc contrib - enhance the default help buffer.
      • Emacs4CL - A tiny Emacs initialization file to quickly set up vanilla Emacs for Common Lisp programming. Comes with a line-by-line explanation of every line of code in the initialization file.
      • Quicksearch - search for projects on GitHub, Quicklisp, Cliki and Bitbucket. MIT.
      • Slime breakpoints
      • slime-star - a SLIME configuration with extensions pre-installed, with also some custom utilities and menus:
      • Quicklisp-apropos - Perform `apropos` queries across libraries in Quicklisp (full-text search on symbol names, classes, documentation…).
      • slime-critic - the lisp critic gently critiques your code for bad patterns.
      • Portacle - A portable and multiplatform Common Lisp environment: SBCL, Quicklisp, Emacs, Slime, Git.
      • Slite - a test runner for FiveAM.
      • sly-mrepl-db - from the debugger, evaluate expressions in a REPL with frame context (and not only in the minibuffer).
      • plain-common-lisp - A trivial way to get a native Common Lisp environment on Windows.
      • Slite - a test runner for FiveAM.
      • IDEmacs

  • Lem ##

  • VSCode ##

    • Third-party APIs

      • commonlisp-vscode - an extension to support syntax highlight, auto completion, documentation on hover, go to definition, compile & load file, REPL. It is [On GitHub](https://github.com/ailisp/commonlisp-vscode/).
      • using VSCode with Alive
      • strict-paredit-vscode - structural editing and navigation like Emacs.
      • alive - Common Lisp Extension for VSCode. Public domain.

  • Online editors ##

    • Third-party APIs

      • Judge0 IDE
      • Riju
      • testiere - a testing utility where tests are included at the top of a `defun/t` form. They are run when you recompile your functions interactively. With mocking and stubbing support. [GPL3][2].
      • Sabra Crolleton's extensive test frameworks comparison
      • sphinxcontrib-cldomain
      • cl-git - a CFFI interface to the libgit2 library. [LGPL3][9].
      • extensive comparison of logging libraries
      • Calendrical calculations
      • the introductory blog post
      • cl-project - General modern project skeletons. [LLGPL][8].
      • wiki-lang-detect
      • erudite - Literate Programming System built with interactive development in mind. [MIT][200].
      • json-schema - A library for validating data against schemas of drafts 4, 6, 7, and 2019-09 of the [JSON Schema](https://json-schema.org/) standard. [LLGPL][8].
      • cl-cookieproject - Generate a ready-to-use Common Lisp project. Not in Quicklisp. [BSD_3Clause][15].
      • docbrowser - a server that generates documentation for the loaded systems on the fly.
      • calendar-date - a Gregorian calendar date library. [MIT][200].
      • lake - a GNU make like build utility. [MIT][200].
      • cl-reexport - when you want to import and re-export many symbols at once and `:include` or `:exclude` some.
      • papyrus - Papyrus makes your markdown executable with the reader macro of Common Lisp.[MIT][200]
      • archive - a library for reading and creating archive (tar, cpio) files. [BSD_3Clause][15]. A pure Common Lisp replacement for the `tar` program.
      • chipz - A decompression library. [3-clause BSD][15].
      • periods - manipulating date/time objects at a higher level. With series-compatible data structure. [BSD_3Clause][15].
      • safe-read - a variant of READ secure against internbombing, excessive input and macro characters. [BSD_2Clause][17].
      • cl-phonetic - Phonetic pattern matching library for Common Lisp (intended to replace the Sylvia library for Python). [MIT][200].
      • MaxPC - a simple and pragmatic library for writing parsers and lexers based on combinatory parsing.
      • cl-bibtex - A compatible re-implementation of the BibTeX program in Common Lisp, with a BST-to-CL compiler. [GNU LGPL2.1][11].
      • supertrace - Superior Common Lisp `trace` functionality for debugging/profiling. Trace many functions at once, use before and after hooks. [BSD_2Clause][17].
      • envy - Configuration switcher. [FreeBSD][39].
      • cl-coveralls - a helper
      • cl-yacc - a LALR(1) parser generator. [MIT][200].
      • filepaths - Modern and consistent filepath manipulation for Common Lisp. [LGPL3][9].
      • nfiles - File persistence, watching, data synchronization, (per user profile) path resolution, and structured data retrieval. Has pre-defined classes for configuration files, remote fetched files, data files, Lisp-readable files and many others. [BSD][15].
      • translate - seamless language localization. LLGPL.
      • smug - parser combinators for Common Lisp. SMUG makes it simple to create quick extensible recursive descent parsers without funky syntax or impenetrable macrology. [MIT][200].
      • lisp-format - indentify](https://github.com/yitzchak/cl-indentify).
      • literate-lisp - Load Common Lisp code blocks from Emacs' Org files. [MIT][200].
      • trivial-time
      • mk-string-metrics
      • cl-binary-store - A fast Common Lisp binary serializer/deserializer. BSD_3Clause. See [reddit announce](https://www.reddit.com/r/Common_Lisp/comments/1hz5879/new_binary_serializationdeserialization_library/) (2025).
      • cl-store - a portable serialization package which gives you the ability to store all common-lisp data types into streams. MIT.
      • conspack - binary serialization.
      • clavier - General purpose validation library for Common Lisp. [MIT][200].
      • cl-livedocs - similar and newer, based on Webinfo, with full text search enabled by default.
      • cookiecutter-lisp-game - An opinionated cookiecutter template for Common Lisp videogame projects. Allows to choose [backend middleware library](#graphics) between liballegro, raylib and SDL2. Contains CI scripts using [docker-lisp-gamedev](#docker-images) to automatically build binaries for Windows, MacOS and Linux.
      • printv - A batteries-included tracing and debug-logging macro. [Apache2][89].
      • testiere-mode
      • Resolve - A software for AST-based diff calculation, display, and automated resolution. Written in C++ and CL, you'll find Lisp utilities.
      • SBCL's code coverage tool
      • fiveam-matchers - an extensible, composable matchers library for fiveam. [Apache2.0][89].
      • sanity-clause - a data serialization/contract library for Common Lisp. Schemas can be property lists or class-based, allowing to check slots' types during `make-instance`. [LLGPL][8].
      • cl-date-time-parser - Parse date-time-string, liberally. Hides the difference between date-time formats, and enables to manage date and time as the one date-time format. [MIT][200].
      • chronicity - A natural language date and time parse, to parse strings like "3 days from now". [BSD_3Clause][15].
      • local-time-duration
      • iso-8601-date - Miscellaneous date routines in Common Lisp, based around the ISO 8601 string representation. [LLGPL][8].
      • esrap - Parsing Grammar, Packrat parser, TDPL features and more. [Expat][14].
      • parseq - a library for parsing sequences such as strings and lists using Parsing Expression Grammars (PEGs). Inspired by Esrap. GPL2.
      • uclp - An experimental implementation of parsing expression grammars (PEGs, a la Janet) in Common Lisp. MIT.
      • alexa - A Lexical Analyzer Generator. [BSD_3Clause][15].
      • cl-shlex - simple lexical analyzer for shell-like syntaxes. [MIT][200].
      • lisp-binary - A library to easily read and write complex binary formats. [GPL3][2].
      • cl-string-generator - Generate string from regular expression. [MIT][200].
      • trivial-sanitize - clean html strings: `"<a>foo</a>"` → `"foo"`. [LLGPL][8].
      • quicksearch - Look up online libraries from the REPL. [Expat][14].
      • FiveAM - Simple regression testing framework. [FreeBSD][39].
      • FiveAM documentation
      • Parachute - An extensible and cross-compatible testing framework. With test dependencies, conditions, fixtures and restarts. [zlib][33].
      • CLUnit2 - A unit testing library. [MIT][200].
      • cl-mock - Another mocking library. It has more features than Mockingbird, like pattern matching on the mocked call, etc.
      • Check-it - A QuickCheck-style randomized property-based testing. [LLGPL][8].
      • CheckL - Why write programs in Common Lisp but tests like Java? Meet CheckL!
      • cl-hamcrest - a set of [Hamcrest](https://hamcrest.org/) matchers that can be combined to create flexible expressions of intent. Helps make your unittests more readable by using assertions such as `has-plist-entries`, `has-slots`, `has-length`, `contains`, `contains-in-any-order`, `has-all`… [BSD_3Clause][15].
      • clache - General caching facility. Cache any Lisp object on disk or in memory. [LLGPL][8].
      • cl-naive-store - a naive persisted, in memory (lazy loading), indexed, document store for Common Lisp. [MIT][200].
      • function-cache - A Common Lisp function caching / memoization library. [BSD][15].
      • zippy - A ZIP archive format library based on 3bz. [zlib][33].
      • cl-tar - project-cl-tar.html).
      • py-configparser - reads and writes Python's ConfigParser-like configuration files. [MIT][200].
      • chameleon - a configuration management library shipped with profile support. [MIT][200].
      • local-time - A development library for manipulating date and time information in a semi-standard manner. [3-clause BSD][15].
      • fuzzy-dates - A library to fuzzily parse date and time strings. Zlib.
      • humanize-duration
      • calendar-times - a calendar time library implemented on top of the LOCAL-TIME library. It features zoned calendar times and calculations.
      • some documentation
      • stopclock - a library for measuring time using (stop)clocks. It allows you to create a clock, pause it, resume it and change its speed. [Apache2.0][89].
      • ratify - A collection of utilities to ratify, validate and parse inputs. [zlib][33].
      • cl-semver - Implementation of the [Semantic Versioning](https://semver.org) Specification. [MIT][200]
      • Cookbook / debugging
      • repl-utilities - Ease
      • flight-recorder - a robust REPL history facility.
      • tracer - tracing profiler for Common Lisp, with output suitable for display in Chrome’s/Chromium’s Tracing Viewer. [MIT][200].
      • cl-flamegraph - A wrapper around SBCL's statistical profiler, to generate FlameGraph charts for Common Lisp programs. [BSD][15].
      • journal - a library for logging, tracing, record-and-replay testing and persistence. MIT.
      • brake - An extended breakpoint facility for Common Lisp. [MIT][200].
      • GTFL - A graphical terminal for Lisp, meant for Lisp programmers who want to debug or visualize their own algorithms. A graphical trace in the browser. BSD-style.
      • trivial-benchmark - Tiny benchmarking library. [zlib][33].
      • Staple - a tool to generate documentation pages using an HTML template. Uses the existing README, adds docstrings, crossreferences and links to the CLHS. [zlib][33].
      • mgl-pax - Exploratory
      • 40ants/doc
      • Codex - A beautiful documentation system for Common Lisp. [MIT][200].
      • QBook - generates HTML (or LaTeX) formatted code listings of Common Lisp source files. [BSD_3Clause][15].
      • Declt - Reference manual generator for Common Lisp libraries. Builds a texinfo document that can be further processed into various formats, such as HTML or PDF. BSD.
      • adp - Common Lisp documentation generator using Scribble files. [MIT][200].
      • NEW in 2025 - scientific publications that combine code, data, and computed results with explanatory text, and software documentation that is an integral part of a software system, rather than a pile of documents remaining outside of it.
      • cl-fad
      • pathname-utils - A collection of utilities to help with pathname operations. [zlib][33].
      • filesystem-utils - deal with common problems with filesystems, such as listing files, probing file types, determining default directories, etc.
      • file-attributes - access to common file attributes (uid, gid, permissions, ctime, mtime, atime).
      • file-finder - File-object finder Common Lisp library. Enable rapid file search, inspection and manipulation. [GPL3][2].
      • osicat - A lightweight operating system interface on POSIX-like systems, including Windows (directory iteration and deletion, file permissions, file-type identification, etc) [Expat][14].
      • ppath - Common Lisp's implementation of the Python's os.path module. [BSD][15].
      • mmap - Portable mmap file memory mapping utility library. [zlib][33].
      • trivial-glob - Shell-style glob pattern matching and filesystem globbing for Common Lisp. MIT.
      • file-notify - a cross-platform library for file change detection. [zlib][33].
      • legit - an interface to the Git binary. [zlib][33].
      • git-api - Common Lisp library to access a git repository. It doesn't need git or libgit installed. [BSD][15].
      • Lem editor's Git interface
      • cl-i18n - an i18n library. Load translations from GNU gettext text or binary files or from its native format. Localisation helpers of plural forms. [LLGPL][8].
      • gettext - a port of the gettext runtime to Common Lisp. [GPL3][2].
      • fluent - implementation of [Fluent](https://github.com/projectfluent/fluent/), a modern localisation system. MPL-2.0.
      • enchant - bindings for the Enchant spell-checker library. Public domain.
      • oxenfurt - A client library for the Oxford dictionary API. [zlib][33].
      • language-codes - A database library for ISO language codes. [zlib][33]
      • system-locale - A library to retrieve the user's preferred language, so that your application may choose a sensible default. [zlib][33].
      • multilang-documentation - Allows writing docstrings in multiple languages, for truly internationally documented libraries. [zlib][33].
      • trivial-formatter - code formatter for Common Lisp. [MIT][200].
      • log4cl - Logging framework modelled after Log4J. [Apache2.0][89]. Advanced integration with Slime.
      • log4cl-json - JSON appender extension. [BSD][15].
      • verbose - A fast and highly configurable logging framework. [zlib][33].
      • a-cl-logger - Logging library providing context sensitive logging of more than just strings to more than just local files or output streams. Features logstash support, json support, logger hierarchies, context sensitive logging, objects printed as an inspectable presentation,…
      • cl-fluent-logger - A Common Lisp structured logger for [Fluentd](https://www.fluentd.org/).
      • easy-macros - an easy way to write 90% of your macros. [Apache2.0][89].
      • 3bmd - a markdown -> html converter. [MIT][200].
      • cl-typesetting - pdf](https://github.com/mbattyani/cl-pdf) - cross-platform Common Lisp libraries for generating PDF files. [FreeBSD][39].
      • cl-pslib - a (thin) wrapper around the [pslib](http://pslib.sourceforge.net/) library for generating PostScript files. Also [cl-pslib-barcode](https://codeberg.org/cage/cl-pslib-barcode). [LLGPL][8].
      • cl-project-with-docs - uses Sphinx and reStructured text to render nice and readable HTML documentation. [BSD][15].
      • cl-isolated - A restricted environment for Common Lisp code evaluation [AGPL-3.0][agpl3].
      • secret-values - A Common Lisp library to reduce the risk of accidentally revealing secret values such as passwords.
      • privacy-output-stream - an output stream that masks secret strings with `****`, based on secret-values. MIT.
      • machine-state - Retrieve machine state information about CPU time, memory usage, thread processing time, etc.
      • babel - A charset encoding/decoding library. [Expat][14].
      • fast-io - Fast octet-vector/stream I/O. [3-clause BSD][15].
      • named-readtables - Provides a readtable namespace, akin to package namespaces. [3-clause BSD][15].
      • simple-currency - A currency conversion library using daily information published by the ECB. [FreeBSD][39].
      • trivial-garbage - A portable finalizer, weak hash-table and weak pointer API. Public domain.
      • trivial-utf8 - A small library for doing UTF-8-based I/O. BSD.
      • fiveam-matchers - an extensible, composable matchers library for fiveam. [Apache2.0][89].
      • mallet - A sensible Common Lisp linter that catches real mistakes, not style. MIT.
      • cl-shlex - simple lexical analyzer for shell-like syntaxes. [MIT][200].
      • texp - A DSL to generate TeX. [AGPL-3.0][agpl3].
      • montezuma - Full-text indexing and search for Common Lisp. [Expat][14].
      • FiveAM - Simple regression testing framework. [FreeBSD][39].
      • deoxybyte-gzip - Common Lisp interface to zlib via CFFI. GPL3.
      • chameleon - a configuration management library shipped with profile support. [MIT][200].
      • cl-fluent-logger - A Common Lisp structured logger for [Fluentd](https://www.fluentd.org/).
      • easy-macros - an easy way to write 90% of your macros. [Apache2.0][89].
      • trivial-with-current-source-from - Helps macro writers produce better errors for macro users. [GPL3][2].
      • cl-docsearch - A tool to search documentation of lisp symbols in the current lisp image.
      • docsearch-ollama
      • Salza2 - A library for creating compressed data. [FreeBSD][39].
      • cl-tar - project-cl-tar.html).
      • py-configparser - reads and writes Python's ConfigParser-like configuration files. [MIT][200].
      • local-time - A development library for manipulating date and time information in a semi-standard manner. [3-clause BSD][15].
      • glyphs - A library for cutting down the verboseness of Common Lisp in places. [GNU GPL3][2].
      • Lisp REPL core dumper
      • uiop
      • cl-fad
      • file-finder - File-object finder Common Lisp library. Enable rapid file search, inspection and manipulation. [GPL3][2].
      • osicat - A lightweight operating system interface on POSIX-like systems, including Windows (directory iteration and deletion, file permissions, file-type identification, etc) [Expat][14].
      • language-codes - A database library for ISO language codes. [zlib][33]
      • system-locale - A library to retrieve the user's preferred language, so that your application may choose a sensible default. [zlib][33].
      • multilang-documentation - Allows writing docstrings in multiple languages, for truly internationally documented libraries. [zlib][33].
      • sblint - a linter for Common Lisp source code using SBCL, suited for Reviewdog ([slides](http://www.slideshare.net/fukamachi/sblint)). [BSD_2Clause][17].
      • ocicl - in linter and auto-fix feature.
      • log4cl - Logging framework modelled after Log4J. [Apache2.0][89]. Advanced integration with Slime.
      • verbose - A fast and highly configurable logging framework. [zlib][33].
      • machine-state - Retrieve machine state information about CPU time, memory usage, thread processing time, etc.
      • trivial-utf8 - A small library for doing UTF-8-based I/O. BSD.
      • CI-utils - a set of utilities and examples for working on continuous integration platforms, including a run script for the Fiveam test library.
      • doc

  • Apps ##

    • Third-party APIs

      • CodePlayground - an iPhone and iPad app with Lisp support via CCL.
      • trivial-sanitize - clean html strings: `"<a>foo</a>"` → `"foo"`. [LLGPL][8].
      • SBCL's code coverage tool
      • Salza2 - A library for creating compressed data. [FreeBSD][39].
      • cl-tar - project-cl-tar.html).
      • py-configparser - reads and writes Python's ConfigParser-like configuration files. [MIT][200].
      • local-time - A development library for manipulating date and time information in a semi-standard manner. [3-clause BSD][15].
      • Calendrical calculations
      • GTFL - A graphical terminal for Lisp, meant for Lisp programmers who want to debug or visualize their own algorithms. A graphical trace in the browser. BSD-style.
      • uiop
      • osicat - A lightweight operating system interface on POSIX-like systems (directory iteration and deletion, environment variables, file permissions, etc) [Expat][14].
      • cl-i18n - an i18n library. Load translations from GNU gettext text or binary files or from its native format. Localisation helpers of plural forms. [LLGPL][8].
      • ADW-Charting - A simple chart drawing library written completely in Common Lisp. Also includes a backend to Google's chart service. BSD-like.
      • CXML - XML parser and serializer, with a range of extension libraries. [LLGPL][8].
      • s-xml - A basic parser. [LLGPL][8].
      • trivial-utf8 - A small library for doing UTF-8-based I/O. BSD.
      • CLUnit2 - A unit testing library. [MIT][200].
      • Lisp REPL core dumper

  • REPLs ##

    • Third-party APIs

      • this active fork - line input and binary releases. Simply download a binary (for Ubuntu) and run it.
      • sbcli - a readline REPL for SBCL. With completion, quick commands, optional syntax highlighting (with pygments), and no interactive debugger. [GPL3][2].
      • magic-ed - a tiny editing facility, where you can directly load, edit, manipulate and evaluate file or file content from the REPL, when going to a full IDE is too much. [MIT][200].
      • cl-repl - an ipython-like REPL. With completion, shell commands, magic commands, debugger, etc. [GPL3][2].
      • colorthemes
      • icl - an enhanced REPL for the terminal. MIT.
      • cl-web-editor - a simple in-browser editor that does on-the-fly form validation and instant REPL results. MIT. -->

  • Clojure

    • clj-arrows - Clojure-compatible threading/transformation/arrow macros for Common Lisp.
    • Cloture - Clojure in Common Lisp.
    • ABCLJ - dead easy Clojure to Common lisp interop. EPL-2.0.
    • cl-oju - a few idioms, mostly relating to sequences, that I miss when writing Common Lisp. [MIT][200].
    • clj-con - Clojure-style concurrency operations in Common Lisp. [MIT][200].
    • clj-re - Clojure-style regular expression functions.
    • with-redefs - enables rebinding of global functions, inspired by Clojure's with-redefs.
    • clj-coll - Clojure collection and sequence APIs in Common Lisp, with optional Clojure collection syntax. [Eclipse][209].

  • Vim & Neovim ##

    • Third-party APIs

      • SLIMV - Superior Lisp Interaction Mode for Vim; a full-blown environment for Common Lisp inside of Vim. No license specified.
      • Vlime - VLIME: Vim plus Lisp Is Mostly Evil. A Common Lisp dev environment for Vim (and Neovim). [MIT][200].
      • quicklisp.nvim - A Quicklisp frontend for Neovim.
      • Slimv_box - slimv in a Docker container.

  • Notebooks ##

    • Third-party APIs

      • common-lisp-jupyter - A Common Lisp kernel for Jupyter along with a library for building Jupyter kernels, based on Maxima-Jupyter by Robert Dodier which was based on cl-jupyter by Frederic Peschanski. [MIT][200].
      • cl-jupyter - A Common Lisp kernel for Jupyter notebooks [custom licence](https://github.com/fredokun/cl-jupyter/blob/master/LICENSE).
      • Cytoscape widget - Cytoscape.js widget for common-lisp-jupyter.
      • ngl widget - A ngl widget (protein viewer) for common-lisp-jupyter.
      • sheet widget - Data grid widget for common-lisp-jupyter.
      • Kekule widget - Kekule.js widget for common-lisp-jupyter.

  • Python ##

    • cl-python - an implementation of Python in Common Lisp. [LLGPL][8], not under active development.
    • burgled-batteries - A bridge between Python and Common Lisp. The goal is that Lisp programs can use Python libraries. Not available on Quicklisp. [MIT][200].
    • cl4py - The library cl4py (pronounce as clappy) allows Python programs to call Common Lisp libraries. [MIT][200].
    • py4cl - A library that allows Common Lisp code to access Python libraries. It is basically the inverse of cl4py. [MIT][200].
    • py4cl2
    • py4cl2-cffi - CFFI based alternative to py4cl2.
    • async-process
    • async-process

  • Educational

  • C ##

    • CFFI - Portable, easy-to-use C foreign function interface. [Expat][14].
    • cffi-ops - helps write concise CFFI-related code.
    • cffi-objects - enables fast and convenient interoperation with foreign objects.
    • cl-autowrap - Automatically parses header files into CFFI definitions. [FreeBSD][39].
    • cl-bindgen - A command line tool and library for creating Common Lisp language bindings from C header files. [MIT][200].
    • cl-gobject-introspection - [Gobject Introspection](https://gi.readthedocs.io/en/latest/) FFI. Automatic bindings to call into the C library. [BSD][15]. Generate a lisp interface with [gir2cl](https://github.com/kat-co/gir2cl). [LGPL3][9].
    • cl-cxx-jit - Common Lisp and C++ interoperation with JIT. [MIT][200].

  • Erlang ##

    • CLERIC - a Common Lisp Erlang Interface. An implementation of the Erlang distribution protocol, comparable with erl_interface and jinterface. [MIT][200].

  • Objective-C ##

    • objc-lisp-bridge - A portable reader and bridge for interacting with Objective-C and Cocoa. [MIT][200].
    • cl-nextstep - Cocoa binding for Common Lisp on macOS.
    • cocoas - A toolkit library to help deal with CoreFoundation, Cocoa, and objc. zlib.

  • .Net Core

    • Bike - a cross-platform .Net Core interface. [MIT][200].

  • Atom, Pulsar ##

  • MCP servers

    • Lisply MCP - a generic Node.js wrapper meant to work with pretty much any language backend which can support "eval" and http .
    • 40ants-MCP - a framework for building Model Context Protocol servers in Common Lisp.
    • cl-MCP - MCP for Common Lisp.

  • Natural Language Processing

    • sparser - A natural language understanding system for English. [Eclipse][209].
    • cl-nlp - Natural language processing toolset. [Apache2.0][89].
    • babel2 - A Fluid Construction Grammar implementation, computational framework, and unification-based grammar formalism [Apache2.0][89].
    • babel2 - A Fluid Construction Grammar implementation, computational framework, and unification-based grammar formalism [Apache2.0][89].

  • Eclipse ##

    • Third-party APIs

      • Dandelion - a Common Lisp plugin for the Eclipse IDE.

  • LispWorks

    • Third-party APIs

      • lw-rich-text - LispWorks panes with support for HTML-like markup.
      • lw-plugins - LispWorks Plugins by April & May. OBSD.

  • JetBrains

    • Third-party APIs

      • SLT - an IDE Plugin for Itellij/Jetbrains IDE lineup implementing support for Common Lisp via SBCL and Slime/Swank.
      • this fork

  • Geany (experimental) ##

  • Lisp parsers

    • gmap - A concise and extensible iteration facility that has the advantage of integrating well with FSet (see the Data Structures section), as it was written by the same author. In Quicklisp as part of `misc-extensions`. Public domain.
    • rewrite-cl - Read, modify, and write Common Lisp source code while preserving whitespace and comments. MIT. *Built with LLMs*.
    • Eclector - A portable Common Lisp reader that is highly customizable, can recover from errors and can return concrete syntax trees.
    • smelter - a zero setup Coalton (and CL) scripts runner, with some batteries (JSON, HTTP, filesystem, process utilities).
Programming Languages
Common Lisp 288 Emacs Lisp 9 JavaScript 4 Python 4 TypeScript 4 C++ 3 HTML 3 C 2 Clojure 2 Jupyter Notebook 2
Categories
Interfaces to other package managers 290 Miscellaneous ## 199 Online editors ## 179 Expert Systems 161 Online ## 101 Offline ## 57 Emacs ## 18 Apps ## 18 Machine Learning 12 Python ## 8 Clojure 8 C ## 7 REPLs ## 7 Educational 6 Notebooks ## 6 VSCode ## 4 Vim & Neovim ## 4 Natural Language Processing 4 Lisp parsers 4 Lem ## 4 MCP servers 3 Objective-C ## 3 Java ## 3 Emacs Lisp 2 Atom, Pulsar ## 2 Sublime Text ## 2 LispWorks 2 JetBrains 2 Geany (experimental) ## 1 Erlang ## 1 Eclipse ## 1 .Net Core 1
Sub Categories
Third-party APIs 392 Isomorphic web frameworks 65 Clack plugins 18 Hosting platforms 16 Web project skeletons and generators 12 Hunchentoot plugins 7 User login and password management 5 Email 5 OpenAPI, OData, OpenRPC 5 Interfaces to other package managers 3 Browser tests 2 Static site generators 2 Form handling 1
Keywords
common-lisp 125 lisp 45 emacs 9 web 5 slime 5 jupyter 5 quicklisp 4 python 4 compiler 4 gamedev 4 parsing 3 tools 3 cookiecutter 3 testing 3 webframework 3 gui 3 repl 3 monitoring 3 sbcl 3 literate-programming 3 game-development 3 database 3 csv 3 cffi 3 binary 2 concurrency 2 interoperability 2 user-agent 2 parser 2 bindings 2 encoding 2 2d 2 game-engine 2 editor 2 CommonLisp 2 jupyter-widgets 2 json-rpc 2 api 2 functional-programming 2 ide 2 audio 2 sql 2 documentation 2 programming 2 networking 2 postgresql 2 common lisp 2 prometheus 2 ci 2 json 2