This library builds on the venerable idea of dynamically memoizing functions. A memoized function remembers results from previous computations and returns cached results when called again with the same arguments rather than repeating the computation.

The Common Foreign Function Interface (CFFI) purports to be a portable foreign function interface for Common Lisp. The CFFI library is composed of a Lisp-implementation-specific backend in the CFFI-SYS package, and a portable frontend in the CFFI package.

This package provides an automatic generator for ASDF's .asd files.

Antik provides a foundation for scientific and engineering computation in Common Lisp. It is designed not only to facilitate numerical computations, but to permit the use of numerical computation libraries and the interchange of data and procedures, whether foreign (non-Lisp) or Lisp libraries. It is named after the Antikythera mechanism, one of the oldest examples of a scientific computer known.

This is a Common lisp library to unify access to the most common dictionary-like data structures.

This is a Common Lisp library providing a set of macros for generating lexical analyzers automatically. The lexers generated using cl-lex can be used with cl-yacc.

This package provides functions to encode or decode byte vectors or byte streams using the Z85 format, which is a base-85 encoding used by ZeroMQ.

one-more-re-nightmare is a regular expression engine that uses the technique presented in Regular-expression derivatives re-examined (Owens, Reppy and Turon, 2009; doi:10.1017/S0956796808007090) to interpret and compile regular expressions.

exit-hooks provides a portable way to automatically call some user-defined function when exiting Common Lisp (both quit from the REPL or a kill in a shell). Like atexit in C and Python or Java’s Runtime.addShutdownHook(). It currently supports SBCL, CCL, ECL, ABCL, Allegro CL, clisp and CMUCL. Before exit-hooks, there was no portable way of doing so and no staightforward way to use an exit hook on ABCL. It can be used for tasks like parmenantly save something when exiting Lisp.

trivial-garbage provides a portable API to finalizers, weak hash-tables and weak pointers on all major implementations of the Common Lisp programming language.

This package provides an implementation of the flexichain protocol, allowing client code to dynamically add elements to, and delete elements from a sequence (or chain) of such elements.

This is a small library providing the ISO-639 language code to language name mapping.

Convenient macros for common lambda patterns.

McCLIM is an implementation of the Common Lisp Interface Manager specification, a toolkit for writing GUIs in Common Lisp.

This is a library for selecting portions of sequences, arrays or data-frames.

Parenscript is a translator from an extended subset of Common Lisp to JavaScript. Parenscript code can run almost identically on both the browser (as JavaScript) and server (as Common Lisp).

Parenscript code is treated the same way as Common Lisp code, making the full power of Lisp macros available for JavaScript. This provides a web development environment that is unmatched in its ability to reduce code duplication and provide advanced meta-programming facilities to web developers.

At the same time, Parenscript is different from almost all other "language X" to JavaScript translators in that it imposes almost no overhead:

• No run-time dependencies: Any piece of Parenscript code is runnable as-is. There are no JavaScript files to include.

• Native types: Parenscript works entirely with native JavaScript data types. There are no new types introduced, and object prototypes are not touched.

• Native calling convention: Any JavaScript code can be called without the need for bindings. Likewise, Parenscript can be used to make efficient, self-contained JavaScript libraries.

• Readable code: Parenscript generates concise, formatted, idiomatic JavaScript code. Identifier names are preserved. This enables seamless debugging in tools like Firebug.

• Efficiency: Parenscript introduces minimal overhead for advanced Common Lisp features. The generated code is almost as fast as hand-written JavaScript.

CEPL (Code Evaluate Play Loop ) is a lispy and REPL-friendly Common Lisp library for working with OpenGL.

Its definition of success is making the user feel that GPU programming has always been part of the languages standard.

The usual approach to using CEPL is to start it at the beginning of your Lisp session and leave it open for the duration of your work. You can then treat the window it creates as just another output for your graphics, analogous to how *standard-output* is treated for text.

This is a Common Lisp library for creating PNG images.

This is a dead-simple, non validating, inline CSS generator for Common Lisp. Its goals are axiomatic syntax, simple implementation to support portability, and boilerplate reduction in CSS.

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.

This package defines a simple extensible protocol for computing a guess using advisors.

This is a collection of useful helper modules and standard implementations for Radiance interfaces.

This library converts the elements from GObject Introspection into Common Lisp-style definitions, based on cl-gobject-introspection.

The GNU Scientific Library for Lisp (GSLL) allows the use of the GNU Scientific Library (GSL) from Common Lisp. This library provides a full range of common mathematical operations useful to scientific and engineering applications. The design of the GSLL interface is such that access to most of the GSL library is possible in a Lisp-natural way; the intent is that the user not be hampered by the restrictions of the C language in which GSL has been written. GSLL thus provides interactive use of GSL for getting quick answers, even for someone not intending to program in Lisp.