This package provides a client for SMTP.

cl-tar-file is a Common Lisp library that allows reading from and writing to various tar archive formats. Currently supported are the POSIX ustar, PAX (ustar with a few new entry types), GNU, and v7 (very old) formats.

This library is rather low level and is focused exclusively on reading and writing physical tar file entries using streams. Therefore, it contains no functionality for automatically building archives from a set of files on the filesystem or writing the contents of a file to the filesystem. Additionally, there are no smarts that read multiple physical entries and combine them into a single logical entry (e.g., with PAX extended headers or GNU long link/path name support). For a higher-level library that reads and writes logical entries, and also includes filesystem integration, see cl-tar.

PAX provides an extremely poor man's Explorable Programming environment. 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). See how to enable some fanciness in Emacs Integration. Generating documentation from sections and all the referenced items in Markdown or HTML format is also implemented.

With the simplistic tools provided, one may accomplish similar effects as with Literate Programming, but documentation is generated from code, not vice versa and there is no support for chunking yet. Code is first, code must look pretty, documentation is code.

Just wrap your Common Lisp function in this macro call and it will be optimized for tail recursion. You will be warned if the function is not tail recursive.

Trial is a game engine written in Common Lisp. Unlike many other engines, it is meant to be more of a loose connection of components that can be fit together as required by any particular game.

Caveman is intended to be a collection of common parts for web applications. Caveman2 has three design goals:

• Be extensible.

• Be practical.

• Don't force anything.

This library is a Common Lisp port of all the constants from the event codes header file found on Linux and FreeBSD.

The py-configparser package implements the ConfigParser Python module functionality in Common Lisp. In short, it implements reading and writing of .INI-file style configuration files with sections containing key/value pairs of configuration options. In line with the functionalities in the python module, does this package implement basic interpolation of option values in other options.

doplus is an iteration macro for Common Lisp.

This a Common Lisp library to convert geographic coordinates between latitude/longitude and MGRS.

GARBAGE-POOLS is Common Lisp re-implementation of the APR Pools for resource management.

Clamp is an attempt to bring the powerful, but verbose, language of Common Lisp up to the terseness of Arc.

There are two parts to Clamp. There is the core of Clamp, which implements the utilities of Arc that are easily converted from Arc to Common Lisp. The other part is the "experimental" part. It contains features of Arc that are not so easy to copy (ssyntax, argument destructuring, etc.).

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

Trivial-features ensures that *FEATURES* is consistent across multiple Common Lisp implementations.

This package implements The MD5 Message-Digest Algorithm, as defined in RFC 1321 by R. Rivest, published April 1992.

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

CL-DOT is a Common Lisp library for generating Graphviz dot output from arbitrary Lisp data.

Smart-buffer provides an output buffer which changes the destination depending on content size.

This is a Common Lisp library providing functions to read/write CSV from/to strings, streams and files.

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.

simple-optimization is a Common Lisp library providing a function to solve unconstrained optimization problems numerically using either the gradient descent or a quasi-Newton method.

Calispel is a Common Lisp library for thread-safe message-passing channels, in the style of the occam programming language, also known as communicating sequential processes (CSP). See https://en.wikipedia.org/wiki/Communicating_sequential_processes.

Calispel channels let one thread communicate with another, facilitating unidirectional communication of any Lisp object. Channels may be unbuffered, where a sender waits for a receiver (or vice versa) before either operation can continue, or channels may be buffered with flexible policy options.

Because sending and receiving on a channel may block, either operation can time out after a specified amount of time.

A syntax for alternation is provided (like ALT in occam, or Unix select()): given a sequence of operations, any or all of which may block, alternation selects the first operation that doesn't block and executes associated code. Alternation can also time out, executing an "otherwise" clause if no operation becomes available within a set amount of time.

Calispel is a message-passing library, and as such leaves the role of threading abstractions and utilities left to be filled by complementary libraries such as Bordeaux-Threads and Eager Future.

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

This library contains an implementation of interfaces and implementations. They're sometimes called protocols in other languages. Broadly speaking, an interface is some collection of function prototypes that a valid implementation must implement.