This library allows creation of hash tables with arbitrary test/hash functions, in addition to the test functions allowed by the standard (EQ, EQL, EQUAL and EQUALP), even in implementations that don't support this functionality directly.

This is a lightweight, non-consing, optimized queue implementation for Common Lisp.

This package provide a Common Lisp library for .zip-file reading and writing.

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.

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.

This package extends the Common Lisp reader syntax such that is accepts Org files as Lisp source code files.

This package provides a Common Lisp translation library similar to CL-I18N and CL-L10N.

CL-STRFTIME is a Common Lisp compiler for the strftime “language.”

cl-annot is an general annotation library for Common Lisp.

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.

Trial is a game engine written in Common Lisp. Unlike many other engines, it is meant to be more of a loose connection of components that can be fit together as required by any particular game.

This package parses and prints dates in RFC-1123 format.

Calispel is a Common Lisp library for thread-safe message-passing channels, in the style of the occam programming language, also known as communicating sequential processes (CSP). See https://en.wikipedia.org/wiki/Communicating_sequential_processes.

Calispel channels let one thread communicate with another, facilitating unidirectional communication of any Lisp object. Channels may be unbuffered, where a sender waits for a receiver (or vice versa) before either operation can continue, or channels may be buffered with flexible policy options.

Because sending and receiving on a channel may block, either operation can time out after a specified amount of time.

A syntax for alternation is provided (like ALT in occam, or Unix select()): given a sequence of operations, any or all of which may block, alternation selects the first operation that doesn't block and executes associated code. Alternation can also time out, executing an "otherwise" clause if no operation becomes available within a set amount of time.

Calispel is a message-passing library, and as such leaves the role of threading abstractions and utilities left to be filled by complementary libraries such as Bordeaux-Threads and Eager Future.

clsql is a Common Lisp interface to SQL RDBMS based on the Xanalys CommonSQL interface for Lispworks. It provides low-level database interfaces as well as a functional and an object oriented interface.

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

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 ().

FLOW is a flowchart graph library. Unlike other graphing libraries, this one focuses on nodes in a graph having distinct ports through which connections to other nodes are formed. This helps in many concrete scenarios where it is important to distinguish not only which nodes are connected, but also how they are connected to each other.

Particularly, a lot of data flow and exchange problems can be reduced to such a flowchart. For example, an audio processing library may present its pipeline as a flowchart of segments that communicate with each other through audio sample buffers. Flow gives a convenient view onto this kind of problem, and even allows the generic visualisation of graphs in this format.

This package provides a Common Lisp implementation of Google Closure Templates.

Porter Stemming Algorithm.

In Common Lisp, a special variable that is never dynamically bound typically serves as a stand-in for a global variable. The global-vars library provides true global variables that are implemented by some compilers. An attempt to rebind a global variable properly results in a compiler error. That is, a global variable cannot be dynamically bound.

Global variables therefore allow us to communicate an intended usage that differs from special variables. Global variables are also more efficient than special variables, especially in the presence of threads.

This package provides a configuration library that adds the ability for Lem to manage packages within the user configuration directory.

Just wrap your Common Lisp function in this macro call and it will be optimized for tail recursion. You will be warned if the function is not tail recursive.

Birch is a simple Common Lisp IRC client library. It makes use of CLOS for event handling.

This Common Lisp library provides a simple FIFO implementation with no external dependencies.