Montezuma is a text search engine library for Lisp based on the Ferret library for Ruby, which is itself based on the Lucene library for Java.

This is a Common Lisp library to read and write disk-based file archives such as those generated by the tar and cpio programs on Unix.

This package provides Common Lisp FFI bindings for libwayland, primarily for the mahogany window manager.

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

This package provides Python style generators for Common Lisp. It also includes a port of itertools.

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.

DATA-SIFT is a Common Lisp data validation and transformation library inspired by cl-data-format-validation and WTForms validators.

Trivia is a pattern matching compiler that is compatible with Optima, another pattern matching library for Common Lisp. It is meant to be faster and more extensible than Optima.

This is a trivial utility for distinguishing between a process running in a real terminal window and a process running in a dumb one, e.g. emacs-slime.

Clamp is an attempt to bring the powerful, but verbose, language of Common Lisp up to the terseness of Arc.

There are two parts to Clamp. There is the core of Clamp, which implements the utilities of Arc that are easily converted from Arc to Common Lisp. The other part is the "experimental" part. It contains features of Arc that are not so easy to copy (ssyntax, argument destructuring, etc.).

This package provides a Common Lisp ASDF system auto-loading extension.

This is an extension library to pathname-utils, to allow dealing with common problems with filesystems, such as listing files, probing file types, determining default directories, etc.

This project is intended as a catchall for small, general-purpose extensions to Common Lisp. It contains:

• new-let, a macro that combines and generalizes let, let* and multiple-value-bind,

• gmap, an iteration macro that generalizes map.

This package provides a JSON-RPC 2.0 server/client for Common Lisp.

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 library for reading semi-raw user input from terminals. Semi-raw as in, we can't detect if the user pressed the Control key alone, and the function keys are a mystery. What is supported, however, is:

• Regular characters

• Control+[key]

• Alt+[key]

• Control+Alt+[key]

Common Lisp library for channel-based concurrency. In a nutshell, you create various threads sequentially executing tasks you need done, and use channel objects to communicate and synchronize the state of these threads.

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

This package provides a function to parse the PATH environment variable portably in Common Lisp.

This package provides a functionality augmenting Hunchentoot error pages and logs with request and session information.

cl-rucksack is a persistence library based on Arthur Lemmens' Rucksack with some enhancements.

With static-vectors, you can create vectors allocated in static memory.

This package holds an enhanced implementation of hooks (extension points). It works similarly to Emacs hooks with crucial improvements:

• If the compiler allows it (such as SBCL), type-checking is performed at compile-time and at run-time when adding handlers to a hook.

• On failure, multiple restarts are offered, such as disabling the offending handler or simply continuing to the next function.

• The hook handler execution order and combination can be customized.

• Anonymous functions (lambdas) can be added to hooks as handler objects. When inspecting hooks, readable names are thus exposed instead of lambda blackboxes. Handlers are compared through their names (through the mandatory name slot). A hook can not contain multiple handlers with the same name.

• A special provision is taken for “setters”, handlers that are meant to set a given place to a given values. Such handler objects can be compared and identified uniquely.

One of the many things that didn't quite get into the Common Lisp standard was how to get a Lisp to output its call stack when something has gone wrong. As such, each Lisp has developed its own notion of what to display, how to display it, and what sort of arguments can be used to customize it. trivial-backtrace is a simple solution to generating a backtrace portably.