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

This library contains utilities for parsing Common Lisp code.

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.

This is a Common Lisp library to present tabular data in ascii-art tables.

definitions-systems provides a simple unified extensible way of processing named definitions.

This is a utility library providing access to the mmap family of functions in a portable way. It allows you to directly map a file into the address space of your process without having to manually read it into memory sequentially. Typically this is much more efficient for files that are larger than a few Kb.

Binary-types is a Common Lisp package for reading and writing binary files. Binary-types provides macros that are used to declare the mapping between Lisp objects and some binary (i.e. octet-based) representation.

This package provides a standard interface to the various package lock implementations of Common Lisp.

A hook, in the present context, is a certain kind of extension point in a program that allows interleaving the execution of arbitrary code with the execution of a the program without introducing any coupling between the two. Hooks are used extensively in the extensible editor Emacs.

In the Common LISP Object System (CLOS), a similar kind of extensibility is possible using the flexible multi-method dispatch mechanism. It may even seem that the concept of hooks does not provide any benefits over the possibilities of CLOS. However, there are some differences:

• There can be only one method for each combination of specializers and qualifiers. As a result this kind of extension point cannot be used by multiple extensions independently.

• Removing code previously attached via a :before, :after or :around method can be cumbersome.

• There could be other or even multiple extension points besides :before and :after in a single method.

• Attaching codes to individual objects using eql specializers can be cumbersome.

• Introspection of code attached a particular extension point is cumbersome since this requires enumerating and inspecting the methods of a generic function.

This library tries to complement some of these weaknesses of method-based extension-points via the concept of hooks.

This Common Lisp library implements the quoted-printable encoding as described in RFC 2045 (see http://tools.ietf.org/html/rfc2045).

Quicksearch is a search-engine-interface for Common Lisp. The goal of Quicksearch is to find the Common Lisp library quickly. For example, if you will find the library about json, just type (qs:? 'json) at REPL.

The function quicksearch searches for Common Lisp projects in Quicklisp, Cliki, GitHub and BitBucket, then outputs results in REPL. The function ? is abbreviation wrapper for quicksearch.

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

This package is a Python Numpy clone implemented in pure Common Lisp.

This is a repackage of the original DejaVu Fonts with some convenience functions.

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

This package provides easy access to the defining class and its options during initialization or reinitialization of its subcomponents.

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

RUTILS is a syntactic utilities package for Common Lisp.

The Plump-SEXP library is a backend for Plump which can convert between S-expressions and the Plump DOM.

This package provides a canonical way of converting generalized booleans to booleans.

This library provides a WebSocket server and client implementation for Common Lisp.

fare-utils is a small collection of utilities. It contains a lot of basic everyday functions and macros.

PAX provides an extremely poor man's Explorable Programming environment. Narrative primarily lives in so called sections that mix markdown docstrings with references to functions, variables, etc, all of which should probably have their own docstrings.

The primary focus is on making code easily explorable by using SLIME's M-. (slime-edit-definition). See how to enable some fanciness in Emacs Integration. Generating documentation from sections and all the referenced items in Markdown or HTML format is also implemented.

With the simplistic tools provided, one may accomplish similar effects as with Literate Programming, but documentation is generated from code, not vice versa and there is no support for chunking yet. Code is first, code must look pretty, documentation is code.

ADOPT is a simple UNIX-style option parser in Common Lisp, heavily influenced by Python's optparse and argparse.