This package provides a macro that allows foreign functions to access the contents of the array at a given pointer, using the best available method given the Common Lisp implementation.

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.

Utility library for handling bit vectors, bit vector arithmetic, and universal integer type conversions between bit-vectors, byte-vectors, octals, decimals, and hexadecimal notation.

This library provides a simple multithreading worker mechanism.

This library provides a macroexpand-all function that calls the implementation specific equivalent.

Conium is a portability library for debugger- and compiler-related tasks in Common Lisp. It is fork of SWANK-BACKEND.

This Common Lisp package contains the core math utilities of the Bodge library collection.

Splits sequence into a list of subsequences delimited by objects satisfying the test.

Stealth-mixin is a Common Lisp library for creating stealth mixin classes. These are classes that are dynamically mixed into other classes without the latter being aware of it.

This is a Common Lisp library implementing the full v1 REST API protocol for Mastodon.

This library provides almost the same code as used inside Quicklisp for drawning progress bars

CL-DATA-STRUCTURES is a Common Lisp library providing a portable collection of mutable and immutable data structures (dictionaries, sets, queues, sequences) and algorithms.

cl-strings is a small, portable, dependency-free set of utilities that make it even easier to manipulate text in Common Lisp. It has 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.

A small collection of common lisp macros to make collecting values easier.

clingon is a command-line option parsing library for Common Lisp. Its features include:

• Support for subcommands

• Support for command aliases

• Support for short and long options

• Related options may be grouped into categories

• Short options may be collapsed into a single argument, as in -xyz

• Long options support the notations --long-opt arg and --long-opt=arg

• Automatic generation of help/usage information for commands and subcommands

• Out-of-the-box support for --version and --help

• Support for various kinds of options including string, integer, boolean, switch, enum, list, counter, filepath, etc.

• Subcommands can look up global options defined in parent commands

• Support for required options

• Options can be initialized via environment variables

• Single interface for creating options using CLINGON:MAKE-OPTION

• Generate documentation for your command-line application

• Support for pre-hook and post-hook actions for commands, which allow invoking functions before and after the respective handler of the command is executed

• Support for Bash and Zsh completions

• Extensibility, so if you don't find something you need you can extend it by developing a new option kind, or even a new mechanism for initializing options, e.g., by looking up an external key/value store

This package provides the getopt function to parse command-line options. The options are organized in valid options, other arguments and unknown arguments. Optional Lisp conditions for error situations are also defined.

MAGICFFI is a Common Lisp CFFI interface to libmagic(3), the file type determination library using magic numbers.

cl-morse is a Morse code translation library for Common Lisp.

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.

This package provides a CONSPACK implementation for Common Lisp.

deeds allows for efficient event delivery to multiple handlers with a complex event filtering system.

It's very basic implementation of channels and queue for Common Lisp.

ORG-SAMPLER allows using Lisp docstrings and reflection to make org-mode text for inclusion into a larger document.

This library is a collection of pseudo random number generators.

While Common Lisp does provide a RANDOM function, it does not allow the user to pass an explicit SEED, nor to portably exchange the random state between implementations. This can be a headache in cases like games, where a controlled seeding process can be very useful.

For both curiosity and convenience, this library offers multiple algorithms to generate random numbers, as well as a bunch of generally useful methods to produce desired ranges.