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.

Common Lisp already has major 2 namespaces, function namespace and value namespace (or variable namespace), but there are actually more — e.g., class namespace. This library offers macros to deal with symbols from any namespace.

Additional dolist style macros for Common Lisp, such as doalist, dohash, dolist*, doplist, doseq and doseq*.

This library tries to provide a way to detect what kind of type the given predicate is trying to check. This is different from inferring the return type of a function.

FXML is a secure-by-default, error-recovering XML parser and serializer. It is a fork of CXML.

You should use FXML instead of CXML if:

• You are parsing potentially ill-formed XML.

• You are parsing potentially malicious XML.

• You need to use Klacks with namespaces.

FXML’s API is very close to CXML's, and for the most part you can refer to the CXML documentation for usage.

This package provides a functionality augmenting Hunchentoot error pages and logs with request and session information.

This library allows macro writers to provide better feedback to macro users when errors are signaled during macroexpansion. It uses the compiler's concept of a source-form to report where the error or warning is located.

ALEXA is a tool similar to lex or flex for generating lexical analyzers. Unlike tools like lex, however, ALEXA defines a domain-specific language within your Lisp program, so you don't need to invoke a separate tool.

This is a binding to the libyaml library. It's not meant as a full library for YAML, just a bare binding with a couple of utility macros. For a YAML parser and emitter using this, check out cl-yaml.

This package provides a CONSPACK implementation for Common Lisp.

This package provides a simple yet powerful value inheritance scheme.

A Common Lisp library implementing a few different kinds of queues:

• Bounded and unbounded FIFO queues.

• Lossy bounded FIFO queues that drop elements when full.

• Unbounded random-order queues that use less memory than unbounded FIFO queues.

Additionally, a synchronization wrapper is provided to make any queue conforming to the jpl-queues API thread-safe for lightweight multithreading applications. (See Calispel for a more sophisticated CL multithreaded message-passing library with timeouts and alternation among several blockable channels.)

Schemeish implements several useful Scheme constructs for Common Lisp. These include named-let, define, scheme argument lists, and a shortcut to FUNCALL with [] instead of ().

A heap-based priority queue whose first and foremost priority is speed.

This package provides CFFI bindings and interface to Allegro 5 game developing library for Common Lisp.

This is a library to find system font files. It works on systems with FontConfig on Linux, BSD. It does not have any foreign dependencies that aren't already directly available on the system.

cl-strings is a small, portable, dependency-free set of utilities that make it even easier to manipulate text in Common Lisp. It has 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.

cl-css-lite is a library for generating CSS from an s-exp based syntax. When compiled with Parenscript loaded in the Lisp image, it also provides the same CSS generation facilities in Parenscript-generated JavaScript code.

lparallel is a library for parallel programming in Common Lisp, featuring:

• a simple model of task submission with receiving queue,

• constructs for expressing fine-grained parallelism,

• asynchronous condition handling across thread boundaries,

• parallel versions of map, reduce, sort, remove, and many others,

• promises, futures, and delayed evaluation constructs,

• computation trees for parallelizing interconnected tasks,

• bounded and unbounded FIFO queues,

• high and low priority tasks,

• task killing by category,

• integrated timeouts.

(X)HTMLambda is yet another (X)HTML library which emphasizes programmability and user-friendliness. Each (X)HTML element is a structured object and pretty-printing of (X)HTML trees is well defined to provide properly indented human-readable output even for complex recursive arrangements.

This package provides a SuperCollider client for Common Lisp.

CL-FTP is a library which provides FTP client functionality to a Common Lisp program. CL-FTP uses the USOCKET package for network sockets and the SPLIT-SEQUENCE package for some parsing needs.

Radiance is a web application environment, which is sort of like a web framework, but more general, more flexible. It should let you write personal websites and generally deployable applications easily and in such a way that they can be used on practically any setup without having to undergo special adaptations.

This is a client library to interact with the "mod.io" (https://mod.io) platform to manage "mods" or extensions for games and other applications. It covers the full v1 API and includes convenience methods to make interacting with the API as well as syncing mods and so on easy.