---
visibility: public
---

# Common Lisp

**repo:** [CodyReichert/awesome-cl](https://github.com/CodyReichert/awesome-cl)  
**category:** [[programming-languages|Programming Languages]]

---

# Awesome Common Lisp [![Awesome](https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)](https://github.com/sindresorhus/awesome) [![Assertible status](https://assertible.com/apis/102e334d-f9a8-4565-9353-7572de775cae/status?api_token=8b55a286830323effb)](https://assertible.com/docs/guide/deployments)

A curated list of _awesome_ Common Lisp libraries.

All libraries listed here are available from [Quicklisp][16] unless
stated otherwise. The ones marked with a ⭐ are so widespread and
solid that they became community standards. You can't be wrong with
them. This is the case for Quicklisp, BordeauxThreads and
such. Libraries denoted with a 👍 are the ones we like and want to
promote here at the Awesome-cl list. They proved solid, they may solve
a problem better than a community standard but they aren't as
widespread, or not considered as stable. For example, we prefer
Spinneret over Cl-Who.

---

For a list of *software*, see the [lisp-screenshots.org](https://www.lisp-screenshots.org/) gallery and the
[awesome-cl-software](https://github.com/azzamsa/awesome-cl-software) list.

For examples of *companies* using CL in production, see [lisp-lang.org's success stories](http://lisp-lang.org/success/),
the [awesome-lisp-companies](https://github.com/azzamsa/awesome-lisp-companies/) list,
but also [LispWorks' success stories](https://www.lispworks.com/success-stories/index.html)
and [Allegro's success stories](https://franz.com/success/).

---

Add something new! See the [contributing](#contributing) section for adding something to the
list.

This is released under the GNU Free Documentation License - its text
is provided in the LICENSE file. Preference is given to [free software][13] and
sellers who aren't evil for physical resources.

**Table of Contents**

- [Artificial Intelligence (AI, LLMs)](#artificial-intelligence-ai-llms)
  - [Around the OpenAI API](#around-the-openai-api)
  - [MCP servers](#mcp-servers)
  - [Machine Learning](#machine-learning)
  - [Natural Language Processing](#natural-language-processing)
  - [Expert Systems](#expert-systems)
  - [Educational](#educational)
- [Audio](#audio)
- [Build Systems](#build-systems)
- [Compilers, code generators](#compilers-code-generators)
  - [APL](#apl)
  - [C, C++](#c-c)
- [Cryptography](#cryptography)
- [Cryptocurrencies](#cryptocurrencies)
- [Database](#database)
  - [ORMs](#orms)
  - [Persistent object databases](#persistent-object-databases)
  - [Graph databases](#graph-databases)
  - [Other DB wrappers](#other-db-wrappers)
  - [Migration tools](#migration-tools)
  - [To third parties](#to-third-parties)
  - [Tools](#tools)
- [Data Formats](#data-formats)
  - [CSV](#csv)
  - [JSON](#json)
  - [TOML](#toml)
  - [XML](#xml)
  - [YAML](#yaml)
- [Data Structures](#data-structures)
- [Docker images](#[docker](/@harrisonqian/awesome/wiki/back-end-development/docker)-images)
- [Foreign Function Interface, languages interop](#foreign-function-interface-languages-interop)
  - [C](#c)
  - [Clojure](#clojure)
  - [Erlang](#erlang)
  - [Java](#java)
  - [Objective-C](#objective-c)
  - [Python](#python)
  - [.Net Core](#net-core)
  - [Emacs Lisp](#[emacs](/@harrisonqian/awesome/wiki/editors/emacs)-lisp)
  - [Miscellaneous](#miscellaneous)
- [Game Development](#game-development)
- [Graphics](#graphics)
- [GUI](#gui)
  - [Web views](#web-views)
  - [Mobile](#mobile)
- [Implementations](#implementations)
- [Language libraries](#language-libraries)
  - [Lisp parsers](#lisp-parsers)
- [Language extensions](#language-extensions)
  - [Pattern matching](#pattern-matching)
  - [Portability layers](#portability-layers)
  - [Changing the syntax](#changing-the-syntax)
  - [CLOS extensions](#clos-extensions)
  - [Function extensions](#function-extensions)
  - [Iteration](#iteration)
  - [Lambda shorthands](#lambda-shorthands)
  - [Non-deterministic, logic programming](#non-deterministic-logic-programming)
  - [Reactive programming](#reactive-programming)
  - [Contract programming](#contract-programming)
  - [Typing](#typing)
  - [Theorem provers](#theorem-provers)
- [Learning and Tutorials](#[learning](/@harrisonqian/awesome/wiki/programming-languages/learning)-and-tutorials)
  - [Online](#online)
  - [Beginner](#beginner)
  - [Intermediate](#intermediate)
  - [Advanced](#advanced)
  - [Coding platforms](#coding-platforms)
  - [Web Development](#web-development)
  - [Reference](#reference)
  - [Offline](#offline)
  - [Beginner](#beginner-1)
  - [Intermediate](#intermediate-1)
  - [Advanced](#advanced-1)
  - [Other books](#other-books)
  - [Community](#community)
  - [Showcase](#showcase)
- [Library Manager](#library-manager)
  - [Interfaces to other package managers](#interfaces-to-other-package-managers)
- [Network and Internet](#network-and-internet)
  - [HTTP clients](#http-clients)
  - [HTTP Servers](#http-servers)
    - [Hunchentoot plugins](#hunchentoot-plugins)
    - [Clack plugins](#clack-plugins)
  - [Web frameworks](#web-frameworks)
    - [Isomorphic web frameworks](#isomorphic-web-frameworks)
  - [Parsing html](#parsing-html)
  - [Querying HTML/DOM, web scraping](#querying-htmldom-web-scraping)
  - [HTML generators and templates](#html-generators-and-templates)
  - [URI and IP handling](#uri-and-ip-handling)
  - [Javascript](#javascript)
  - [Deployment](#deployment)
    - [Hosting platforms](#hosting-platforms)
  - [Monitoring](#monitoring)
  - [Websockets](#websockets)
  - [HTTPS](#https)
  - [Web development utilities](#web-development-utilities)
    - [Browser tests](#browser-tests)
    - [Form handling](#form-handling)
    - [User login and password management](#user-login-and-password-management)
    - [Web project skeletons and generators](#web-project-skeletons-and-generators)
  - [Others](#others)
    - [Email](#email)
    - [OpenAPI, OData, OpenRPC](#openapi-odata-openrpc)
    - [Static site generators](#static-site-generators)
    - [Third-party APIs](#third-party-apis)
- [Numerical and Scientific](#numerical-and-scientific)
  - [Matrix libraries](#matrix-libraries)
  - [Statistics](#statistics)
  - [Units](#units)
  - [Plotting](#plotting)
  - [Utils](#utils)
- [Parallelism and Concurrency](#parallelism-and-concurrency)
  - [Actors pattern](#actors-pattern)
  - [Event processing](#event-processing)
  - [Job processing](#job-processing)
- [Regular expressions and string parsing](#regular-expressions-and-string-parsing)
- [Scripting](#scripting)
  - [Running scripts](#running-scripts)
  - [Command-line options parsers](#command-line-options-parsers)
  - [Readline, ncurses and other graphical TUI helpers](#readline-ncurses-and-other-graphical-tui-helpers)
  - [Shells, shells interfaces](#shells-shells-interfaces)
  - [System administration](#system-administration)
  - [Updating executables](#updating-executables)
  - [Other scripting utilities](#other-scripting-utilities)
- [Text Editor Resources](#text-editor-resources)
  - [Emacs](#emacs)
  - [Vim & Neovim](#vim--neovim)
  - [Eclipse](#eclipse)
  - [Lem](#lem)
  - [LispWorks](#lispworks)
  - [Atom, Pulsar](#[atom](/@harrisonqian/awesome/wiki/editors/atom)-pulsar)
  - [Sublime Text](#sublime-text)
  - [VSCode](#vscode)
  - [JetBrains](#jetbrains)
  - [Geany (experimental)](#geany-experimental)
  - [Notebooks](#notebooks)
  - [REPLs](#repls)
  - [Online editors](#online-editors)
- [Text and binary parsers](#text-and-binary-parsers)
- [Text Processing](#text-processing)
- [Tools](#tools-1)
- [Unit Testing](#unit-testing)
- [Utilities](#utilities)
  - [Caching (serialization)](#caching-serialization)
  - [Caching (memoization)](#caching-memoization)
  - [Compression / decompression](#compression--decompression)
  - [Configuration](#configuration)
  - [Date and time](#date-and-time)
  - [Data validation](#data-validation)
  - [Developer utilities](#developer-utilities)
  - [Documentation builders](#documentation-builders)
  - [Documentation lookup](#documentation-lookup)
  - [Files and directories](#files-and-directories)
  - [Git](#git)
  - [i18n](#i18n)
  - [Linting, code formatting](#linting-code-formatting)
  - [Literate programming](#literate-programming)
  - [Logging](#logging)
  - [Macro helpers](#macro-helpers)
  - [Markdown](#markdown)
  - [Package declarations](#package-declarations)
  - [PDF](#pdf)
  - [Project skeletons](#project-skeletons)
  - [Security](#security)
  - [System interface](#system-interface)
  - [Other](#other)
- [Contributing](#contributing)

Artificial Intelligence (AI, LLMs)
==================================

## Around the OpenAI API

* [openai-openapi-client](https://codeberg.org/kilianmh/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.
  * available on Ultralisp.
* [cl-completions](https://github.com/atgreen/cl-completions) - LLM completions.
  * makes it easy to create GPT functions in Common Lisp.
  * Ollama support.
* [cl-embeddings](https://github.com/atgreen/cl-embeddings) - LLM embeddings.
* [cl-chroma](https://github.com/atgreen/cl-chroma) - the vector DB interface.

demos: [cl-rag-example](https://github.com/atgreen/cl-rag-example) and [cl-chat](https://github.com/atgreen/cl-chat), a LLM chat library and web UI.

Work In Progress:

* [Caten](https://github.com/hikettei/Caten) -  [Deep Learning](/@harrisonqian/awesome/wiki/computer-science/deep-learning) Compiler based on Polyhedral Compiler and Light-weight IRs, and Optimizing Pattern Matcher, written in Common Lisp

## MCP servers

* [cl-MCP](https://github.com/cl-ai-project/cl-mcp) - MCP for Common Lisp.
  * provides a newline‑delimited [JSON](/@harrisonqian/awesome/wiki/miscellaneous/json)‑RPC 2.0 transport over stdio or TCP, a small protocol layer (initialize, ping, tools/list, tools/call), and a REPL tool that evaluates forms and returns the last value.
* [40ants-MCP](https://github.com/40ants/mcp) - a framework for building Model Context Protocol servers in Common Lisp.
* [mcp-lisp](https://github.com/jsulmont/mcp-lisp) - Common Lisp SDK for MCP (2025-11-25) with full conformance (44/44 checks) and limited A2A support. Supports stdio and SSE transports, tools, resources, prompts, structured errors, and access logging. [MIT][200].
* [Lisply MCP](https://github.com/gornskew/lisply-mcp) - a generic [Node.js](/@harrisonqian/awesome/wiki/platforms/node-js) wrapper meant to work with pretty much any language backend which can support "eval" and http .
  * By default, it comes configured to work with an existing reference-implementation backend CL-based container image which it will pull and run on-demand.

## Machine Learning

* [MGL](https://github.com/melisgl/mgl) - a [machine learning](/@harrisonqian/awesome/wiki/computer-science/machine-learning) library for backpropagation neural networks, boltzmann machines, gaussian processes and more. [MIT][200].
  * some parts originally contributed by Ravenpack International.
  * used by its [author](https://github.com/melisgl) to [win](https://github.com/melisgl/higgsml) the Higgs Boson [Machine Learning](/@harrisonqian/awesome/wiki/computer-science/machine-learning) Challenge.
  * more about the author: he also won the Google [AI Challenge](https://en.wikipedia.org/wiki/AI_Challenge) in 2010 using Common Lisp, but without MGL, as no [machine learning](/@harrisonqian/awesome/wiki/computer-science/machine-learning) was needed. A [related talk](https://www.youtube.com/watch?v=7sgERtZkycU) (59', 2013).
* [clml](https://github.com/mmaul/clml) - originally developed by Mathematicl Systems Inc., a Japanese company. With a [tutorial](https://mmaul.[github](/@harrisonqian/awesome/wiki/development-environment/github).io/clml.tutorials//2015/08/08/CLML-Time-Series-Part-1.html). [LLGPL][8].
* [antik](https://www.common-lisp.net/project/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).

Credit: borretti.me's [State of CL Ecosystem 2015](http://borretti.me/article/common-lisp-sotu-2015#machine-learning).

* [llama.cl](https://github.com/snunez1/llama.cl) - implementation of Llama inference operations. MIT.
    * "Enables researchers and developers to explore LLM techniques within the Common Lisp ecosystem, leveraging the language's capabilities for interactive development and [integration](/@harrisonqian/awesome/wiki/platforms/integration) with symbolic AI systems."

## Natural Language Processing

* 🚀 [sparser](https://github.com/ddmcdonald/sparser) - A natural language understanding system for English. [Eclipse][209].
  * > a model-driven, rule-based language text analysis system for large volume, high-precision information extraction. At its heart, Sparser is a bottom-up, phrase-structure-based chart parser, optimized for semantic grammars and partial parsing.
* [cl-nlp](https://github.com/vseloved/cl-nlp) - Natural language processing toolset. [Apache2.0][89].
* [babel2](https://github.com/lucas8/Babel2/) - A Fluid Construction Grammar implementation, computational framework, and unification-based grammar formalism [Apache2.0][89].

## Expert Systems

* [Lisa](https://github.com/youngde811/Lisa) - a production-quality, forward-chaining expert system [shell](/@harrisonqian/awesome/wiki/development-environment/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.
* [WouldWork](https://github.com/davypough/wouldwork) - solve classical planning and constraint satisfaction problems without extensive programming experience. BSD_3Clause.

## Educational

* [PAIP-lisp](https://github.com/norvig/paip-lisp) - Lisp code for the textbook ["Paradigms of [Artificial Intelligence](/@harrisonqian/awesome/wiki/theory/artificial-intelligence) Programming"](https://norvig.[github](/@harrisonqian/awesome/wiki/development-environment/github).io/paip-lisp/#/).
* [AIMA-lisp](https://github.com/aimacode/aima-lisp) -  Common Lisp implementation of [algorithms](/@harrisonqian/awesome/wiki/theory/algorithms) from Russell and Norvig's "[Artificial Intelligence](/@harrisonqian/awesome/wiki/theory/artificial-intelligence) - A Modern Approach".
* the book [Reinforcement [Learning](/@harrisonqian/awesome/wiki/programming-languages/learning): An Introduction](http://www.incompleteideas.net/book/the-book.html), by Richard S. Sutton and Andrew G. Barto, with code in Lisp.
  * the authors are the recipients of the [2024 ACM A.M. Turing Award](https://awards.acm.org/about/2024-turing) for developing the conceptual and algorithmic foundations of reinforcement [learning](/@harrisonqian/awesome/wiki/programming-languages/learning).

Audio
=====

Music composition:

* [OpenMusic](https://github.com/openmusic-project/openmusic/) visual programming / computer-aided composition environment. [GPL3][2]. Developped at [IRCAM](https://www.stms-lab.fr/team/representations-musicales/), France.
* [OM7](https://github.com/openmusic-project/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].
  * an extension: [rq](https://github.com/openmusic-project/RQ) - a library for rhythm transcription in OpenMusic (version 6.10 and later). [demo video](https://www.youtube.com/watch?v=XVEllB0TtVs). [GPL3][2].
* [Incudine](http://incudine.sourceforge.net/) -  [Music](/@harrisonqian/awesome/wiki/media/music)/DSP programming environment for Common Lisp. Useful to design software synthesizers or sound plugins from scratch. It is also a compositional tool that allows to produce high quality sounds controllable at the sample level, defining and redefining the digital signal processors and the musical structures on-the-fly.
* [CLM](https://ccrma.stanford.edu/software/clm/) - Common Lisp [Music](/@harrisonqian/awesome/wiki/media/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).
  * [common-tones](https://github.com/theraphonics/common-tones) - a fork of CLM5 with modern Lisp (ASDF, cffi…). [BSD_3Clause][15].
* [Slippery Chicken](https://github.com/mdedwards/slippery-chicken/) - Algorithmic composition library which outputs Midi, Common [Music](/@harrisonqian/awesome/wiki/media/music) Notation, pdf-score via Lilypond and sound via Common Lisp Music. [GPL3][2].
  * with documentation: https://michael-edwards.org/sc/
* [Common Music](https://github.com/ormf/cm) - the repository of an
  ancient version of Common Music (version 2.12.0), the presumably
  last version which ran on Common Lisp dating from around 2007-09,
  before work on Common Music shifted to (scheme-based) cm3.
  * note: old project but working.
  * [cm-incudine](https://github.com/ormf/cm-incudine) - extends Common [Music](/@harrisonqian/awesome/wiki/media/music) 2 with realtime capabilities. GPL2.
* [cl-patterns](https://github.com/defaultxr/cl-patterns) - a system for composing [music](/@harrisonqian/awesome/wiki/media/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](https://github.com/MegaLoler/Music) - A framework for musical expression in Lisp with a focus on [music](/@harrisonqian/awesome/wiki/media/music) theory (built from scratch, unrelated to Common Music).

Decoders, sound processing:

* [Harmony](https://shirakumo.[github](/@harrisonqian/awesome/wiki/development-environment/github).io/harmony) - A real-time sound processing and playback system. [zlib][33].
  * "provides you with audio processing tools as well as an audio server to play back [music](/@harrisonqian/awesome/wiki/media/music), sfx, and so forth."
  * using [cl-mixed](https://github.com/Shirakumo/cl-mixed) for the mixing and sound processing library.
* [easy-audio](https://github.com/shamazmazum/easy-audio) - a collection of audio decoders and metadata readers.

others:

* [scheduler](https://github.com/byulparan/scheduler) - The time based musical event scheduler for Common Lisp. [Apache2.0][89].
* [Common [Music](/@harrisonqian/awesome/wiki/media/music) Notation](https://ccrma.stanford.edu/software/cmn/) - Common Music Notation (CMN) provides a package of functions to hierarchically describe a musical score. Public domain.
* [osc](https://github.com/zzkt/osc) - an implementation of the Open Sound Protocol. [LGPL2.1][11].

bindings and clients to other software and libraries:

* [cl-mpg123](https://github.com/Shirakumo/cl-mpg123), [cl-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)
* [csound](https://github.com/csound/csound) - A sound and [music](/@harrisonqian/awesome/wiki/media/music) computing system. Includes CFFI and FFI interfaces for Common Lisp.
* [cl-collider](https://github.com/byulparan/cl-collider) - A [SuperCollider](http://supercollider.[github](/@harrisonqian/awesome/wiki/development-environment/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.
* [cl-openal](https://github.com/zkat/cl-openal) - bindings for the OpenAL audio library. Public domain.

and more audio software targetting musicians on [awesome-cl-software#audio](https://github.com/CodyReichert/awesome-cl#audio) (Opus Modus, OpenMusic…).

Build Systems
=============

* ⭐[ASDF](https://common-lisp.net/project/asdf/) - Another System Definition Facility; a build system for Common Lisp. [Expat][14]. Quicklisp (see [library manager](#library-manager)) uses ASDF under the hood.
  * [known ASDF extensions](https://common-lisp.net/project/asdf/#extensions), such as `asdf-system-connections`, that lets you specify systems that are automatically loaded when two other systems are loaded, to connect them.
* [asdf-viz](https://github.com/guicho271828/asdf-viz) - a tool to visualize the library dependencies of ASDF systems, the call graph of a function and the class inheritances. [LLGPL][8].

See also:

* [modularize](https://codeberg.org/shinmera/modularize) -  A modularization framework for Common Lisp. [zlib][33].
  * provides a common interface to segregate major application components.
  * for instance, by adding module definition options you can introduce mechanisms to tie modules together in functionality, hook into each other and so on.
  * acts as a wrapper around `defpackage` and integrates into ASDF.
* [asdf-linguist](https://github.com/eudoxia0/asdf-linguist) - Extensions for ASDF for compiling various languages and running various preprocessing tools on files in your project. [Expat][14].
  * [Sass](/@harrisonqian/awesome/wiki/front-end-development/sass), [LESS](/@harrisonqian/awesome/wiki/front-end-development/less), Myth, C, C++, [Fortran](/@harrisonqian/awesome/wiki/programming-languages/fortran), CSS/JS minifiers, ParensScript, Make, [CMake](/@harrisonqian/awesome/wiki/programming-languages/cmake), org-mode, pandoc, dot, diita…
  * currently archived and unmaintained.
* [asdf-dependency-traverser](https://codeberg.org/johnlorentzson/asdf-dependency-traverser/) - a small utility for traversing the dependency tree of an ASDF system. Zlib.

Compilers, code generators
==========================

APL
---

* [April](https://github.com/phantomics/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].

C, C++
------

* [C-mera](https://github.com/kiselgra/c-mera) - a source-to-source compiler that utilizes Lisp's macro system for meta programming of C-like languages. [GPL3][2].
* [lispc](https://github.com/eratosthenesia/lispc) - a powerful "lispsy" macrolanguage for C. [MIT][200].
* [with-c-syntax](https://github.com/y2q-actionman/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.
* [ecrepl](https://gitlab.common-lisp.net/ecl/ecrepl) - an interactive REPL for the C language. [BSD_2Clause][17].
* [Software-Evolution-Library](https://github.com/GrammaTech/sel) - The SEL enables the programmatic modification and evaluation of software (C/C++ support using Clang, compiled assembler, and linked ELF binaries). [GPL3][2].
* [vacietis](https://github.com/vsedach/Vacietis) -  C to Common Lisp compiler. [LGPL3][9].
* NEW as of 2025 [Cicili](https://github.com/saman-pasha/cicili/) - C generator macro-driven language. GPL3.0.
  * "can use lisp libraries to produce compile time content like html, [json](/@harrisonqian/awesome/wiki/miscellaneous/json), sql, ... for inside C generated code".

Cryptography
============

* ⭐ [Ironclad](https://github.com/sharplispers/ironclad) - A library of crypto functions for Common Lisp. Not considered secure, but is still useful for the message digest functions. [Expat][14].
* [crypto-shortcuts](https://codeberg.org/shinmera/crypto-shortcuts) - Collection of common crypto shortcuts. [zlib][33].
* [cl-ssh-keys](https://github.com/dnaeon/cl-ssh-keys) - Common Lisp system for generating and parsing of OpenSSH keys. [BSD_3Clause][15].
* [cl-bcrypt](https://github.com/dnaeon/cl-bcrypt) - Common Lisp system for parsing and generating bcrypt password hashes. [BSD_3Clause][15].
* [gpgme](https://www.gnupg.org/download/index.en.html#gpgme) (GnuPG Made Easy) is the standard library to access GnuPG functions from programming languages. It provides an official Common Lisp system.
  * [gpgme lisp sources](https://git.gnupg.org/cgi-bin/gitweb.cgi?p=gpgme.git;a=tree;f=lang/cl;h=05151bdf839e513f534a1b423d59332a2e46fd5d;hb=HEAD) (not in Quicklisp). GPL2.
* [cl-frugal-uuid](https://github.com/ak-coram/cl-frugal-uuid/) -  Common Lisp UUID library with zero dependencies. [MIT][200].

Cryptocurrencies
================

* [bitcoin-[core](/@harrisonqian/awesome/wiki/platforms/core)-rpc](https://codeberg.org/kilianmh/bitcoin-core-rpc/) - a (hopefully) complete [Bitcoin](/@harrisonqian/awesome/wiki/decentralized-systems/bitcoin) Core RPC client. [AGPL-3.0+][agpl3]
* [bp](https://github.com/rodentrabies/bp) - [Bitcoin](/@harrisonqian/awesome/wiki/decentralized-systems/bitcoin) Protocol components in Common Lisp. [MIT][200].
* [peercoin-blockchain-parser](https://github.com/glv2/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](/@harrisonqian/awesome/wiki/databases/database). It can also create a [database](/@harrisonqian/awesome/wiki/databases/database) using the RPC of a Peercoin daemon as source of data instead of a blockchain file. LGPL3. Not in Quicklisp.
* [peercoin-calculator](https://github.com/glv2/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-vote](https://github.com/glv2/peercoin-vote) -  A voting system based on data from the blockchain (addresses and balances). [GPL3][2]. Not in Quicklisp.
* [stacks-api](https://github.com/kilianmh/stacks-api) - a [Stacks](/@harrisonqian/awesome/wiki/miscellaneous/stacks) API client. [AGPL-3.0][89]

See also [legochain](https://github.com/defunkydrummer/legochain), a simple educational blockchain; [emotiq](https://github.com/emotiq/emotiq), a next-generation blockchain with an innovative natural-language approach to smart contracts built in Common Lisp (stopped).

Database
========

* ⭐ [postmodern](http://marijnhaverbeke.nl/postmodern/) - A library for interacting with [PostgreSQL](/@harrisonqian/awesome/wiki/databases/postgresql). [zlib][33].
* [cl-dbi](https://github.com/fukamachi/cl-dbi) - A [database](/@harrisonqian/awesome/wiki/databases/database)-independent interface for Common Lisp. [LLGPL][8].
* [sxql](https://github.com/fukamachi/sxql) - A DSL for generating SQL. [3-clause BSD][15].
  * NEW as of Oct, 2025: a [composable query builder](https://github.com/fukamachi/sxql/blob/master/COMPOSER.md). Queries become first-class values that can be derived, combined, and reused without side effects.
* [cl-sqlite](https://github.com/dmitryvk/cl-sqlite) - Bindings for SQLite. Public domain.
* [cl-yesql](https://github.com/ruricolist/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](/@harrisonqian/awesome/wiki/programming-languages/clojure)'s Yesql. [MIT][200].

See also:

* [endatabas](https://github.com/endatabas/endb) - Schemaless SQL document [database](/@harrisonqian/awesome/wiki/databases/database) with full history. [AGPL-3.0][89].
  - built in Common Lisp and [Rust](/@harrisonqian/awesome/wiki/programming-languages/rust), in development.

ORMs
----

* 👍 [mito](https://github.com/fukamachi/mito) - An ORM for Common Lisp with migrations, relationships and [PostgreSQL](/@harrisonqian/awesome/wiki/databases/postgresql) support [BSD_3Clause][15].
  * [mitho-auth](https://github.com/fukamachi/mito-auth), a mixin class for use authorization
  * [mito-attachment](https://github.com/fukamachi/mito-attachment), a mixin class for file management outside of RDBMS.
  * works best coupled with SxQL and its Query [Composer](/@harrisonqian/awesome/wiki/programming-languages/composer).
* [clsql](http://www.cliki.net/CLSQL) - An SQL [database](/@harrisonqian/awesome/wiki/databases/database) with a Common Lisp interface. [LLGPL][8].
  * [dbd-oracle](https://github.com/sergadin/dbd-oracle) - an Oracle [database](/@harrisonqian/awesome/wiki/databases/database) driver for CL-DBI. [LLGPL][8].
* [datafly](https://github.com/fukamachi/datafly) - A lightweight [database](/@harrisonqian/awesome/wiki/databases/database) library. [3-clause BSD][15].

Persistent object databases
---------------------------

* [bknr.datastore](https://github.com/hanshuebner/bknr-datastore) - a CLOS-based lisp-only [database](/@harrisonqian/awesome/wiki/databases/database) in RAM with transaction logging persistence. [Manual](https://www.common-lisp.net/project/bknr/html/documentation.html). [licence][208].
  * see also this [good introductory blog post](https://ashok-khanna.medium.com/persistent-in-memory-data-storage-in-common-lisp-b-k-n-r-37f8ae76042f)
  * an example web application using bknr.datastore: [screenshotbot-oss](https://github.com/screenshotbot/screenshotbot-oss).
  * See also [bknr.cluster](https://github.com/tdrhq/bknr.cluster), if you want a highly-available replicated version of bknr.datastore. [blog post](https://screenshotbot.io/blog/building-a-highly-available-web-service-without-a-database).
* [ubiquitous](https://codeberg.org/shinmera/ubiquitous) - A library providing easy-to-use persistent configuration storage. [zlib][33].
* [cl-prevalence](https://common-lisp.net/project/cl-prevalence/) - in-memory [database](/@harrisonqian/awesome/wiki/databases/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].
  * See also [cl-prevalence-multimaster](https://github.com/40ants/cl-prevalence-multimaster), to syncronize multiple cl-prevalence systems state.

See also the [Caching (serialization)](#caching-serialization) section.

Graph databases
---------------

* [AllegroGraph](https://allegrograph.com/) - a high-performance, multi-model (document and graph), entity-event knowledge graph technology.
  * Proprietary, with a free version of a limit of 5 million RDF triples.
  * with a [hosted version](https://allegrograph.cloud/)
  * AllegroGraph 8.0 - "incorporates Large Language Model (LLM) components directly into SPARQL along with vector generation and vector storage for a comprehensive AI Knowledge Graph solution."
* [cl-agraph](https://github.com/vseloved/cl-agraph), a minimal client for AllegroGraph.
* [neo4cl](https://codeberg.org/Equill/neo4cl) - a library for interacting with [Neo4J](/@harrisonqian/awesome/wiki/databases/neo4j). Sends Cypher queries to a [Neo4J](/@harrisonqian/awesome/wiki/databases/neo4j) server, and decodes the responses into something useful for processing in CL. [Apache2][89].
  * and maybe: [cl-neo4j](https://github.com/kraison/cl-neo4j) - a thin [neo4j](/@harrisonqian/awesome/wiki/databases/neo4j) RESTFUL client interface.
* [vivace-graph](https://github.com/kraison/vivace-graph-v3) - graph [database](/@harrisonqian/awesome/wiki/databases/database) & Prolog implementation. Takes design [inspiration](/@harrisonqian/awesome/wiki/front-end-development/inspiration) from [CouchDB](/@harrisonqian/awesome/wiki/databases/couchdb), [neo4j](/@harrisonqian/awesome/wiki/databases/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].
  * "I have used Vivace Graph as an online catalog for millions of products, as the back end for a complex, adaptable VoIP-based IVR, as well as data store for several complex [big data](/@harrisonqian/awesome/wiki/big-data/big-data) analysis systems, and finally as the engine for two recommender systems." (issue #23)
  * "Why is vivace graph so fast? I have been comparing it with SQL-based approach and [Neo4j](/@harrisonqian/awesome/wiki/databases/neo4j), and vivace graph is much, much faster."

and also:

* [restagraph](https://github.com/JermellB/restagraph) - an app that dynamically generates [REST](/@harrisonqian/awesome/wiki/miscellaneous/rest) APIs for a [Neo4j](/@harrisonqian/awesome/wiki/databases/neo4j) [database](/@harrisonqian/awesome/wiki/databases/database), using a schema defined within the database. [GPL3][2].

Other DB wrappers
-----------------

* [cl-memcached](https://github.com/quasi/cl-memcached) - Fast, thread-safe interface to the Memcached object caching system. [Expat][14].
* [cl-redis](https://github.com/vseloved/cl-redis) - Redis client. [Expat][14].
* [cl-disque](https://github.com/CodyReichert/cl-disque) - Disque client. [3-clause BSD][15].
* [cl-rethinkdb](https://github.com/orthecreedence/cl-rethinkdb) - [RethinkDB](/@harrisonqian/awesome/wiki/databases/rethinkdb) client. [Expat][14].
* [cl-mango](https://github.com/cmoore/cl-mango/) -  A minimalist [CouchDB](/@harrisonqian/awesome/wiki/databases/couchdb) 2.x [database](/@harrisonqian/awesome/wiki/databases/database) client. BSD_3Clause.
  * See also [clouchdb](https://common-lisp.net/project/clouchdb/) - Library for interacting with [CouchDB](/@harrisonqian/awesome/wiki/databases/couchdb). [FreeBSD][39].
* [lmdb](https://github.com/antimer/lmdb) - Bindings to [LMDB](http://www.lmdb.tech/doc/), the Lightning Memory-mapped [Database](/@harrisonqian/awesome/wiki/databases/database), an ACID key-value database with MultiVersion Concurrency Control.
* [cl-ndbapi](https://github.com/datagraph/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.
* [cl-duckdb](https://github.com/ak-coram/cl-duckdb) -  Common Lisp CFFI wrapper around the DuckDB C API. [MIT][200].
* [cl-bunny](https://github.com/cl-rabbit/cl-bunny) -  Common Lisp RabbitMQ client based on IOLib. MIT.

Migration tools
---------------

(recall that Mito handles migrations)

* [cl-migratum](https://github.com/dnaeon/cl-migratum) - a system which provides facilities for performing [database](/@harrisonqian/awesome/wiki/databases/database) schema migrations, designed to work with various databases. [BSD_3Clause][15].
* [postmodern-passenger-pigeon](https://github.com/fisxoj/postmodern-passenger-pigeon/) - a migration manager for postmodern. No licence specified.

To third parties
----------------

* [dyna](https://github.com/Rudolph-Miller/dyna) - an AWS DynamoDB ORM. [MIT][200].
* [cl-influxdb](https://github.com/mmaul/cl-influxdb/) - an interface to the Time Series [Database](/@harrisonqian/awesome/wiki/databases/database) [InfluxDB](/@harrisonqian/awesome/wiki/databases/influxdb). [MIT][200].
* [cl-remizmq](https://fossil.cyberia9.org/cl-remizmq/index) - ZeroMQ sockets, messages, timers, atomics, and proxies.
  * low-level and high-level APIs. Tested with libzmq 5.2.5, any v4.x and v5.x should work, v3.x may as well.
* [coalton-zmq](https://github.com/coalton-lang/coalton-zmq) - ZeroMQ interface for Coalton.
  - "It's complete enough to be useful for building [apps](/@harrisonqian/awesome/wiki/platforms/apps) that use ZeroMQ". Many of the official [ZeroMQ examples](https://github.com/coalton-lang/coalton-zmq/tree/main/zmq-examples) are implemented.

Tools
-----

* ⭐ [pgloader](https://github.com/dimitri/pgloader) - a data loading tool for [PostgreSQL](/@harrisonqian/awesome/wiki/databases/postgresql). [PostgreSQL Licence][205].
  * obligatory blog post: [Why is pgloader so much faster?](https://tapoueh.org/blog/2014/05/why-is-pgloader-so-much-faster/) (hint: it was re-written from [Python](/@harrisonqian/awesome/wiki/programming-languages/python) to Common Lisp)

Data Formats
============

CSV
---

* ⭐ [cl-csv](https://github.com/AccelerationNet/cl-csv) - A library for parsing CSV files. [3-clause BSD][15].
  * [documentation](https://github.com/AccelerationNet/cl-csv/blob/master/DOCUMENTATION.md)
  * [example blog post](https://dev.to/vindarel/read-csv-files-in-common-lisp-cl-csv-data-table-3c9n).
* [cl-decimals](https://github.com/tlikonen/cl-decimals) - Decimal number parser and formatter. Public domain.
* [auto-text](https://github.com/defunkydrummer/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.
* [csv-validator](https://github.com/KoenvdBerg/csv-validator) - Validates tabular CSV data using predefined validations, inspired from its [Python](/@harrisonqian/awesome/wiki/programming-languages/python) homologue "Great Expectations". [BSD_3Clause][15].

See also: cl-duckdb for fast parsing, [lisp-stat's data-frames `read-csv`](https://lisp-stat.dev/docs/manuals/data-frame/), [vellum-csv](https://github.com/sirherrbatka/vellum-csv/) (data frames library), vellum-duckdb.

JSON
----

* 👍 [jzon](https://github.com/Zulu-Inuoe/jzon/) - a correct, safe and fast [JSON](/@harrisonqian/awesome/wiki/miscellaneous/json) parser. [MIT][200].
  * jzon is the only CL [JSON](/@harrisonqian/awesome/wiki/miscellaneous/json) library which correctly declines all invalid inputs per the official JSON test suite and accepts all valid inputs per that suite.
  * it doesn't crash on invalid input (jsown), doesn't choke on large [datasets](/@harrisonqian/awesome/wiki/miscellaneous/datasets) (Jonathan), and more.
  * "I believe jzon to be the superior choice and hope for it to become the new, true de-facto library in the world of [JSON](/@harrisonqian/awesome/wiki/miscellaneous/json)-in-CL once and for all."
* [shasht](https://github.com/yitzchak/shasht) -  Common Lisp [JSON](/@harrisonqian/awesome/wiki/miscellaneous/json) reading and writing for the Kzinti. [MIT][14].
  - "Shasht is one of the two new libraries that I particularly like and is already in quicklisp. It is fast, it handles null correctly, it encodes CLOS objects, structures and hash-tables. It can also do incremental encoding." Sabra Crolleton.
* [cl-json](https://github.com/sharplispers/cl-json) - A highly customizable [JSON](/@harrisonqian/awesome/wiki/miscellaneous/json) encoder and decoder. [MIT][14].
  * "cl-[json](/@harrisonqian/awesome/wiki/miscellaneous/json) and yason are still the work horses if you need fine control, but speed is not their forte." @sabracrolleton
* [parcom/json](https://github.com/fosskers/parcom) - An extension to `parcom` for simple, fast, no-dependency [JSON](/@harrisonqian/awesome/wiki/miscellaneous/json) parsing.

See this [extensive comparison](https://sabracrolleton.github.io/json-review) of many more JSON libraries, as well as [these benchmarks](https://github.com/fosskers/parcom?tab=readme-ov-file#json-benchmarks).

JSON tools:

* [NJSON](https://github.com/atlas-engineer/njson) - Parser-agnostic [JSON](/@harrisonqian/awesome/wiki/miscellaneous/json) indexing (with JSON Pointer support), destructuring, and validation framework. [BSD][15].
* [json-mop](https://github.com/gschjetne/json-mop) - A metaclass for bridging CLOS and [JSON](/@harrisonqian/awesome/wiki/miscellaneous/json) objects. [MIT][200].
  * depends on YASON
  * for [JSON](/@harrisonqian/awesome/wiki/miscellaneous/json) libraries that don't do it natively (jzon, shasht and cl-json are able to *encode* CLOS objects to JSON out of the box, and cl-json has the ability to *decode* JSON objects into a "fluid-class" CLOS object.)

---
*truncated — [full list on GitHub](https://github.com/CodyReichert/awesome-cl)*