cl-amb provides an implementation of John McCarthy's ambiguous operator in portable Common Lisp.

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.

Lack is a Common Lisp library which allows web applications to be constructed of modular components. It was originally a part of Clack, however it's going to be rewritten as an individual project since Clack v2 with performance and simplicity in mind.

RESTAS is a Common Lisp web application framework.

BORDEAUX-THREADS is a proposed standard for a minimal MP/Threading interface. It is similar to the CLIM-SYS threading and lock support.

This package provides a DSL for array slices in Common Lisp.

Random-Sample is a library for reliably taking a random sample from a sequence.

This package provides an extensible implementation of defclass that can accurately control the expansion according to the metaclass and automatically detect the suitable metaclass by analyzing the defclass form.

Dufy is a library for exact color manipulation and conversion in various color spaces, which supports many color models.

CF is a Common Lisp library for doing computations using continued fractions.

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.

cl-syslog is a Common Lisp library that provides access to the syslog logging facility.

This is a Common Lisp macro for defining temporary caches that invalidate based on expressions evaluating to different values.

This package provides some condition classes, functions and macros which may be useful when building slightly complex systems.

A collection of Common Lisp utility functions and macros mostly not found in other utility packages.

This package provides a Language Server Protocol implementation for use with the Alive Visual Studio Code extension.

It can be used in Emacs like this:

(require 'lsp)
(defun lsp-lisp-alive-start-ls ()
 "Start the alive-lsp."
 (interactive)
 (when-let (((lsp--port-available "localhost" lsp-lisp-alive-port)))
  (lsp-async-start-process #'ignore #'ignore
   "sbcl"
   "--eval"
   "(require :asdf)"
   "--eval"
   "(asdf:load-system :alive-lsp)"
   "--eval"
   (format "(alive/server::start :port %s)"
    lsp-lisp-alive-port))))

ARNESI is Common Lisp utilities library similar to ALEXANDRIA, ANAPHORA or GOLDEN-UTILS.

This a Common Lisp library to convert geographic coordinates between latitude/longitude and MGRS.

The Readline library provides a set of functions for use by applications that allow users to edit command lines as they are typed in. Both Emacs and vi editing modes are available. The Readline library includes additional functions to maintain a list of previously-entered command lines, to recall and perhaps reedit those lines, and perform csh-like history expansion on previous commands.

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 is a portable compatibility layer around "Common Lisp the Language, 2nd Edition" (https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html) and it exports symbols from implementation-specific packages.

This package provides a Common Lisp system implementing event bus.

This package provides a PEM (Privacy-Enhanced Mail) parser for Common Lisp.

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.