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.

charje.lambda-list can parse every kind of lambda list defined in the ANSI Common Lisp standard. Parsing yields only one object that has all the parsed parts of the lambda list inside. New kinds of lambda lists can be made too.

This package provides a portability layer for the extensible sequences standard extension to Common Lisp. Extensible sequences allow you to create your own sequence types that integrate with the rest of the functions and operations that interact with sequences.

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.

This package provides a robust CSV parser and printer that tries to follow the fine print of de facto standards. It can be configured to choose which standard exactly.

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

This library provides a uniform API, as specified in Common Lisp the Language 2, for accessing information about variable and function bindings from implementation-defined lexical environment objects. All major Common Lisp implementations are supported, even those which don't support the CLTL2 environment access API.

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

DEFLATE data, defined in RFC1951, forms the core of popular compression formats such as zlib (RFC 1950) and gzip (RFC 1952). As such, Chipz also provides for decompressing data in those formats as well. BZIP2 is the format used by the popular compression tool bzip2.

Babel is a charset encoding and decoding library, not unlike GNU libiconv, but completely written in Common Lisp.

This is a very simple implementation of SHA1 and HMAC-SHA1 for Common Lisp. The code is intended to be easy to follow and is therefore a little slower than it could be.

cl-xkb is a Common Lisp wrapper for the libxkbcommon keyboard handling library.

The library currently supports these xkb modules:

• Keysyms

• Library Context

• Include Paths

• Logging Handling

• Keymap Creation

• Keymap Components

• Keyboard State

• Compose and dead-keys support

This library is an extension of the Common Lisp Object System (CLOS) that allows a compiler to inline a generic function under certain conditions.

This is a simple library to retrieve the argument list of a function.

This package provides a canonical stand-in for NIL for contexts where NIL means no value.

Nsymbols extends the regular package API of ANSI CL with more operations, allowing one to list:

• package-symbols.

• package-variables.

• package-functions.

• package-generic-functions.

• package-macros.

• package-classes.

• package-structures.

• And other symbol types, given define-symbol-type for those.

Nsymbols can also find symbols by their name/matching symbol with resolve-symbol. All these operations are aware of symbol visibility in the given packages, due to a symbol-visibility function.

An additional nsymbols/star system has a set of functions mirroring the regular Nsymbols ones, but using closer-mop to provide better results and returning structured data instead of symbols.

This is a wrapper for the SDL2_TTF library used for loading fonts and creating text assets. The library, in it's current state, can load TTF and OTF fonts and render fonts with the three different rendering modes provided by the C library (solid, shaded, and blended). While Latin text, UTF8, UNICODE, and Glyph text rendering is available only Latin text has been tested (as shown in the examples).

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

This library is an SDL wrapper as part of an umbrella project that provides cross-platform packages for building large, interactive applications in Common Lisp.

This is a utility kit for cl-sdl2 that provides something similar to GLUT. However, it's also geared at being useful for "real" applications or games.

Common Lisp comes with quite some functions to compare objects for equality, yet none is applicable in every situation and in general this is hard, as equality of objects depends on the semantics of operations on them. As consequence, users find themselves regularly in a situation where they have to roll their own specialized equality test.

This module provides one of many possible equivalence relations between standard Common Lisp objects. However, it can be extended for new objects through a simple CLOS protocol. The rules when two objects are considered equivalent distinguish between mutating and frozen objects. A frozen object is promised not to be mutated in the future in a way that operations on it can notice the difference.

We have chosen to compare mutating objects only for identity (pointer equality), to avoid various problems. Equivalence for frozen objects on the other hand is established by recursing on the objects' constituent parts and checking their equivalence. Hence, two objects are equivalent under the OBJECT= relation, if they are either identical, or if they are frozen and structurally equivalent, i.e. their constituents are point-wise equivalent.

Since many objects are potentially mutable, but are not necessarily mutated from a certain point in their life time on, it is possible to promise to the equivalence relation that they remain frozen for the rest of their life time, thus enabling coarser equivalence than the often too fine-grained pointer equality.

UBIQUITOUS is a very easy-to-use library for persistent configuration storage. It automatically takes care of finding a suitable place to save your data, and provides simple functions to access and modify the data within.

Convenient macros for common lambda patterns.

This is a system for two dimensional computational geometry for Common Lisp.

Note: the system assumes exact rational arithmetic, so no floating point coordinates are allowed. This is not checked when creating geometric objects.