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 package provides an enhanced EVAL-WHEN macro that supports a shorthand for (eval-when (:compile-toplevel :load-toplevel :execute) ...), addressing concerns about verbosity.

Parse-Declarations is a Common Lisp library to help writing macros which establish bindings. To be semantically correct, such macros must take user declarations into account, as these may affect the bindings they establish. Yet the ANSI standard of Common Lisp does not provide any operators to work with declarations in a convenient, high-level way. This library provides such operators.

ALEXA is a tool similar to lex or flex for generating lexical analyzers. Unlike tools like lex, however, ALEXA defines a domain-specific language within your Lisp program, so you don't need to invoke a separate tool.

zsort is a collection of portable sorting algorithms. Common Lisp provides the sort and stable-sort functions but these can have different algorithms implemented according to each implementation. Also, the standard sorting functions might not be the best for a certain situations. This library aims to provide developers with more options.

This package provides data frames for Common Lisp, a two-dimensional array-like structure in which each column contains values of one variable and each row contains one set of values from each column.

This library is a small interface to portable but nonstandard introspection of Common Lisp environments. It is intended to allow a bit more compile-time introspection of environments in Common Lisp.

Quite a bit of information is available at the time a macro or compiler-macro runs; inlining info, type declarations, that sort of thing. This information is all standard - any Common Lisp program can (declare (integer x)) and such.

This info ought to be accessible through the standard &environment parameters, but it is not. Several implementations keep the information for their own purposes but do not make it available to user programs, because there is no standard mechanism to do so.

This library uses implementation-specific hooks to make information available to users. This is currently supported on SBCL, CCL, and CMUCL. Other implementations have implementations of the functions that do as much as they can and/or provide reasonable defaults.

This package provides Common Lisp system collecting tools written to wrangle OpenGL Shader Language (GLSL) source files.

This package provides a Common Lisp system with a collection of common tests and operations to help handling pathnames. It does not actually deal in handling the accessing of files on the underlying system however.

HARMONY is a library that provides you with audio processing tools as well as an audio server to play back music, sfx, and so forth. It is most suited for use in a game engine, but may feasibly also be used for more advanced things such as a DAW

CLOBBER is an alternative to so-called object prevalence, and in particular to cl-prevalence. Clobber is both simpler, more flexible, and more robust than systems based on object prevalence.

XSubseq provides functions to be able to handle "subseq"s more effieiently.

Inquisitor is a cross-implementation library providing encoding/end-of-line detection and external-format abstraction for Common Lisp.

Collections of accessor functions and patterns to access the elements in compound type specifier, e.g. dimensions in (array element-type dimensions)

ALEXA is a tool similar to lex or flex for generating lexical analyzers. Unlike tools like lex, however, ALEXA defines a domain-specific language within your Lisp program, so you don't need to invoke a separate tool.

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 contains a few utility functions from the LispWorks library that are used in software such as ContextL.

defclass-star provides defclass* and defcondition* to simplify class and condition declarations. Features include:

• Automatically export all or select slots at compile time.

• Define the :initarg and :accessor automatically.

• Specify a name transformer for both the :initarg and :accessor, etc.

• Specify the :initform as second slot value.

See https://common-lisp.net/project/defclass-star/configuration.lisp.html for an example.

EASY-ROUTES is yet another routes handling system on top of Hunchentoot. It's just glue code for Restas routing subsystem (CL-ROUTES).

It supports:

• dispatch based on HTTP method

• arguments extraction from the url path

• decorators

• URL generation from route names

This package provides EASY-ROUTES, EASY-ROUTES+DJULA and EASY-ROUTES+ERRORS systems.

This is a very short and simple program, written in Common Lisp, that extends Common Lisp to embed shell code in a manner similar to Perl's backtick. It has been forked from SHELISP.

This Common Lisp library provides a tiny utility to change the size of a simple-array ensuring that the resulting array is still a simple-array.

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.

FLARE is a library designed to allow quick and precise particle effect creations. It does not concern itself with displaying and only with the management and movement of particles. As such, it can easily be integrated into any existing or future application.

This is a (currently) brief but usable wrap for SDL2_image.