The version 3.5a is a major version. It improves portability on
Arm/Android in particular by supporting native multi-threaded
applications. This version also supports new APIs and fixes many
glitches of the version 3.4a.

This version has been successfully installed on the following platforms:

* x86/32, Linux 2.6, Arch Linux.

* x86/64, Linux 2.6, Fedora.

* Arm v6/v7, Linux, Maemo4/Maemo5, Android.

* PowerPC G3, Linux, Debian.

* x86/32, Windows SP2, MinGW.

* x86/32, Mac OS X 10.5 Leopard,

* x86/64, Mac OS X 10.6 SnowLeopard,

Announce of previous Bigloo release (3.4a):
supporting
two extra platforms Arm/Android and OSGi bundles. This version also
supports new APIs and fixes many glitches of the version 3.3a.

Announce of previous Bigloo release (3.3a):
new compilation framework that support cross-compilation.

Announce of previous Bigloo release (2.4c):
* Bigloo is now available to Mac OS X users. The native back-end
supports
this architecture.

* In addition to RGC, Bigloo now supports posix regular expressions,
by the mean of the Dorai Sitaram pregexp package.

* Bigloo supports SRFI-22.

Announce of previous Bigloo release (2.4a):
* Bigloo is now available for Win32 users by the means of two packages:

- the standard source package that requires Cygwin.
- A precompiled version that entirely relies on the JVM
back-end. That
package only requires JDK 1.3 or higher installed.

* Bigloo is now case sensitive (with a backward compatibility mode).

Announce of previous Bigloo release (2.3a):
JVM back-end (a join work with Bernard Serpette). That is, Bigloo can
compile Scheme program to C for efficiency or to JVM for
portability. Using the Bigloo C back-end, Scheme programs can be mixed
with C programs, using the Bigloo JVM back-end, Scheme programs can be
mixed with Java programs. The distribution contains examples of both
connections.

Announce of previous Bigloo release (2.2a):
It contains a new installation/configure procedure, a new file
hierarchy, a new version of the garbage collector and a support
for new programming tools.

Announce of previous Bigloo release (2.1c):
It supports for SRFI-6, SRFI-8 and SRFI-9. It adds some extra facilities
(such as dynamic loading, command line parsing support). It improves
user errors detection and report (better source file positioning). In
addition, some new compiler optimizations have been implemented (in
particular
generic arithmetic is now optimized).

Announce of previous Bigloo release (2.1b):
It supports for SRFI-6 and SRFI-8. It adds some extra facilities (such
as printing/reading circular data structures).

Announce of previous Bigloo release (2.1a):
important, Bigloo2.1 is provided with new facilities for better
support for debugging and profiling.

* Object introspection facilities
-------------------------------
The Bigloo1.9 object system has been extended by the addition of
some introspections library functions. Classes are now able to
deliver access and mutation functions to their instance's fields.

Bigloo 1.9 is at a departure point from the Scheme programming
language as defined in the RnRS report. The main goal of Bigloo
is to allow a Scheme based programming style where C(++) is
usually required. Bigloo attempts to make Scheme practical by
offering features usual to traditional programming languages but
unusual to Scheme:

* An extended foreign interface
-----------------------------
C code and Bigloo code can be merged together. Bigloo functions
can call C functions and vice-versa, Bigloo code can use C global
variables and vice-versa. Bigloo functions and variables can hold
C values (C type value). C values can be allocated from Bigloo
program and vice-versa, Bigloo data structures can point to C
data structures and vice-versa.

* A batch compiler
----------------
Bigloo compiles modules. Bigloo is a batch compiler. It does not
relies on a read-eval-print loop.

* An explicit type system and compile time type mismatch detections
-----------------------------------------------------------------
Bigloo programs may contain type annotations. Bigloo programs are
encouraged to contain type annotations. Type annotations hold
on variables, function parameters and function results. Type
annotations help the compiler in the task of static type
mismatch detections and they help the compiler to produce more
efficient code.

* Simple exceptions
-----------------
Bigloo discourages the use of call/cc. Instead it proposes
dynamic
exceptions a la Common Lisp (by the means of three constructions:
`try' that catch errors, `bind-exit' that binds an exception and
`unwind-protect' that protects a piece of code from exceptions).

* Practical IOs by the means of lexing and parsing tools
------------------------------------------------------

For those who already knows Bigloo
also contains some improvements of the already existing features:
- Improvement of the Object layer compilation:
i) Generic functions are now compacted (the memory space used by
generic
functions is smaller). This has a very little impact on performance.
ii) Class accessors are now handled more efficiently. That is, the
code generated for class accessors is much smaller.
- Cleanup over class indexed fields.
- Mutable recursive class instances can now be instantiated by the
means of
the CO-INSTANTIATE form.
- Enhanced introspection support.
- New hash tables API (` la Java). New hash tables are now i) more
convenient to use ii) more efficient.
- Serializer/deserializer can now be customized for procedures and
opaques
values.

At last, many thanks to all of you that are providing an inestimable help.