Confidence is a test framework for Common Lisp that focuses on simplicity. It avoids bureaucracy and makes it easy to work interactively, without a complicated setup, and with explicit functions and decisions.

The Lisp Critic scans your code for instances of bad Lisp programming practice.

KAPUTT is a test framework for Common Lisp that focuses on the following features:

• KAPUTT is simple, it only defines three abstractions testcase, assertion and protocol and does not add any artefact on the backtrace when errors occur.

• KAPUTT is extensible, it is possible to add problem-specific assertions to make test code more informative.

• KAPUTT fits well interactive development.

This is a small testing framework for Common Lisp. The entire API consists of: test, is, signals, finishes, run, suite and setf suite.

Rove is a unit testing framework for Common Lisp applications. This is intended to be a successor of Prove.

Confidence is a test framework for Common Lisp that focuses on simplicity. It avoids bureaucracy and makes it easy to work interactively, without a complicated setup, and with explicit functions and decisions.

Stefil is a simple test framework for Common Lisp, with a focus on interactive development.

This is a small testing framework for Common Lisp. The entire API consists of: test, is, signals, finishes, run, suite and setf suite.

Try is a library for unit testing with equal support for interactive and non-interactive workflows. Tests are functions, and almost everything else is a condition, whose types feature prominently in parameterization.

This is a small testing framework for Common Lisp. The entire API consists of: test, is, signals, finishes, run, suite and setf suite.

lparallel is a library for parallel programming in Common Lisp, featuring:

• a simple model of task submission with receiving queue,

• constructs for expressing fine-grained parallelism,

• asynchronous condition handling across thread boundaries,

• parallel versions of map, reduce, sort, remove, and many others,

• promises, futures, and delayed evaluation constructs,

• computation trees for parallelizing interconnected tasks,

• bounded and unbounded FIFO queues,

• high and low priority tasks,

• task killing by category,

• integrated timeouts.

lQuery is a DOM manipulation library written in Common Lisp, inspired by and based on the jQuery syntax and functions. It uses Plump and CLSS as DOM and selector engines. The main idea behind lQuery is to provide a simple interface for crawling and modifying HTML sites, as well as to allow for an alternative approach to templating.

This is a minimalistic parser of command line options. The main advantage of the library is the ability to concisely define command line options once and then use this definition for parsing and extraction of command line arguments, as well as printing description of command line options (you get --help for free). This way you don't need to repeat yourself. Also, unix-opts doesn't depend on anything and precisely controls the behavior of the parser via Common Lisp restarts.

Fast-io is about improving performance to octet-vectors and octet streams (though primarily the former, while wrapping the latter).

cl-draw-cons-tree draws a cons tree in ASCII-art style.

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

This is a native Common Lisp graphics math library with an emphasis on performance and correctness.

This library provides all of

• ad hoc polymorphism and

• subtype polymorphism

• parametric polymorphism (in a very limited sense)

to dispatch on the basis of types rather than classes.

Parse-js is a Common Lisp package for parsing JavaScript (ECMAScript 3). It has basic support for ECMAScript 5.

This package provides a Common Lisp library for defining OpenGL shader programs. There are also functions for referencing shader programs by name, querying for basic information about them, modifying uniform variables throughout the lifecycle of an OpenGL application, and managing certain OpenGL buffer object types (UBO, SSBO currently).

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 is a Common Lisp autowrapping facility for quickly creating clean and lean bindings to C libraries.

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

EXTERNAL-PROGRAM enables running programs outside the Lisp process. It is an attempt to make the RUN-PROGRAM functionality in implementations like SBCL and CCL as portable as possible without sacrificing much in the way of power.