Enter the query into the form above. You can look for specific version of a package by using @ symbol like this: gcc@10.
API method:
GET /api/packages?search=hello&page=1&limit=20
where search is your query, page is a page number and limit is a number of items on a single page. Pagination information (such as a number of pages and etc) is returned
in response headers.
If you'd like to join our channel webring send a patch to ~whereiseveryone/toys@lists.sr.ht adding your channel as an entry in channels.scm.
CLML (Common Lisp Machine Learning) is a high performance and large scale statistical machine learning package
The Bordeaux-FFT library provides a reasonably efficient implementation of the Fast Fourier Transform and its inverse for complex-valued inputs, in portable Common Lisp.
This package exports the following function to parse floating-point values from a string in Common Lisp.
zsort is a collection of portable sorting algorithms. Common Lisp provides the sort and stable-sort functions but these can have different algorithms implemented according to each implementation. Also, the standard sorting functions might not be the best for a certain situations. This library aims to provide developers with more options.
Bind extends the idea of of let and destructing to provide a uniform syntax for all your accessor needs. It combines let, destructuring-bind, with-slots, with-accessors, structure editing, property or association-lists, and multiple-value-bind and a whole lot more into a single form.
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.
Often times we need to destructure a form definition in a Common Lisp macro. This library provides a set of simple utilities to help with that.
The Plump-SEXP library is a backend for Plump which can convert between S-expressions and the Plump DOM.
fmt provides an alternative to the Common Lisp format function by utilizing s-expressions for formatting directives instead of control strings.
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 Common Lisp package offers an implementation of the 32-bit variant of MurmurHash3 (https://github.com/aappleby/smhasher), a fast non-crytographic hashing algorithm.
This library provides a wrapper type for secret values, to reduce the risk of accidentally revealing them.
CEPL (Code Evaluate Play Loop ) is a lispy and REPL-friendly Common Lisp library for working with OpenGL.
Its definition of success is making the user feel that GPU programming has always been part of the languages standard.
The usual approach to using CEPL is to start it at the beginning of your Lisp session and leave it open for the duration of your work. You can then treat the window it creates as just another output for your graphics, analogous to how *standard-output* is treated for text.
Trivial-Benchmark runs a block of code many times and outputs some statistical data for it. On SBCL this includes the data from time, for all other implementations just the real-time and run-time data. However, you can extend the system by adding your own metrics to it, or even by adding additional statistical computeations.
ORG-SAMPLER allows using Lisp docstrings and reflection to make org-mode text for inclusion into a larger document.
This library provides a WebSocket server and client implementation for Common Lisp.
This library exports three symbols: with-raw-io, read-char, and read-line, to provide raw POSIX I/O in Common Lisp.
This package provides a stream based JSON parser/writer, well suited as building block for higher level libraries.
This is a client library to interact with the "mod.io" (https://mod.io) platform to manage "mods" or extensions for games and other applications. It covers the full v1 API and includes convenience methods to make interacting with the API as well as syncing mods and so on easy.
Vom is a logging library for Common Lisp. It's goal is to be useful and small. It does not provide a lot of features as other loggers do, but has a small codebase that's easy to understand and use.
one-more-re-nightmare is a regular expression engine that uses the technique presented in Regular-expression derivatives re-examined (Owens, Reppy and Turon, 2009; doi:10.1017/S0956796808007090) to interpret and compile regular expressions.
CHRONICITY is Common Lisp natural language date and time parser inspired by Ruby's Chronic.
Radiance is a web application environment, which is sort of like a web framework, but more general, more flexible. It should let you write personal websites and generally deployable applications easily and in such a way that they can be used on practically any setup without having to undergo special adaptations.
mito-auth provides a mito mixin class for user authorization.