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

This package provides functions to encode or decode byte vectors or byte streams using the Z85 format, which is a base-85 encoding used by ZeroMQ.

Periods is a Common Lisp library providing a set of utilities for manipulating times, distances between times, and both contiguous and discontiguous ranges of time.

UCONS is a Common Lisp library providing unique conses. Unique conses are different from regular conses in that, in addition to their car and cdr, they maintain a table of past users. Also, the cdr of each ucons is restricted to other uconses or nil. Uconses are meant for those situations where even reusing regular conses (to avoid consing) is too computationally expensive.

Cluffer is a library for representing the buffer of a text editor. As such, it defines a set of CLOS protocols for client code to interact with the buffer contents in various ways, and it supplies different implementations of those protocols for different purposes.

The cl-sqlite package is an interface to the SQLite embedded relational database engine.

trivial-clipboard gives access to the system clipboard.

This package provides an enhanced version of typep that is exactly like the one in the Lisp spec, except it can also accept a single type argument, in which case it returns the appropriate closure.

Support library for numcl that provides Julia-like runtime parametric type correctness in Common Lisp. It is based on CLtL2 extensions.

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

NFiles is a Common Lisp library to help manage file persistence and loading, in particular user-centric files like configuration files. It boasts the following features:

• Dynamic and customizable path expansion.

• Extensible serialization and deserialization.

• Cached reads and writes. When a file object expands to the same path as another one, a read or write on it won’t do anything in case there was no change since last write.

• (Experimental!) On-the-fly PGP encryption.

• Profile support.

• On read error, existing files are backed up.

• On write error, no file is written to disk, the existing file is preserved.

Supertrace provides a superior Common Lisp trace functionality for debugging and profiling real world applications.

This library validates superclasses according to a simple substitution model, thereby greatly simplifying the definition of class mixins.

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

DEFPACKAGE-PLUS is an extensible DEFPACKAGE variant with predictable cross-platform behavior and some utilities useful for versioning.

A hook, in the present context, is a certain kind of extension point in a program that allows interleaving the execution of arbitrary code with the execution of a the program without introducing any coupling between the two. Hooks are used extensively in the extensible editor Emacs.

In the Common LISP Object System (CLOS), a similar kind of extensibility is possible using the flexible multi-method dispatch mechanism. It may even seem that the concept of hooks does not provide any benefits over the possibilities of CLOS. However, there are some differences:

• There can be only one method for each combination of specializers and qualifiers. As a result this kind of extension point cannot be used by multiple extensions independently.

• Removing code previously attached via a :before, :after or :around method can be cumbersome.

• There could be other or even multiple extension points besides :before and :after in a single method.

• Attaching codes to individual objects using eql specializers can be cumbersome.

• Introspection of code attached a particular extension point is cumbersome since this requires enumerating and inspecting the methods of a generic function.

This library tries to complement some of these weaknesses of method-based extension-points via the concept of hooks.

This package provides CFFI bindings for the stb_vorbis audio library to Common Lisp.

When dealing with network protocols and file formats, it's common to have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned flavors. Common Lisp sort of supports this by specifying :element-type for streams, but that facility is underspecified and there's nothing similar for read/write from octet vectors. What most people wind up doing is rolling their own small facility for their particular needs and calling it a day.

This library attempts to be comprehensive and centralize such facilities. Functions to read 16-, 32-, and 64-bit quantities from octet vectors in signed or unsigned flavors are provided; these functions are also SETFable. Since it's sometimes desirable to read/write directly from streams, functions for doing so are also provided. On some implementations, reading/writing IEEE singles/doubles (i.e. single-float and double-float) will also be supported.

The 3D-Spaces library implements a number of spatial query data structures; structures that can answer spatial range queries for optimized lookup, particularly suited for games.

This package provides a simple yet powerful value inheritance scheme.

This is a c2ffi-based wrapper generator for Common Lisp.

Cl-tga was written to facilitate loading .tga files into OpenGL programs. It's a very simple library, and, at the moment, only supports non-RLE encoded forms of the files.

CLSS is a DOM traversal engine based on CSS selectors. It makes use of the Plump-DOM and is used by lQuery.

One of the many things that didn't quite get into the Common Lisp standard was how to get a Lisp to output its call stack when something has gone wrong. As such, each Lisp has developed its own notion of what to display, how to display it, and what sort of arguments can be used to customize it. trivial-backtrace is a simple solution to generating a backtrace portably.