This is a Common Lisp wrapper for interacting with the Redis data structure store.

This package implements binary trees of various kinds, presenting a uniform interface to them all.

This library defines a way of treating Common Lisp packages as conduits which can sit between one or more implementation packages and users of those packages.

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.

This is a teensy library that provides some functions to determine the mime-type of a file.

RTG-MATH provides a selection of the math routines most commonly needed for making realtime graphics in Lisp.

Clack is a web application environment for Common Lisp inspired by Python's WSGI and Ruby's Rack.

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

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 data structure can be used to store the history of visited paths or URLs with a file or web browser, in a way that no “forward” element is ever forgotten.

The history tree is “global” in the sense that multiple owners (e.g. tabs) can have overlapping histories. On top of that, an owner can spawn another one, starting from one of its nodes (typically when you open a URL in a new tab).

The Common Foreign Function Interface (CFFI) purports to be a portable foreign function interface for Common Lisp. The CFFI library is composed of a Lisp-implementation-specific backend in the CFFI-SYS package, and a portable frontend in the CFFI package.

cl-template is a template engine for Common Lisp, taking inspiration from Ruby's ERb module.

This package provides a Common Lisp templating system based on Python Django with a syntax similar to Python Jinja2.

This package provides a way of extracting and replicating the compile-time side-effects of forms.

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

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.

PARSE is a simple token parsing library for Common Lisp.

This is a Common Lisp library to enable simple message pipelines.

This package provides a set of bindings and utilities for accessing the OpenGL (Mesa), GLU and GLUT (FreeGLUT) APIs using CFFI.

An implementation of the exponential backoff algorithm in Common Lisp. Inspired by the implementation found in Chromium. Read the header file to learn about each of the parameters.

This package provides an example implementation of the Common Lisp condition system and library, based on the original condition system implementation by Kent M. Pitman.

CLAWK is an AWK implementation embedded into Common Lisp.

This package provides a library for parsing MIME types, in the spirit of http://code.google.com/p/mimeparse/, with a Common Lisp flavor.

TRIVIAL-OCTET-STREAMS is a Common Lisp library implementing in-memory octet streams analogous to string streams.