When dealing with network protocols and file formats, it's common to have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned flavors. Common Lisp sort of supports this by specifying :element-type for streams, but that facility is underspecified and there's nothing similar for read/write from octet vectors. What most people wind up doing is rolling their own small facility for their particular needs and calling it a day.

This library attempts to be comprehensive and centralize such facilities. Functions to read 16-, 32-, and 64-bit quantities from octet vectors in signed or unsigned flavors are provided; these functions are also SETFable. Since it's sometimes desirable to read/write directly from streams, functions for doing so are also provided. On some implementations, reading/writing IEEE singles/doubles (i.e. single-float and double-float) will also be supported.

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

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

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

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 provides a small utility library to open a thing (usually a file or URL) in an appropriate handler (usually an external file manager or browser).

This is a Common Lisp version of UglifyJS, a JavaScript compressor. It works on data produced by parse-js to generate a minified version of the code. Currently it can:

• reduce variable names (usually to single letters)

• join consecutive var statements

• resolve simple binary expressions

• group most consecutive statements using the sequence operator (comma)

• remove unnecessary blocks

• convert IF expressions in various ways that result in smaller code

• remove some unreachable code

jsown is a high performance Common Lisp JSON parser. Its aim is to allow for the fast parsing of JSON objects in Common Lisp. Recently, functions and macros have been added to ease the burden of writing and editing jsown objects.

jsown allows you to parse JSON objects quickly to a modifiable Lisp list and write them back. If you only need partial retrieval of objects, jsown allows you to select the keys which you would like to see parsed. jsown also has a JSON writer and some helper methods to alter the JSON objects themselves.

nontrivial-gray-streams is a compatibility system for Gray streams, which is an extension to Common Lisp that makes it possible to implement Common Lisp streams using generic functions.

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

CL-TYPESETTING is a cross-platform Common Lisp typesetting library for all kind of typesetting applications.

defclass-star provides defclass* and defcondition* to simplify class and condition declarations. Features include:

• Automatically export all or select slots at compile time.

• Define the :initarg and :accessor automatically.

• Specify a name transformer for both the :initarg and :accessor, etc.

• Specify the :initform as second slot value.

See https://common-lisp.net/project/defclass-star/configuration.lisp.html for an example.

CL-FAST-ECS is a Common Lisp library providing an implementation of the ECS pattern, primarily focused on speed and interactive development.

ECS is an architectural data-oriented design pattern that allows for the effective processing of a large number of in-game objects while keeping the code and data separated. This provides flexibility in the way that game objects are built at runtime.

Mito is yet another object relational mapper, and it aims to be a successor of Integral.

• Support MySQL, PostgreSQL and SQLite3.

• Add id (serial/uuid primary key), created_at and updated_at by default like Ruby's ActiveRecord.

• Migrations.

• Database schema versioning.

Named readtables is a library that creates a namespace for named readtables, which is akin to package namespacing in Common Lisp.

FLOW is a flowchart graph library. Unlike other graphing libraries, this one focuses on nodes in a graph having distinct ports through which connections to other nodes are formed. This helps in many concrete scenarios where it is important to distinguish not only which nodes are connected, but also how they are connected to each other.

Particularly, a lot of data flow and exchange problems can be reduced to such a flowchart. For example, an audio processing library may present its pipeline as a flowchart of segments that communicate with each other through audio sample buffers. Flow gives a convenient view onto this kind of problem, and even allows the generic visualisation of graphs in this format.

This Common Lisp package offers functions for parsing and formatting decimal numbers. The package's main interface are the functions parse-decimal-number and format-decimal-number. The former is for parsing strings for decimal numbers and the latter for pretty-printing them as strings.

CXML does an excellent job at parsing XML elements, but what do you do when you have a XML file that's larger than you want to fit in memory, and you want to extract some information from it? Writing code to deal with SAX events, or even using Klacks, quickly becomes tedious. cl-xmlspam (for XML Stream PAttern Matcher) is designed to make it easy to write code that mirrors the structure of the XML that it's parsing. It also makes it easy to shift paradigms when necessary - the usual Lisp control constructs can be used interchangeably with pattern matching, and the full power of CXML is available when necessary.

Defstar is a collection of Common Lisp macros that can be used in place of defun, defmethod, defgeneric, defvar, defparameter, flet, labels, let* and lambda. Each macro has the same name as the form it replaces, with a star added at the end, e.g. defun. (the exception is the let* replacement, which is called *let).

40ants-doc provides a rudimentary explorable programming environment. The 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). Generating documentation in Markdown or HTML format from sections and all the referenced items is also implemented.

With the simplistic tools provided, one may obtain results similar to literate programming, but documentation is generated from code, not the other way around, and there is no support for chunking. Code comes first, code must look pretty, documentation is code.

40ants-doc is a fork of MGL-PAX with fewer dependencies (only named-readtables and pythonic-string-reader) for the core system, and additional features in the full system.

concurrent-hash-tables is a Common Lisp portability library wrapping some implementations of concurrent hash tables which do not have to be entirely locked in their operation, including 42nd-at-threadmill, luckless, and a fallback, segmented hash table.

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.

Triads is a simple command line tool that reads roman numeral notation from standard input (or a file) and an musical key and outputs the roman numeral in addition to the notes of the triad associated with that roman numeral given in the key.

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.