This package provides A Guile reader extension for `raw strings', it lets you write verbatim strings without having to escape double quotes.

guile-email is a collection of email utilities implemented in pure guile. It supports parsing MIME (Multipurpose Internet Mail Extensions) compliant email messages and reading emails from the mbox format.

Guile OpenAI is an implementation of the OpenAI API in Guile Scheme, providing a convenient interface for interactive programming with their AI models.

Guile-Daemon is a small Guile program that loads your initial configuration file, and then reads and evaluates Guile expressions that you send to a FIFO file.

This package provides Guile bindings to the Tree-sitter parsing library.

Irregex is an s-expression based alternative to your classic string-based regular expressions. It implements SRFI 115 and is deeply inspired by the SCSH regular expression system.

The (hashing …) modules implement cryptographic hash functions in pure R6RS Scheme: CRC, HMAC, MD5, SHA-1, and SHA-2 (SHA-256, SHA-512).

This package provides a complete Scheme implementation of miniAdapton, which implements the core functionality of the Adapton system for incremental computation (also known as self-adjusting computation). Like Adapton, miniAdapton allows programmers to safely combine mutation and memoization. miniAdapton is built on top of an even simpler system, microAdapton. Both miniAdapton and microAdapton are designed to be easy to understand, extend, and port to host languages other than Scheme.

This library provides a reference implementation for SRFI-197. This SRFI defines a family of chain and nest pipeline operators, which can rewrite nested expressions like (a b (c d (e f g))) as a sequence of operations: (chain g (e f _) (c d _) (a b _)).

Lokke intends to provide a full dialect of Clojure for Guile. It also consists of a set of Guile modules providing some of Clojure's functionality in two different guises.

Guile-ERIS is a Guile implementation of the Encoding for Robust Immutable Storage (ERIS). ERIS allows arbitrary content to be encoded into uniformly sized, encrypted blocks that can be reassembled using a short read-capability.

Guile-GI is a library for Guile that allows using GObject-based libraries, such as GTK+3. Its README comes with the disclaimer: This is pre-alpha code.

This package provides bindings for GNU Parted library, a C library allowing disk partition tables creation and manipulation. The bindings are written in pure Scheme by using Guile's foreign function interface.

This package provides tooling to write web applications in Guile, such as signed sessions, multipart message support, etc.

MiniKanren is a relational programming extension to the Scheme programming Language, written as a smaller version of Kanren suitable for pedagogical purposes. It is featured in the book, The Reasoned Schemer, written by Dan Friedman, William Byrd, and Oleg Kiselyov.

This is Ian Price's r6rs packaged version of miniKanren, which deviates slightly from miniKanren mainline.

See http://minikanren.org/ for more on miniKanren generally.

This library implements parts of the JSON-RPC specification, allowing for calling methods on remote servers by exchanging JSON objects.

This package provides SRFI-145. This provides the means to denote the invalidity of certain code paths in a Scheme program.

This package provides a Scheme wrapper around liblmdb.so. Most names are the same as LMDB ones, except for prefix absence. Several conveniences are added on top:

• call-with-env-and-txn, call-with-cursor, and call-with-wrapped-cursor helpers and respective with- macros.

• for-cursor procedure for cursor iteration.

• val and stat types.

• set-compare! and set-dupsort! to configure entry sorting.

• Error signaling instead of integer return values.

Haunt is a static site generator written in Guile Scheme. Haunt features a functional build system and an extensible interface for reading articles in any format.

Fibers is a Guile library that implements a a lightweight concurrency facility, inspired by systems like Concurrent ML, Go, and Erlang. A fiber is like a "goroutine" from the Go language: a lightweight thread-like abstraction. Systems built with Fibers can scale up to millions of concurrent fibers, tens of thousands of concurrent socket connections, and many parallel cores. The Fibers library also provides Concurrent ML-like channels for communication between fibers.

Note that Fibers makes use of some Guile 2.1/2.2-specific features and is not available for Guile 2.0.

This package provides a library (lsp-server) and an executable guile-lsp-server that can be used by LSP clients in order to provide IDE functionality for Guile Scheme.

Guile Documentá is a command-line program and accompanying library to generate API documentation for GNU Guile projects.

Gulie-CoAP is a Guile implementation of the Constrained Application Protocol (CoAP). CoAP is a network transport protocol specialized for use with constrained nodes and constrained networks (e.g. low-power, lousy). This library implements basic serialization of CoAP messages over UDP (RFC 7252) and TCP (RFC 8323) as well as an asynchronous TCP client (using guile-fibers).

This Guile library provides tools for reading, comparing, and writing Semantic Versions. It also includes ranges in the style of the Node Package Manager (NPM).