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 library provides two strata to access the POSIX shm API:

• the package posix-shm/ffi, a collection of slim bindings to the POSIX API

• the package posix-shm, a lispy wrapper around the FFI that integrates more closely to the features of Common Lisp, and provides a handful of utilities and macros

Features include:

• open, close, create, resize, change ownership of, change permissions of, and memory map to shared memory objects

• open-shm appears more like open from the standard library

• open-shm*, for creating anonymous shm objects

• with-open-shm, with-mmap and similar with- macros for safely accessing resources with dynamic extent

Py4CL is a bridge between Common Lisp and Python, which enables Common Lisp to interact with Python code. It uses streams to communicate with a separate python process, the approach taken by cl4py. This is different to the CFFI approach used by burgled-batteries, but has the same goal.

Trucler defines a CLOS-based protocol to be used by Common Lisp compilers for environment query and update. In addition, library authors can use the trucler-native interface to inspect native environments. Trucler supports introspection for variables, functions, tags, blocks and optimization policies.

This library enable rapid file search, inspection and manipulation straight from the REPL. It aims at replacing Unix tools such as find or du. It also offers a replacement to the pathname Common Lisp API. Slot writers which commit changes to disk, e.g. permissions, modification time, etc.

mito-auth provides a mito mixin class for user authorization.

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.

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

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 Common Lisp library provides function to make QR codes and to save them as PNG files.

This package provides a priority queue implemented with an array-based heap.

Clop is a Common Lisp library for parsing strings in the TOML configuration file format.

core-gp is a Common Lisp library for genetic programming (GP) algorithms. It allows standard GP, strongly-typed GP, grammatical evolution as well as standard genetic algorithms.

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

CXML implements a namespace-aware, validating XML 1.0 parser as well as the DOM Level 2 Core interfaces. Two parser interfaces are offered, one SAX-like, the other similar to StAX.

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.

This package provides a stream based JSON parser/writer, well suited as building block for higher level libraries.

This package provides a PNG Common Lisp system to operate with Portable Network Graphics file format.

This library is a path strings manipulation library inspired by Python's os.path. All functionality from os.path is supported on major operation systems.

The philosophy behind is to use simple strings and "dumb" string manipulation functions to handle paths and filenames. Where possible the corresponding OS system functions are called.

Gray streams is an interface proposed for inclusion with ANSI CL by David N. Gray. The proposal did not make it into ANSI CL, but most popular CL implementations implement it. This package provides an extremely thin compatibility layer for gray streams.

This package provides a KDL reader/writer for Common Lisp.

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.

A miniature toolkit that contains some useful shifting/popping/pushing functions for arrays and vectors. Originally from Plump.

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.