This library is intended to solve the problem of source tracking for Common Lisp code.

By "source tracking", it is meant that code elements that have a known origin in the form of a position in a file or in an editor buffer are associated with some kind of information about this origin.

Since the exact nature of such origin information depends on the Common Lisp implementation and the purpose of wanting to track that origin, the library does not impose a particular structure of this information. Instead, it provides utilities for manipulating source code in the form of what is called concrete syntax trees (CSTs for short) that preserve this information about the origin.

Clip is an attempt at a templating library that allows you to write templates in a way that is both accessible to direct webdesign and flexible. The main idea is to incorporate transformation commands into an HTML file through tags and attributes. Clip is heavily dependent on Plump and lQuery.

CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.

CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used by AT&T Yacc, Berkeley Yacc and Zebu. It does not use the faster algorithm due to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).

Stealth-mixin is a Common Lisp library for creating stealth mixin classes. These are classes that are dynamically mixed into other classes without the latter being aware of it.

This library is an implementation of the XML Path Language (XPath) Version 1.0.

NASDF is an ASDF extension providing utilities to ease system setup, testing and installation.

• Simple way to fetch Git submodules and “do the right thing” for setup. This may effectively supersede Quicklisp. A benefit of using Git submodules over the default Quicklisp distribution is improved reproducibility.

• Test helpers, like distinction between offline and online tests, or continuous integration options, and warning reports.

• Installation helpers, for instance to install libraries, icons and desktop files to the right directories.

This is a task scheduling framework for Common Lisp.

Trivial-Benchmark runs a block of code many times and outputs some statistical data for it. On SBCL this includes the data from time, for all other implementations just the real-time and run-time data. However, you can extend the system by adding your own metrics to it, or even by adding additional statistical computeations.

This package provides a function to parse the PATH environment variable portably in Common Lisp.

Clamp is an attempt to bring the powerful, but verbose, language of Common Lisp up to the terseness of Arc.

There are two parts to Clamp. There is the core of Clamp, which implements the utilities of Arc that are easily converted from Arc to Common Lisp. The other part is the "experimental" part. It contains features of Arc that are not so easy to copy (ssyntax, argument destructuring, etc.).

This library implements the -> and ->> macros from Clojure, as well as several expansions on the idea.

This is an optimized Common Lisp library of Bob Jenkins' ISAAC-32 and ISAAC-64 algorithms, which are fast cryptographic random number generators: Indirection, Shift, Accumulate, Add, and Count.

cl-draw-cons-tree draws a cons tree in ASCII-art style.

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.

fare-utils is a small collection of utilities. It contains a lot of basic everyday functions and macros.

Skippy is a Common Lisp library to read and write GIF image files.

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 library implements a basic promise datastructure, which is useful for dealing with asynchronous behaviours. Importantly, this library does not use any other libraries or frameworks, and instead leaves the execution and state transition of promise objects in your control, making it easy to integrate.

This is a portability library that allows one to fully override the standard debugger provided by their Common Lisp system for situations where binding *debugger-hook* is not enough -- most notably, for break.

This is a small library to help you with managing the Common Lisp docstrings for your library.

This is a Common Lisp package for hash table creation with flexible, extensible initializers.

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.

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.

This library provides a drop-in replacement function for cl:documentation that supports multiple docstrings per-language, allowing you to write documentation that can be internationalised.