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.

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

This is a Common Lisp library to handle the IBM PC version of the IXF (Integration Exchange Format) file format.

Eager Future2 is a Common Lisp library that provides composable concurrency primitives that unify parallel and lazy evaluation, are integrated with the Common Lisp condition system, and have automatic resource management.

A mixture of features from eRuby and HTML::Template. You could name it "Yet Another LSP" (LispServer Pages) but it's a bit more than that and not limited to a certain server or text format.

This is a library for access to atomic operation primitives such as compare-and-swap. It aims to be a rather thin layer over what the implementations offer.

Common Lisp ships with a set of powerful built in data structures including the venerable list, full featured arrays, and hash-tables. CL-containers enhances and builds on these structures by adding containers that are not available in native Lisp (for example: binary search trees, red-black trees, sparse arrays and so on), and by providing a standard interface so that they are simpler to use and so that changing design decisions becomes significantly easier.

This package parses and prints dates in RFC-1123 format.

CL-FAD (for "Files and Directories") is a thin layer atop Common Lisp's standard pathname functions. It is intended to provide some unification between current CL implementations on Windows, OS X, Linux, and Unix. Most of the code was written by Peter Seibel for his book Practical Common Lisp.

This is a Common Lisp library consisting of a collection of useful GPU shader functions, written with Shadow.

HTML-TEMPLATE is a Common Lisp library which can be used to fill templates with arbitrary (string) values at runtime. The result does not have to be HTML.

It is loosely modeled after the Perl module HTML::Template and partially compatible with a its syntax, though both libraries contain some extensions that the other does not support.

HTML-TEMPLATE translates templates into efficient closures which can be re-used as often as needed. It uses a cache mechanism so you can update templates while your program is running and have the changes take effect immediately.

cl-charms is an interface to libcurses in Common Lisp. It provides both a raw, low-level interface to libcurses via CFFI, and a more higher-level lispier interface.

On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there is a collection of Common Lisp Utilities, things that everybody writes since they're not part of the official standard. There are some very useful things there; the only problems are that they aren't implemented as well as you'd like (some aren't implemented at all) and they aren't conveniently packaged and maintained. It takes quite a bit of work to carefully implement utilities for common use, commented and documented, with error checking placed everywhere some dumb user might make a mistake.

GENERIC-COMPARABILITY is an implementation of CDR-8 (Generic Equality and Comparison for Common Lisp). CDR-8 provides an interface for the EQUALS function, which is defined as a general equality predicate, as well as a set of ordering (COMPARE) functions for comparison. The semantics are described in the CDR-8 standard.

This library introduces fast generic functions, i.e. functions that behave just like regular generic functions, except that the can be sealed on certain domains. If the compiler can then statically detect that the arguments to a fast generic function fall within such a domain, it will perform a variety of optimizations.

Metatilities-base is the core of the metatilities Common Lisp library which implements a set of utilities.

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

Eclector is a portable Common Lisp reader that is highly customizable, can recover from errors and can return concrete syntax trees.

In contrast to many other reader implementations, eclector can recover from most errors in the input supplied to it and continue reading. This capability is realized as a restart.

It can also produce instances of the concrete syntax tree classes provided by the concrete syntax tree library.

This library provides a wrapper type for secret values, to reduce the risk of accidentally revealing them.

This package provides Common Lisp FFI bindings for xkbcommon (libxkbcommon) using cffi-grovel.

BOOST-JSON is a simple JSON parsing library for Common Lisp.

This package provides an implementation of the which UNIX command in Common Lisp.

This library provides an asynchronous process execution mechanism for Common Lisp.

This is a task scheduling framework for Common Lisp.