Guile

Guile is a library designed to help programmers create flexible applications. Using Guile in an application allows programmers to write plug-ins, or modules (there are many names, but the concept is essentially the same) and users to use them to have an application fit their needs.

There is a long list of proven applications that employ extension languages. Successful and long-lived examples in the free software world are GNU Emacs and The GIMP.

Very popular examples of extending server applications are the Apache projects Perl and PHP modules.

Extension languages allow users, programmers, and third-party developers to add features to a program without having to re-write the program as a whole, and it allows people extending a program to co-operate with each other, without having to expend any extra effort.

Guile is an interpreter for the Scheme programming language, packaged as a library which can be incorporated into your programs. Your users have full access to the interpreter, so Guile itself can be extended, based on the needs of the user. The result will be a scripting language tailored to your application.

Using Guile with your program makes it more usable. Users don't need to learn the plumbing of your application to customize it; they just need to understand Guile, and the access you've provided. They can easily trade and share features by downloading and creating scripts, instead of trading complex patches and recompiling their applications. They don't need to coordinate with you, or anyone else.

What is new in this release:

• This version adds SRFI-105 curly infix expressions, per-port reader options, nested futures, functional record setters, a port interface to HTTP bodies, more optimizations, better load path and compiled load path handling, and the usual long list of bugfixes.

What is new in version 1.8.8:

• Maintenance release for the 1.8 stable series.

What is new in version 1.9.9:

• Faster dynamic binding with fluids
• `fluid-ref' and `fluid-set' now have dedicated bytecode instructions.
• Dynamic binding via `with-fluids' or `with-fluids*' no longer causes
• recursive VM invocations, nor closure allocation of the body. Unused
• fluid numbers are now garbage-collected.
• Incompatible Tree-IL changes:
• There were a number of incompatible changes made in the last cycle
• regarding Tree-IL, Guile's high-level intermediate language. See the
• change logs for details. If these affected you, clearly you need to
• submit your compiler patches upstream!
• Prompts: Delimited, composable continuations:
• Guile now has prompts as part of its primitive language. See "Prompts"in the manual, for more information.
• Expressions entered in at the REPL, or from the command line, are surrounded by a prompt with the default prompt tag.
• Deprecated:`lazy-catch' was a form that captured the stack at the point of a `throw', but the dynamic state at the point of the `catch'. It was a bit
• crazy. Please change to use `catch', possibly with a throw-handler, or`with-throw-handler'.
• 'catch', `throw', `with-throw-handler' implemented in Scheme
• This doesn't have any end-user impact, but we're so proud of being able to implement these constructs in terms of prompts and fluids, while not changing the user API, that we need to mention it in the NEWS. Thanks for reading!
• Current-module tracking in the syntax expander:
• Expanding a `begin' expression that changed the current module via an`eval-when' wasn't working, due to a bug. This was fixed.
• Backtraces at the REPL don't show REPL frames
• The 1.9 series has had overly verbose backtraces, which showed frames internal to the implementation of the REPL. This has been mostly fixed.
• Please report bugs to bug-guile@gnu.org.
• Additions to the foreign function interface (FFI)
• The `(system foreign)' module now provides additional foreign types corresponding to C's `int', `long', `size_t', etc.
• In addition, the `dynamic-link' procedure can now be called without any argument, in which case it returns a "global symbol handle", allowing symbols currently available to the program to be looked up.
• Documentation of `syntax-rules' macros:
• The documentation of macros in the manual is now separate from that of procedures. A new section on `syntax-rules' macros has been added.
• Effective version bump to 2.0:
• Guile has had an "effective version" for some time, typically generated as "MAJOR-VERSION.MINOR-VERSION". This release decouples the effective version from the actual version, setting it prematurely to 2.0. This should shake out any version-related distribution bugs.
• Parallel installability fixes:
• Guile now installs its header files to a effective-version-specific directory, and includes the effective version (e.g. 2.0) in the library name (e.g. libguile-2.0.so).
• This change should be transparent to users, who should detect Guile via the guile.m4 macro, or the guile-2.0.pc pkg-config file. It will allow parallel installs for multiple versions of Guile development environments.