NFiles is a Common Lisp library to help manage file persistence and loading, in particular user-centric files like configuration files. It boasts the following features:

• Dynamic and customizable path expansion.

• Extensible serialization and deserialization.

• Cached reads and writes. When a file object expands to the same path as another one, a read or write on it won’t do anything in case there was no change since last write.

• (Experimental!) On-the-fly PGP encryption.

• Profile support.

• On read error, existing files are backed up.

• On write error, no file is written to disk, the existing file is preserved.

VAS-STRING-METRICS provides the Jaro, Jaro-Winkler, Soerensen-Dice, Levenshtein, and normalized Levenshtein string distance/similarity metrics algorithms.

DAEMON provides the functionality of daemonizing Common Lisp processes on UNIX like platforms.

This piece of code sets up some reader macros that make it simpler to input string literals which contain backslashes and double quotes This is very useful for writing complicated docstrings and, as it turns out, writing code that contains string literals that contain code themselves.

This is ZS3, a library for working with Amazon's Simple Storage Service (S3) and CloudFront service from Common Lisp.

This Common Lisp library converts strings, symbols and keywords between any of the following typographical cases: PascalCase, camelCase, snake_case, kebab-case (lisp-case).

This package contains an implementation of RFC 2388, which is used to process form data posted with HTTP POST method using enctype "multipart/form-data".

This is a Common Lisp library for processing data found in dBase III database files (dbf and db3 files).

This package provides a BNF parser in Common Lisp.

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

This Common Lisp library implements a parser generator for the ABNF grammar format as described in RFC2234. The generated parser is a regular expression scanner provided by the cl-ppcre lib, which means that we can't parse recursive grammar definition. One such definition is the ABNF definition as given by the RFC. Fortunately, as you have this lib, you most probably don't need to generate another parser to handle that particular ABNF grammar.

This package provides a hierarchy of major functions and auxiliary functions related to the structured analysis and processing of open text.

YASON is a Common Lisp library for encoding and decoding data in the JSON interchange format.

This is a library that implements delimited continuations by transforming Common Lisp code to continuation passing style.

This package provides a configuration library that adds the ability for Lem to manage packages within the user configuration directory.

This is a Common Lisp library that implements the 9p network filesystem protocol.

Linedit is a readline-style library written in Common Lisp that provides customizable line-editing for Common Lisp programs.

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

This library implements the -> and ->> macros from Clojure, as well as several expansions on the idea.

Cl-async is a library for general purpose, non-blocking programming in Common Lisp. It uses the libuv library as backend.

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

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.

This library features a rectangle packer for sprite and texture atlases.

This package makes it possible to name classes by lists of symbols instead of symbols.