Alexandria is a collection of portable utilities. It does not contain conceptual extensions to Common Lisp. It is conservative in scope, and portable between implementations.

This Common Lisp library implements object prevalence (see https://en.wikipedia.org/wiki/System_prevalence). It allows for (de)serializing to and from s-exps as well as XML. Serialization of arbitrary classes and cyclic data structures are supported.

This package provides Common Lisp CFFI bindings to the Raylib game development library.

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

This package provides CFFI bindings for Common Lisp to the Cairo C library.

This library can be used to print the licenses used by a Common Lisp project and its dependencies.

cl-jpl-util is a collection of Common Lisp utility functions and macros, primarily for software projects written in CL by the author.

Library to fuzzily parse time and date strings into a universal-time timestamp.

Ironclad is a cryptography library written entirely in Common Lisp. It includes support for several popular ciphers, digests, MACs and public key cryptography algorithms. For several implementations that support Gray streams, support is included for convenient stream wrappers.

Smart-buffer provides an output buffer which changes the destination depending on content size.

defclass-star provides defclass* and defcondition* to simplify class and condition declarations. Features include:

• Automatically export all or select slots at compile time.

• Define the :initarg and :accessor automatically.

• Specify a name transformer for both the :initarg and :accessor, etc.

• Specify the :initform as second slot value.

See https://common-lisp.net/project/defclass-star/configuration.lisp.html for an example.

Fully auto-generated Common Lisp bindings to Raylib and Raygui.

This package contains an implementation of RFC 2388, which is used to process form data posted with HTTP POST method using enctype "multipart/form-data".

Alloy is a user interface toolkit. It is defined through a set of protocols that allow for a clear interface, as well as a standardised way to integrate Alloy into a target backend.

This is a Common Lisp bindings library to libfond, a simple OpenGL text rendering engine.

This Common Lisp library implements the quoted-printable encoding as described in RFC 2045 (see http://tools.ietf.org/html/rfc2045).

3D-VECTORS is a library for vector math in 3D space. It contains most of the vector operations one would usually expect out of such a library and offers them both in non-modifying and modifying versions where applicable.

jsown is a high performance Common Lisp JSON parser. Its aim is to allow for the fast parsing of JSON objects in Common Lisp. Recently, functions and macros have been added to ease the burden of writing and editing jsown objects.

jsown allows you to parse JSON objects quickly to a modifiable Lisp list and write them back. If you only need partial retrieval of objects, jsown allows you to select the keys which you would like to see parsed. jsown also has a JSON writer and some helper methods to alter the JSON objects themselves.

This package provides an ANSI CL adaptation of the SBCL mailbox utility.

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

Common Lisp ships with a set of powerful built in data structures including the venerable list, full featured arrays, and hash-tables. CL-containers enhances and builds on these structures by adding containers that are not available in native Lisp (for example: binary search trees, red-black trees, sparse arrays and so on), and by providing a standard interface so that they are simpler to use and so that changing design decisions becomes significantly easier.

This package provides a flexible shallow/deep copy mechanism for Common Lisp.

string-case is a Common Lisp macro that generates specialised decision trees to dispatch on string equality.

This package provides a portability layer for the extensible sequences standard extension to Common Lisp. Extensible sequences allow you to create your own sequence types that integrate with the rest of the functions and operations that interact with sequences.