Domů Procházet Nápověda
Přihlásit se
yuvallanger
/
awesome-guile
rozštěpen z ZelphirKaltstahl/awesome-guile
Sledovat 1
Oblíbit 0
Rozštěpit 0
Soubory
Strom: 90fb72ef2c
Větve Značky
awesome-guile
/
list.org

list.org 77 KB
Historie Surový

Manuals

Tutorials / Guides / Books

General GNU Guile / Scheme

Macros

CK macros

Monads

FFI - Foreign Function Interface

GUI development

Libraries

Async

Audio

Browser

Bots

Chat

Chat clients

IRC

Chat bots

IRC

(https://github.com/cadrspace/cunning-bot/blob/cadrobot/README) #+end_quote

Protocols

Matrix

Compression

Computer vision

Guile-CV is based on Vigra (Vision with Generic Algorithms), enhanced with additional algorithms (Image Textures, Delineate, Reconstruction and many more), all accessible through a nice, clean and easy to use high level API.

Guile-CV is natively multi-threaded, and takes advantage of multiple cores, using high-level and fine grained application-level parallelism constructs available in Guile, based on its support to POSIX threads.

(https://www.gnu.org/software/guile-cv/index.html) #+end_quote

Configuration

Cryptography

  • guile-gcrypt
  • git repo: https://notabug.org/cwebber/guile-gcrypt
  • description:
    • #+begin_quote Guile-Gcrypt provides a Guile 3.x/2.x interface to a subset of the GNU Libgcrypt crytographic library, which is itself used by the GNU Privacy Guard (GPG).

Guile-Gcrypt provides modules for cryptographic hash functions, message authentication codes (MAC), public-key cryptography, strong randomness, and more. It is implemented using the foreign function interface (FFI) of Guile. #+end_quote

Databases

Generic

Postgres

Sqlite

MySQL

Redis

CouchDB

Other

  • nomunofu
  • mentioned on: https://hyper.dev/blog/nomunofu.html
  • git repo: ???

Data structures

Purely functional data structures (PFDs)

RDF

Lenses

Trees

Other

  • scheme-bytestructures
  • git repo: https://github.com/TaylanUB/scheme-bytestructures
  • description:
    • #+begin_quote [...] offers a system imitating the type system of the C programming language, to be used on bytevectors. C's type system works on raw memory, and ours works on bytevectors which are an abstraction over raw memory in Scheme. The system is in fact more powerful than the C type system, elevating types to first-class status. #+end_quote
  • Treaps
  • website: http://okmij.org/ftp/Scheme/#treaps
  • description:
    • #+begin_quote An ordered dictionary data structure, based on randomized search trees (treaps) by Seidel and Aragon. Compared to red-black trees, treap is simpler and more elegant, and can get by without sentinels.

(http://okmij.org/ftp/Scheme/#treaps) #+end_quote

Debugging

#+begin_quote jump-to-debugger: like Python's pdb.set_trace(), but for Guile

The `(jtd)` module for Guile provides a procedure (jump-to-debugger) for escaping to the Guile REPL for the purpose of debugging code. It should be considered beta code, still under development.

-- https://raw.githubusercontent.com/mwette/guile-jtd/cb40b0e0f2/README.md #+end_quote

Decentralization

  • wispwot
  • repository: https://hg.sr.ht/~arnebab/wispwot/browse
  • description:
    • #+begin_quote This implements the defense from the Freenet project against disruption of communication. It is created to experiment with ways to improve the scaling and performance.

-- https://hg.sr.ht/~arnebab/wispwot #+end_quote

Development environments

  • guile-studio
  • git repo: https://git.elephly.net/gitweb.cgi?p=software/guile-studio.git;a=tree
  • description:
    • #+begin_quote Racket has Dr Racket. Guile has ... Emacs? This is Emacs with a few settings that make working with Guile easier for people new to Emacs. Features include: CUA mode, Geiser, tool bar icons to evaluate Guile buffers, support for Guile's very own picture language, code completion, a simple mode line, etc. [...] #+end_quote ([[https://git.elephly.net/gitweb.cgi?p=software/guile-studio.git;a=blob;f=README.org;hb=HEAD]])

Device management

Distributed computing

E-Mail

Encodings

Event loop

FFI - Foreign Function Interface

File formats

JSON

YAML

CSV

XML

  • Guile's standard library SXML implementation
  • GNU software manual: https://www.gnu.org/software/guile/manual/html_node/SXML.html
  • Basically your templates become functions or macros.
  • The structure of your document is kept as Scheme data structures.
  • This avoids having parse the document as a long string into an internal data structure to perform semantic transformations.
  • It enables pattern matching without resorting to things like regular expressions and similar shenanigans.

Markdown

Texinfo

JPEG

PNG

ICS

torrent

Shapefile

CBOR

  • guile-cbor
  • git repo: https://inqlab.net/git/guile-cbor.git/
  • description:
    • #+begin_quote The Concise Binary Object Representation (CBOR), as specified by RFC 8949, is a binary data serialization format. CBOR is similar to JSON but serializes to binary which is smaller and faster to generate and parse. #+end_quote

TAR

There is no standalone library for TAR files yet (2021-11-15), but there is code dealing with TAR files, which might be separatable into its own library:

  • Implementation of Ustar in Gash:
  • https://git.savannah.nongnu.org/cgit/gash/gash-utils.git/tree/gash/commands/tar.scm
  • https://git.savannah.nongnu.org/cgit/gash/gash-utils.git/tree/gash/ustar.scm
  • GNU Tar stuff:
  • https://git.savannah.gnu.org/cgit/tar.git/tree/src/tar.h
  • https://savannah.gnu.org/git/?group=tar
  • https://www.gnu.org/software/tar/

INI

Other

  • If the input is not input from users and is trustworthy, one might be able to leverage read/write of s-expressions instead of using other formats.

File system

Game development

#+begin_quote gzochi (zoʊ-tʃiː) is a programming framework for developing online games in GNU Guile, and a distributed middleware container that hosts your games for thousands of connected players. gzochi takes care of the hard parts of online game development - concurrency, data persistence, and network communications - so you can focus on the stuff that matters! #+end_quote

(https://www.nongnu.org/gzochi/)

Games

#+begin_quote Dryads Wake is a game of dialogue and choices. (https://hg.sr.ht/~arnebab/dryads-wake) #+end_quote

Generators

Genomics

  • sparqling-genomics
  • git repo: https://github.com/UMCUGenetics/sparqling-genomics
  • description:
    • #+begin_quote This project provides programs to extract RDF triplets from commonly used file formats in genomics. It also provides a web-based environment to explore the RDF triplets once inserted in a triple store.

Graphics

Image processing

Design and CAD

#+begin_quote "libfive is a software library and set of tools for solid modeling, especially suited for parametric and procedural design. It is infrastructure for generative design, mass customization, and domain-specific CAD tools."

-- https://libfive.com/ (2021-05-13) #+end_quote

libfive itself is not written in GNU Guile, but interaction with it include using GNU Guile as a modelling language.

GUI development

GNU Guile is an implementation of Scheme, which is a Lisp-like language. This library allows Guile to use GObject-based libraries -- such as GTK+3, GLib, and WebKit2 -- by generating a Scheme API from the GObject Introspection information provided by those libraries.

[...]

-- https://raw.githubusercontent.com/spk121/guile-gi/c4a9b8d11d/README.md #+end_quote

Language

Logging

Machine Learning

  • AIscm
  • website: http://wedesoft.github.io/aiscm/
  • description:
    • #+begin_quote AIscm is a Guile extension for numerical arrays and tensors. Performance is achieved by using the LLVM JIT compiler.

(http://wedesoft.github.io/aiscm/) #+end_quote

Macros

  • guile-for-loops
  • mercurial repo: https://hg.sr.ht/~bjoli/guile-for-loops
  • description:
    • #+begin_quote A re-implementation of a large-ish chunk of rackets for-macros. It is mostly compatible with racket's macros, with the largest omission being the body-or-break clause and some of the sequence iterators (like in-cycle, which can be covered by circular lists). There are other differences of course, like for/foldr not being on par feature-wise, and all the nicities you get by having a generic sequence interfce.

[...]

(https://hg.sr.ht/~bjoli/guile-for-loops/browse/README.md?rev=580d3fb365) #+end_quote

#+begin_quote goof-loop - a scheme looping facility

goof-loops aims to be an amalgamation of the racket for loops and Alex Shinn's (chibi-loop). We are many that found racket's for loops a breeze of fresh air, but in the end their most general forms (for/fold and for/foldr) are kinda odd to work with. If you choose not to use those general for loops, you cannot express arbitrary transformations, like say a fibonacci sequence, since for clauses cannot reference eachother. goof-loop tries to fix this [...]

-- https://git.sr.ht/~bjoli/goof-loop/tree/cccc324ecd/item/README.md #+end_quote

  • megacut macro:
  • mercurial repo: https://hg.sr.ht/~bjoli/megacut
  • description:
    • #+begin_quote This is a clojure-like lambda shorthand for guile. The macro is called megacut (which is a bad name, since it is not much like cut).

(https://hg.sr.ht/~bjoli/megacut/browse/readme.txt?rev=75caf96aa4) #+end_quote

Message Queues

Network programming

  • Scheme-GNUnet
  • git repository: https://git.gnunet.org/gnunet-scheme.git/
  • description:
    • #+begin_quote Scheme-GNUnet is a WIP (Guile) Scheme port of the GNUnet client libraries. Unlike gnunet-guile, it is not a binding for the C libraries. It can be used in multi-threaded applications, e.g. with guile-fibers.

It is not to be confused with https://git.gnunet.org/gnunet-guile2.git and https://git.savannah.gnu.org/cgit/guix/gnunet.git, which implement bindings for the C libraries and support a different set of services.

Parallelism

  • standard library futures
  • GNU software manual page: https://www.gnu.org/software/guile/docs/docs-2.2/guile-ref/Futures.html (link to Guile 2.2 docs -- Where are the 3.x docs?)
  • description:
    • #+begin_quote [...] a construct for fine-grain parallelism. A future is a wrapper around an expression whose computation may occur in parallel with the code of the calling thread, and possibly in parallel with other futures. Like promises, futures are essentially proxies that can be queried to obtain the value of the enclosed expression [...] #+end_quote

Parsing

Parser Combinators

Parser Generator

Other

(https://www.gnu.org/software/guile/manual/html_node/PEG-Parsing.html) #+end_quote

XML parser

Plotting

Protocols

Serialization

  • guile-msgpack
  • git repo: https://gitlab.com/HiPhish/guile-msgpack
  • description:
    • #+begin_quote This is a GNU Guile library implementing the MessagePack data serialisation format. It allows you to serialise (pack) and de-serialise (unpack) Scheme objects to and from binary data according to the MessagePack format.

(https://gitlab.com/HiPhish/guile-msgpack/-/blob/master/README.rst) #+end_quote

SRFI (Scheme Request For Implementation) implementations

Strings

Syntax

Regular expressions

REPL (Read Eval Print Loop)

RPC (Remote Procedure Call)

  • ~guile-xmlrpc~:
  • description:
    • #+begin_quote guile-xmlrpc is an XMLRPC module for Guile. Guile already has the wonderful sxml module that allows XML document creation and parsing. guile-xmlrpc goes one step further and combines sxml with some macros and procedures that simplifies even more the creation and parsing of XMLRPC documents.

Scientific computing and mathematics

(https://www.cs.rochester.edu/~gildea/guile-scmutils/) #+end_quote

  • Guile implementation of symbolic mathematics shown in SICP
  • Does this exist?

Interaction with the Jupyter ecosystem

Search engine

  • babelia
  • git repo: https://github.com/amirouche/babelia
  • description:
    • #+begin_quote Wanna be search engine with federation support

(https://github.com/amirouche/babelia) #+end_quote

Shell

#+begin_quote Gash is a POSIX-compatible shell written in Guile Scheme. It provides both the shell interface, as well as a Guile library for parsing shell scripts. Gash is designed to bootstrap Bash as part of the Guix bootstrap process. We are planning to develop Gash into a general-purpose shell and tool for building interfaces between Scheme and the shell. #+end_quote

(https://git.savannah.nongnu.org/cgit/gash.git/tree/README?id=8f9b973264cc799df27795df6230839e96dc00eb)

TUI development

To query and change settings of serial devices on POSIX systems, the termios API is used. GNU Guile doesn't have an interface for that built in. This module implements this interface by use of Guile's dynamic FFI.

[...]

Testing

Integration testing

Unit testing

TAP output

Other

  • guile-quickcheck
  • git repo: https://git.ngyro.com/guile-quickcheck
  • website: https://ngyro.com/software/guile-quickcheck.html
  • description:
    • #+begin_quote This Guile library provides tools for randomized, property-based testing. It follows closely the QuickCheck library written in Haskell, with inspiration from the Racket version. You can use it to define a property (a predicate with specifications for its inputs) and test it by generating many random inputs and seeing if it holds.

-- https://ngyro.com/software/guile-quickcheck.html #+end_quote

  • guile-proba
  • git repo: https://codeberg.org/luis-felipe/guile-proba
  • description:
    • #+begin_quote Guile Probá is a set of testing tools for GNU Guile projects with SRFI 64-based test suites. It comes with a command-line interface that allows you to autodiscover tests and run them, and a library that includes a test runner and helpers for writing tests.

-- https://codeberg.org/luis-felipe/guile-proba/src/commit/f6b235072e/README.org #+end_quote

Types

Static typing

  • Theme-D
  • source code: on website at: https://www.tohoyn.fi/theme-d/download.html
  • description:
    • #+begin_quote Programming language Theme-D extends Scheme with static typing. The current Scheme platform is guile 3.0 but the software works for guile 2.2, too. Theme-D resembles Jaap Weel's Theme but Theme-D is more dynamic and the objects in Theme-D need to have type tags. See Theme-D-Golf for GNOME bindings to Theme-D.

Version control systems

Web Development

Web servers

Web clients

Web frameworks

  • SPH web app
  • git repository at GitHub: https://github.com/sph-mn/sph-web-app
  • Tekuti
  • git repository at GutHub: https://github.com/wingo/tekuti
  • blog post about tekuti: https://wingolog.org/projects/tekuti/
  • description: "Server-side blog engine written in Scheme" (see repository), web blog using Git as its persistent store

Protocols

Web sockets

Tooling / Additional libraries

  • guile-html
  • git repo: https://github.com/TaylanUB/guile-html
  • description:
    • #+begin_quote A tiny module to make it less annoying to make and write HTML files using SXML. Read the code! #+end_quote

Authorization and authentication

Static website generators

Template engine

  • Guile's standard library SXML implementation
  • GNU software manual: https://www.gnu.org/software/guile/manual/html_node/SXML.html
  • Basically your templates become functions or macros.
  • The structure of your document is kept as Scheme data structures.
  • This avoids having parse the document as a long string into an internal data structure to perform semantic transformations.
  • It enables pattern matching without resorting to things like regular expressions and similar shenanigans.

Interaction with services

Web application examples

Web drivers / Selenium

Window manager

Working with code

This software aims to support several Scheme implementations. To achieve this, the code is designed to contain as much logic as possible in R7RS Scheme, separating implementation-specific code in different directories.

Note: this code is still in an early development stage and the API may change. Change suggestions are welcome.

Other

(https://www.nongnu.org/guile-lib/) #+end_quote

  • Spells
  • git repo: https://github.com/rotty/spells
  • description:
    • #+begin_quote Spells is a collection of R6RS libraries providing features beyond R6RS in a uniform way across supported implementations.
  • SPH website:
  • It has some Guile library and project descriptions and links.
  • http://sph.mn/

#+begin_quote The idea is similar to the one expressed in Guile-Lib, that is, a place for people to collaborate to the development of a common library, though less intimidating maybe and, unlike Guile-Lib, Grip will tolerate, under strict conditions, some C code: this is notably to support and boost Guile-CV floating point operations, at least till Guile has an AOT compiler, able to offer similar performance results for fixed size floating points and integer operations. #+end_quote

(https://www.nongnu.org/grip/index.html)

Unsorted

#+begin_quote This library contains three scheme modules targetted at GNU Guile. The (communication lfsr) module implements linear feedback shift registers as infinite streams of bits. LFSRs are used, for example, to generate chip sequences in CDMA systems, for synchronising preambles or as pseudo random number generators. The module implements LFSRs in both Fibonacci and Galois configurations.

  • guile-e-series
  • git repository: https://gitlab.com/ft/guile-e-series
  • description:
    • #+begin_quote -------------------------------- E-Series Tools for GNU Guile --------------------------------

The E-Series are series of preferred numbers, commonly used to specify electro- nic parts; mostly resistors, inductors and capacitors. This library implements two kinds of lookups: a) Given a value, look up that value in all E-series and return the values surrounding the desired value; and b) Given an integer that identifies an E-Series and a desired value, return combinations of two parts, that approximate the desired value as closely as possible.

[...]

Projects

  • Guile 100
  • description:
    • #+begin_quote This is the repository for the Guile 100 Programs project. This is a collaborative effort to create a set of examples on how Guile might be used for real-world problems.

Programming paradigm

"Object-oriented programming"

Prototype based

Relational programming

Functional programming

  • Genshou: Extensible effects
  • website: https://git.sr.ht/~wklew/genshou
  • description: Implementation of a way to encapsulate side effects based on
    • [[http://okmij.org/ftp/Haskell/extensible/]]. It helps dealing with side effects in a functional way.

Programming language concepts

Pipeline / pipe / chain / threading

State Machines

Programs

Finances

Window manager

Other

  • Starlet
  • repository: https://github.com/taw10/starlet
  • description:
    • #+begin_quote Starlet is an experimental Lisp-based domain-specific language (DSL) for theatrical lighting control. It's based on Guile and sends its DMX output via OLA to almost any type of lighting control interface - DMX, sACN, Art-Net etc.

-- https://github.com/taw10/starlet/blob/79df0f8c32/README.md #+end_quote

Tools

Notes

Editor support

  • guile.vim
  • git repo: https://gitlab.com/HiPhish/guile.vim
  • description:
    • #+begin_quote This plugin extends Vim's Scheme support to include the additions to the language provided by the GNU Guile implementation. The plugin automatically detects whether a Scheme file is a Guile file and adds syntax highlighting for Guile's special forms.

(https://gitlab.com/HiPhish/guile.vim/-/blob/master/README.rst) #+end_quote

  • repl.nvim
  • git repo: https://gitlab.com/HiPhish/repl.nvim/
  • description:
    • #+begin_quote REPL.nvim bring REPL support to Nvim! Use the built-in REPLs, add your own, or change the existing ones. Change settings in your init.vim or on the fly, make them global or local, use the existing ones or make your own.

(https://gitlab.com/HiPhish/repl.nvim/-/blob/master/README.rst) #+end_quote

  • Emacs Guile support
  • guile-ide
  • repository: https://framagit.org/Jeko/guile-ide
  • description: Emacs configuration file focusing on Guile development
  • flycheck-guile
  • geiser-guile
  • TODO: other editors support

Project management

Package managers

  • guildhall
  • git repository at GitHub: https://github.com/ijp/guildhall
  • Akku
  • website: https://akkuscm.org/
  • description:
    • #+begin_quote Akku.scm is a language package manager for Scheme. It grabs hold of code and vigorously shakes it until it behaves properly.

(https://akkuscm.org/) #+end_quote

Time tracking

#+begin_quote GNU Foliot is a small and easy to use time keeping application.

It can be used in a single user mode or by small organizations. Starting with version 0.9.4, it can import other user's database, an essential feature for remote collaborators.

The fields it handles are: a date, who, for whom, what, a duration, whether or not to be charged and a description.

It includes, on the main application screen, a powerful dynamic filters criteria mechanism, which lets you visualize, work on and print a subset of your time keeping entries.

A printing templates system allows you to (pre)define, reuse and hence quickly generate the pdf files and/or printed reports of your needs.

A version which will let users export an active filter based subset of their time keeping entries is under work. #+end_quote

(https://www.gnu.org/software/foliot/index.html)

Build tools

  • potato-make
  • repository: https://github.com/spk121/potato-make
  • description:
    • #+begin_quote Potato Make is a scheme library that aims to simplify the task of maintaining, updating, and regenerating programs. It is inspired by the make utility in POSIX. With this library, you can write a build script in Guile Scheme.

-- https://github.com/spk121/potato-make/blob/5e823c5f5a/README.md #+end_quote

Blogs

Other

(https://github.com/alpardal/SICP-guile) #+end_quote

  • Guile-BAUX
  • git repo: https://git.savannah.nongnu.org/cgit/guile-baux.git
  • description: A loose collection Guile modules:
    • #+begin_quote Guile-BAUX is a collection of scripts and modules intended to be installed in your project’s aux dir (i.e., build-aux/, or equivalent dir specified by AC_CONFIG_AUX_DIR in configure.ac). There are modules for:
  • extracting documentation / generating texinfo
  • doing (Scheme) source-source scanning / transforming
  • constructing / displaying modules’ dependency graph
  • generating C boilerplate

[...]

-- https://www.gnuvola.org/software/guile-baux/guile-baux.pdf #+end_quote

  • gclip-select
  • git repo: https://git.savannah.nongnu.org/cgit/gclip-select.git
  • description:
    • #+begin_quote This is gclip_select, a small program that allows you to re-select from the text lines that were selected at one time or another as the X Primary Selection. This is useful when, in X Windows, if you have selected something using the left mouse button (as in the convention of the X Windows System) and you later select something else but want to get back to the earlier selection.

Thus this program allows you to quickly switch between frequently copied texts for pasting. When you select some text you will notice gclip_select window adds the newly selected text to the list. And you can choose any earlier selection in the list window to make it the X11 primary selection again; you can then paste it using the middle mouse button.

-- https://git.savannah.nongnu.org/cgit/gclip-select.git/tree/README?id=b78bc3cd2d #+end_quote

Other lists of Guile software

Videos / Talks / Presentations

This category is still fairly empty. Help filling it with interesting GNU Guile related videos, talks or presentations!