Aims to be fast, modular, cachable and concise. It does so by defining each tag as a macro which expands to code printing the respective HTML source. Also employs a DSL for element attributes.

This library allows you to implement and enforce proper finalization of compile-time constructs while building Lisp source files.

It produces two systems: asdf-finalizers and list-of.

This is a Common Lisp macro for defining temporary caches that invalidate based on expressions evaluating to different values.

Circular-Streams allows you to read streams circularly by wrapping real streams. Once you reach end-of-file of a stream, its file position will be reset to 0 and you're able to read it again.

Parseq (pronounced parsec) is a parsing library for common lisp. It can be used for parsing lisp's sequences types: strings, vectors (e.g. binary data) and lists. Furthermore, parseq is able to parse nested structures such as trees (e.g. lists of lists, lists of vectors, vectors of strings).

Parseq uses parsing expression grammars (PEG) that can be defined through a simple interface. Extensions to the standard parsing expressions are available. Parsing expressions can be parameterised and made context aware. Additionally, the definition of each parsing expression allows the arbitrary transformation of the parsing tree.

The library is inspired by Esrap and uses a very similar interface. No code is shared between the two projects, however. The features of Esrap are are mostly included in parseq and complemented with additional, orthogonal features. Any resemblance to esrap-liquid is merely coincidental.

This package provides a statistical computing environment for Common Lisp.

RESTAS is a Common Lisp web application framework.

This package provides a Common Lisp library for getting the battery information.

CL-ALGEBRAIC-DATA-TYPE, or ADT, is a library for defining algebraic data types in a similar spirit to Haskell or Standard ML, as well as for operating on them.

cl-num-utils implements simple numerical functions for Common Lisp, including:

• num=, a comparison operator for floats

• simple arithmeric functions, like sum and l2norm

• elementwise operations for arrays

• intervals

• special matrices and shorthand for their input

• sample statistics

• Chebyshev polynomials

• univariate rootfinding

trivial-download allows you to download files from the Internet from Common Lisp. It provides a progress bar.

simple-neural-network is a Common Lisp library for creating, training and using basic neural networks. The networks created by this library are feedforward neural networks trained using backpropagation.

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.

This is a common lisp library to easily pluralize and singularize English and Portuguese words. This is a port of the ruby ActiveSupport Inflector module.

Staple is a documentation system. It provides you with a way to generate standalone documentation accumulated from various sources such as readmes, documentation files, and docstrings.

Porter Stemming Algorithm.

This is a keymap facility for Common Lisp inspired by Emacsy (keymap.scm) which is inspired by Emacs.

• Support prefix keys to other keymaps. For instance, if you prefix my-mode-map with C-c, then all bindings for my-mode will be accessible after pressing C-c.

• List all bindings matching a given prefix. (Also known as which-key in Emacs.)

• List the bindings associated to a command.

• Support multiple inheritance.

• Support keycode.

• Validate keyspec at compile time.

• define-key can set multiple bindings in a single call.

• Support multiple scheme to make it easy to switch between, say, Emacs-style and VI-style bindings. This orthogonality to keymaps composes better than having multiple keymaps: changing scheme applies to the entire program, which is easier than looping through all keymaps to change them.

• Translate keyspecs as a fallback. For instance if shift-a is not bound, check A.

• Behaviour can be customized with global parameters such as *print-shortcut*.

• The compose function can merge multiple keymaps together.

• Support multiple arguments when that makes sense (e.g. multiple keymaps for lookup-key).

• Key remapping à-la Emacs.

• Typed keymaps, i.e. keymaps where bound values can only be of a given type. This is convenient to catch typos, for instance when binding 'FOO instead of #'FOO.

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

This library implements efficient algorithms that calculate various string metrics in Common Lisp:

• Damerau-Levenshtein distance

• Hamming distance

• Jaccard similarity coefficient

• Jaro distance

• Jaro-Winkler distance

• Levenshtein distance

• Normalized Damerau-Levenshtein distance

• Normalized Levenshtein distance

• Overlap coefficient

cl-peppol provides access to code lists extracted from the OpenPEPPOL standard for electronic business and invoicing in Europe.

clsql is a Common Lisp interface to SQL RDBMS based on the Xanalys CommonSQL interface for Lispworks. It provides low-level database interfaces as well as a functional and an object oriented interface.

CL-ALGEBRAIC-DATA-TYPE, or ADT, is a library for defining algebraic data types in a similar spirit to Haskell or Standard ML, as well as for operating on them.

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

This package provides a macro commonly used in livecoding to enable continuing when errors are raised. Simply wrap around a chunk of code and it provides a restart called continue which ignores the error and carrys on from the end of the body.