This is a wrapper library to allow you to interface with the Valve SteamWorks API.

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 allows flexible specification of package-local preferences.

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.

This is a string/octets parser library for Common Lisp with speed and readability in mind. Unlike other libraries, the code is not a pattern-matching-like, but a char-by-char procedural parser.

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.

Alexandria is a collection of portable utilities. It does not contain conceptual extensions to Common Lisp. It is conservative in scope, and portable between implementations.

This package provides a Common Lisp web framework for building GUI applications. CLOG can take the place, or work along side, most cross platform GUI frameworks and website frameworks. The CLOG package starts up the connectivity to the browser or other websocket client (often a browser embedded in a native template application).

This is a very short and simple program, written in Common Lisp, that extends Common Lisp to embed shell code in a manner similar to Perl's backtick. It has been forked from SHELISP.

This is a Common Lisp library for reading and printing MIME content. It supports automatic conversion between 7-bit, quoted-printable and base64 encodings.

This package provides a set of bindings and utilities for accessing the OpenGL (Mesa), GLU and GLUT (FreeGLUT) APIs using CFFI.

A CLOS class that defines callable objects whose behavior is similar to closures but adds conveniences such as introspectability.

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.

Unifies a parametrized type specifier against an actual type specifier. Importantly, it handles complicated array-subtypes and number-related types correctly.

This is a YAML parser and emitter for Common Lisp built on top of libyaml.

string-pokemonize provides a function that alternates uppercase and lowercase characters for a given string.

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 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 a Common Lisp library to convert geographic coordinates between latitude/longitude and Maidenhead locator system.

This package provides a Common Lisp library for fetching and parsing RSS feeds data via HTTP. Currently, it supports RSS versions 0.90, 0.91, and 0.92 as well as RSS version 2.

This Common Lisp library provides optimized byte-swapping primitives. The library can change endianness of unsigned integers of length 1/2/4/8. Very useful in implementing various network protocols and file formats.

This a Common Lisp library to convert geographic coordinates between latitude/longitude and Maidenhead locator system.

BOOST-RE is a small, portable, lightweight, and quick, regular expression library for Common Lisp. It is a non-recursive, backtracking VM.

This package provides a Common Lisp translation library similar to CL-I18N and CL-L10N.