This is a Common Lisp kernel for Jupyter along with a library for building Jupyter kernels, based on Maxima-Jupyter which was based on cl-jupyter.

Html-entities is a Common Lisp library that lets you encode and decode entities in HTML.

Dexador is yet another HTTP client for Common Lisp with neat APIs and connection-pooling. It is meant to supersede Drakma.

A CLOS class that defines callable objects whose behavior is similar to closures but adds conveniences such as introspectability.

Common Lisp comes with quite some functions to compare objects for equality, yet none is applicable in every situation and in general this is hard, as equality of objects depends on the semantics of operations on them. As consequence, users find themselves regularly in a situation where they have to roll their own specialized equality test.

This module provides one of many possible equivalence relations between standard Common Lisp objects. However, it can be extended for new objects through a simple CLOS protocol. The rules when two objects are considered equivalent distinguish between mutating and frozen objects. A frozen object is promised not to be mutated in the future in a way that operations on it can notice the difference.

We have chosen to compare mutating objects only for identity (pointer equality), to avoid various problems. Equivalence for frozen objects on the other hand is established by recursing on the objects' constituent parts and checking their equivalence. Hence, two objects are equivalent under the OBJECT= relation, if they are either identical, or if they are frozen and structurally equivalent, i.e. their constituents are point-wise equivalent.

Since many objects are potentially mutable, but are not necessarily mutated from a certain point in their life time on, it is possible to promise to the equivalence relation that they remain frozen for the rest of their life time, thus enabling coarser equivalence than the often too fine-grained pointer equality.

This project is intended as a catchall for small, general-purpose extensions to Common Lisp. It contains:

• new-let, a macro that combines and generalizes let, let* and multiple-value-bind,

• gmap, an iteration macro that generalizes map.

This is a small Common Lisp library to make slugs, mainly for URIs, from English and beyond.

This library allows you to open native file dialogs to open and save files. This is useful if you have an application that's primarily text based and would like a more convenient file selection utility, or if you are working with a UI toolkit that does not offer a way to access the native file dialogs directly.

Magic (ed) is a tiny editing facility for Common Lisp, where you can directly load, edit, manipulate and evaluate file or file content from REPL. This package also can be a starting point for people who are not accustomed to Emacs or SLIME and would like to continue using their default terminal/console editor with Common Lisp.

This is a Common Lisp library to make histograms using UTF-8 block characters.

This library provides GTK4 bindings for Common Lisp via Gobject Introspection, in the cl-gtk4 ASDF system.

This package provides a PEM (Privacy-Enhanced Mail) parser for Common Lisp.

This library strives to provide a portable TCP/IP and UDP/IP socket interface for as many Common Lisp implementations as possible, while keeping the abstraction and portability layer as thin as possible.

The canonical way to determine the size of a file in bytes, using Common Lisp, is to open the file with an element type of (unsigned-byte 8) and then calculate the length of the stream. This is less than ideal. In most cases it is better to get the size of the file from its metadata, using a system call.

This library exports a single function, file-size-in-octets. It returns the size of a file in bytes, using system calls when possible.

Zippy is a library for the PKWARE Zip archive format. It can read and write zip files. It features:

• archive inspection without extraction;

• Zip64 support;

• split archive support;

• PKWARE decryption;

• fast deflate decompression thanks to 3bz;

• operates on streams and vectors;

• can compress stream->stream;

• extensible for other encryption and compression mechanisms.

Common Lisp library for channel-based concurrency. In a nutshell, you create various threads sequentially executing tasks you need done, and use channel objects to communicate and synchronize the state of these threads.

This package implements an algorithm for the spelling of enharmonics and dealing with ties and dots in rhythm notation.

It's very basic implementation of channels and queue for Common Lisp.

This library provides Glib, GIO and Gobject bindings for Common Lisp via Gobject Introspection.

Dynamic-mixins is for simple, dynamic class combination; it allows objects to be mixed and updated without manually defining many permutations.

This is an interface to the git binary to make controlling it from within Common Lisp much easier. It might not ever reach full coverage of all features given git's immense size, but features will be added as they are needed. The low-level command API is fully mapped however.

The Plump-SEXP library is a backend for Plump which can convert between S-expressions and the Plump DOM.

This is a Common Lisp implementation of the Encoding for Robust Immutable Storage specification (ERIS).

exit-hooks provides a portable way to automatically call some user-defined function when exiting Common Lisp (both quit from the REPL or a kill in a shell). Like atexit in C and Python or Java’s Runtime.addShutdownHook(). It currently supports SBCL, CCL, ECL, ABCL, Allegro CL, clisp and CMUCL. Before exit-hooks, there was no portable way of doing so and no staightforward way to use an exit hook on ABCL. It can be used for tasks like parmenantly save something when exiting Lisp.