Software Map

Dolda Connect is a modular P2P filesharing client
built around the Direct Connect model. It supports
most of the latest features of the DC protocol. It
runs in client/server mode with a well defined
protocol, allowing extensibility, flexibility, and
multiple detachable user interfaces. It also has
an optional multi-user mode.

Scwm is the Scheme Constraints Window Manager, a highly dynamic and extensible window manager for the X Window System. Scwm embeds Guile Scheme as the configuration and extension language, and includes a sophisticated constraint solver for permitting the user to interactively specify constraints among top-level window sizes and positions. Nearly all decorations can be changed at runtime on a per-window basis. Dynamic loading of C modules is supported. Scwm is self-documenting and provides a powerful protocol for interacting with the window manager from other processes.

ncurses wrapper for guile allows you to write applications in the guile scheme dialect using the ncurses library.

GeneRecon is a software package for linkage
disequilibrium mapping using coalescent theory. It
is based on a Bayesian Markov-chain Monte Carlo
(MCMC) method for fine-scale
linkage-disequilibrium gene mapping using
high-density marker maps. GeneRecon explicitly
models the genealogy of a sample of the case
chromosomes in the vicinity of a disease locus.
Given case and control data in the form of
genotype or haplotype information, it estimates a
number of parameters, most importantly, the
disease position.

The Inline::Guile module allows you to add blocks
of Scheme code to your Perl scripts and modules.
Any procedures you define in your Scheme code will
be available in Perl. The Guile module provides
full access to the GNU Guile Scheme interpreter.

Js2Scheme compiles JavaScript to Scheme so that it can be processed by Bigloo. It also includes a pretty-printer and a (rudimentary) obfuscator.

Orion is a window manager for the X11 windowing
system. It is written in Scheme and accesses Xlib
via the scx library for scsh. It is in fact a
family of window managers that can be nested. This
enables great flexibility and efficient handling
of X11 applications. It currently comes with four
child window managers: a conventional moving
window manager, a window manager for stacking
windows in a frame, a window manager for splitting
windows horizontally, and vertically and a work
space manager. It also supports saving the window
manager layout and programmatic configuration.

Momoko is a generic, object-oriented, modular, extensible environment for creating multi-user environments. It is suitable for writing MUDs, servers, and community-based Web sites. It is written in pure Java and supports Java and Python as internal scripting languages. Momoko provides facilities for organizing objects into tree-based hierarchies, orthogonal persistence, a transparent distributed objects system, remote access to source code and user files via WebDAV, a telnet-enabled shell for manipulating the object database, and an integrated build process which can be triggered remotely.

Kahua is a continuation passing style (CPS)
application framework and server. It is written
using the Gauche implementation of Scheme. It has
the advantage that you can use "continuations"
easily, so you can solve the typical Web
application's problem of process disconnection. It
allows you to program declaratively by using
S-expressions as a fundamental data type, you can
use Kahua's Object Database to persist data, and
you can modify the function being run, supporting
incremental development.

L2T extracts excerpts of Lisp (Scheme), C, or Perl code from files and incorporates them, for instance, into TeX files. It can also conveniently pretty-print or convert parenthetic Sexpressions into trees, drawings, Greek denotations, etc.

TinyScheme is a lightweight Scheme interpreter that implements as large a subset of R5RS as possible without getting very large and complicated. It is meant to be used as an embedded scripting interpreter for other programs. As such, it does not offer IDEs or extensive toolkits although it does sport a small top-level loop, included conditionally. A lot of functionality in TinyScheme is included conditionally, and it allows multiple interpreter states to coexist in the same program without any interference between them. Foreign functions in C can also be added and values can be defined in the Scheme environment.

G-Wrap is a tool (and Guile library) for
generating function wrappers for inter-language
calls. It currently supports generating Guile
wrappers for C functions.

vrml-scm is a VRML (Virtual Reality Modelling Language) parser written in scheme. The parser strictly conforms to the VRML 1.0 standard. It implements only parsing and syntactic checking. There is no semantic checking of the data. The scheme module is self-contained, and has been tested in guile and Bigloo.

EPOR is an extensible package organiser for
Unix-like systems. It's written to trace
filesystem changes (something being installed) and
save this information in a simple text database
(this, as any other provided feature, is
customisable via the embedded Guile interpreter).
Database entries contain information supplied by
the command line (package name, version, etc.) and
traced by filesystem changes (new directories,
files, etc.). This is achieved using the
"LD_PRELOAD method''.