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.

This is a collection of iteration macros for Guile. They are inspired by racket's family of iterators. Specifically, the following iterators are available:

• for

• for/map

• for/c

• for/fold

• for/fold-right

• for/folder

• folder

Emacsy is an embeddable Emacs-like library that uses GNU Guile as extension language. Emacsy can give a C program an Emacsy feel with keymaps, minibuffer, recordable macros, history, tab completion, major and minor modes, etc., and can also be used as a pure Guile library. It comes with a simple counter example using FreeGLUT and browser examples in C using Gtk+-3 and WebKitGtk.

guile-ini is a GNU Guile library for working with the INI format. This library provides API for reading and writing INI data.

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 _)).

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).

This package provides Guile FFI bindings for CBLAS, the library of linear algebra subprograms.

To use the bindings, import (ffi cblas). CBLAS will be loaded from the default dynamic library path. There are up to three bindings for each function: raw, typed, and functional.

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).

Schmutz is a header-only library to declare Scheme bindings for C++ code using a simple embedded DSL. Think of it as Boost.Python or LuaBind but for Scheme.

Guile-Reader is a simple framework for building readers for GNU Guile.

The idea is to make it easy to build procedures that extend Guile’s read procedure. Readers supporting various syntax variants can easily be written, possibly by re-using existing “token readers” of a standard Scheme readers. For example, it is used to implement Skribilo’s R5RS-derived document syntax.

Guile-Reader’s approach is similar to Common Lisp’s “read table”, but hopefully more powerful and flexible (for instance, one may instantiate as many readers as needed).

This package provides bindings for Newt, a programming library for color text mode, widget based user interfaces. The bindings are written in pure Scheme by using Guile’s foreign function interface.

GNU Guile QR code generator that can create QR codes from text and binary data. The resulting QR codes can be rendered to ASCII art strings or to PNG images (using Guile-PNG API.)

This package provides Guile modules to access the REST API of Mastodon, a federated microblogging service.

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 is an R6RS Scheme adaptation of the packrat parsing. Packrat parsing is a memoizing, backtracking, recursive-descent parsing technique that runs in time and space linear in the size of the input text.

The (file-names) module provides tools for manipulating file names. The module was built on the idea that doing anything more than a non-trivial modification of a file name string is a pain (making sure all slashes are present and accounted for, resolving . and .., etc). Inevitably, you have to break the string up into chunks and operate on that list of components. This module takes care of that for you.

This package provides a simple SVG-based picture language for Guile. The picture values can directly be displayed in Geiser.

This is an R6RS library for working with packed byte structures. It is similar to struct in Python or pack and unpack in Perl.

Guile Config is a library providing a declarative approach to application configuration specification. The library provides clean configuration declaration forms, and processors that take care of: configuration file creation; configuration file parsing; command-line parameter parsing using getopt-long; basic GNU command-line parameter generation (--help, --usage, --version); automatic output generation for the above command-line parameters.

Guile-ICS is an iCalendar (RFC5545) and vCard (RFC6350) format parser library written in pure Scheme. The library can be used to read and write iCalendar/vCadr data and convert the data from/to various formats.

The library is shipped with documentation in Info format and usage examples.

This project provides a pure Scheme implementation of Protocol Buffers, including parsing and code generation.

Guile-Lens is a library implementing lenses in Guile. The library is currently a re-implementation of the lentes library for Clojure. Lenses provide composable procedures, which can be used to focus, apply functions over, or update a value in arbitrary data structures.

This package provides an implementation of AA trees, a self-balancing binary tree data structure, for Guile. It ensure O(log n) worst case performance for core operations. The module provides non-mutating insert, delete, and search operations, with support for convenient nested tree operations.

Guile-Bash provides a shared library and set of Guile modules, allowing you to extend Bash in Scheme. Scheme interfaces allow you to access the following aspects of Bash:

• aliases;

• setting and getting Bash variables;

• creating dynamic variables;

• creating Bash functions with a Scheme implementation;

• reader macro for output capturing;

• reader macro for evaluating raw Bash commands.

To enable it, run:

enable -f ~/.guix-profile/lib/bash/libguile-bash.so scm

and then run scm example.scm.