The purpose of this library is to provide a collection of implementations of trees.

In contrast to existing libraries such as cl-containers, it does not impose a particular use for the trees. Instead, it aims for a stratified design, allowing client code to choose between different levels of abstraction.

As a consequence of this policy, low-level interfaces are provided where the concrete representation is exposed, but also high level interfaces where the trees can be used as search trees or as trees that represent sequences of objects.

Markup allows the use of HTML syntax with in Common Lisp code. This has the advantage of being able to copy HTML snippets and have them instantly be functional, less double quotes than a s-expression approach, and designers will be able to understand the embedded HTML.

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.

ASDF-FLV provides support for file-local variables through ASDF. A file-local variable behaves like *PACKAGE* and *READTABLE* with respect to LOAD and COMPILE-FILE: a new dynamic binding is created before processing the file, so that any modification to the variable becomes essentially file-local.

In order to make one or several variables file-local, use the macros SET-FILE-LOCAL-VARIABLE(S).

Anaphora is the anaphoric macro collection from Hell: it includes many new fiends in addition to old friends like aif and awhen.

This package provides an embedded template engine for Common Lisp.

This is a Gettext-style internationalisation framework for Common Lisp.

The server part of AllegroServe can be used either as a standalone web server or a module loaded into an application to provide a user interface to the application. AllegroServe's proxy ability allows it to run on the gateway machine between some internal network and the Internet. AllegroServe's client functions allow Lisp programs to explore the web.

This library is a collection of utilities for writing compiler macros. It is intended to make it possible to make compiler macros much more useful, by granting them access to lexical type information, making the protocol for declining expansion more convenient, and establishing some information for signaling optimization advice to programmers. Some utilities to support this, especially for reasoning on types, are also included.

This package provides a pure-lisp implementation of a DNS client. It can be used to resolve hostnames, reverse-lookup IP addresses, and fetch other kinds of DNS records.

This library provides the FORMGREP function and related utilities which find top-level Lisp forms matching the regular expression corresponding to an operator name, returning the matched forms and the names of the files and the line numbers where they were found.

This package provides a KDL reader/writer for Common Lisp.

cl-tar-file is a Common Lisp library that allows reading from and writing to various tar archive formats. Currently supported are the POSIX ustar, PAX (ustar with a few new entry types), GNU, and v7 (very old) formats.

This library is rather low level and is focused exclusively on reading and writing physical tar file entries using streams. Therefore, it contains no functionality for automatically building archives from a set of files on the filesystem or writing the contents of a file to the filesystem. Additionally, there are no smarts that read multiple physical entries and combine them into a single logical entry (e.g., with PAX extended headers or GNU long link/path name support). For a higher-level library that reads and writes logical entries, and also includes filesystem integration, see cl-tar.

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.

Filtered functions provide an extension of CLOS generic function invocation that add a simple preprocessing step before the actual method dispatch is performed and thus enable the use of arbitrary predicates for selecting and applying methods. See http://www.p-cos.net/documents/filtered-dispatch.pdf for a paper that introduces and explains filtered functions in detail.

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

cl-webkit is a binding to WebKitGTK+ for Common Lisp, currently targeting WebKit version 2. The WebKitGTK+ library adds web browsing capabilities to an application, leveraging the full power of the WebKit browsing engine.

Parseq (pronounced parsec) is a parsing library for common lisp. It can be used for parsing lisp's sequences types: strings, vectors (e.g. binary data) and lists. Furthermore, parseq is able to parse nested structures such as trees (e.g. lists of lists, lists of vectors, vectors of strings).

Parseq uses parsing expression grammars (PEG) that can be defined through a simple interface. Extensions to the standard parsing expressions are available. Parsing expressions can be parameterised and made context aware. Additionally, the definition of each parsing expression allows the arbitrary transformation of the parsing tree.

The library is inspired by Esrap and uses a very similar interface. No code is shared between the two projects, however. The features of Esrap are are mostly included in parseq and complemented with additional, orthogonal features. Any resemblance to esrap-liquid is merely coincidental.

This is a library for quaternions. It contains most of the quaternion operations one would usually expect out of such a library and offers them both in non-modifying and modifying versions where applicable. It also tries to be efficient where plausible. Each quaternion is made up of floats, which by default are single-floats, as they do not require value boxing on most modern systems and compilers.

This project is meant to provide tools for internationalizing Common Lisp programs.

One important aspect of internationalization is of course the language used in error messages, documentation strings, etc. But with this project we provide tools for all other aspects of internationalization as well, including dates, weight, temperature, names of physical quantities, etc.

This library provides Glib, GIO and Gobject bindings for Common Lisp via Gobject Introspection.

This library implements the let+ macro, which is a dectructuring extension of let*. It features:

• Clean, consistent syntax and small implementation (less than 300 LOC, not counting tests)

• Placeholder macros allow editor hints and syntax highlighting

• &ign for ignored values (in forms where that makes sense)

• Very easy to extend

Eager Future2 is a Common Lisp library that provides composable concurrency primitives that unify parallel and lazy evaluation, are integrated with the Common Lisp condition system, and have automatic resource management.

This is a Common Lisp library providing functions to read/write CSV from/to strings, streams and files.