Skip to content


Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
A native compiler for Scheme compliant with R6RS
tag: 0.2d9

Fetching latest commit…

Cannot retrieve the latest commit at this time

Failed to load latest commit information.


                             Vicare Scheme


  1. Introduction
  2. License
  4. Install
  5. Testing
  A. Credits
  B. Bug reports
  C. Resources

1. Introduction

Scheme is  a statically scoped  and properly tail--recursive  dialect of
the  Lisp programming  language invented  by  Guy Lewis  Steele Jr.  and
Gerald Jay Sussman.  It was  designed to have an exceptionally clear and
simple semantics and few different ways to form expressions.

  The  "Revised^6 Report  on the  Algorithmic Language  Scheme"  gives a
defining description of the  programming language Scheme.  The report is
the work  of many  people in the  course of  many years; revision  6 was
edited by Michael  Sperber, R. Kent Dybvig, Matthew  Flatt and Anton Van

  Ikarus Scheme is an almost R6RS compliant implementation of the Scheme
programming  language; it is  the creation  of Abdulaziz  Ghuloum, which
retired from  development in 2010.   Vicare Scheme is an  R6RS compliant
fork of Ikarus Scheme, aiming to  become a native compiler for R6 Scheme
producing  single   threaded  programs  running  on   Intel  x86  32-bit
processors, with experimental support  for 64-bit machines; it is tested
only on GNU+Linux,  no official support for other  platforms is present.
"Vicare" is pronounced the etruscan way.

  Vicare implements  an optionally included  foreign-functions interface
based on Libffi.   The last time the maintainer  updated this paragraph,
it had tested Libffi version 3.0.10.

  Current official maintainers are:

Marco Maggi <>

2. License

Copyright (c) 2011, 2012 Marco Maggi <>
Copyright (c) 2006-2010 Abdulaziz Ghuloum <>
Modified by the Vicare contributors.

This program is free software:  you can redistribute it and/or modify it
under the  terms of the GNU  General Public License as  published by the
Free Software Foundation,  either version 3 of the  License, or (at your
option) any later version.

This program  is distributed  in the  hope that it  will be  useful, but
WITHOUT   ANY   WARRANTY;  without   even   the   implied  warranty   of
General Public License for more details.

You should have received a copy  of the GNU General Public License along
with this program.  If not, see <>.

4. Install

4.1 Install Vicare

After checking out a revision from the repository, we will have to build
the infrastructure running a script from the top source directory:

   $ cd /path/to/vicare
   $ sh

after  that, or  if we  have downloaded  a proper  distribution tarball,
basically we should do:

   $ mkdir "=build"
   $ cd "=build"
   $ ../configure
   $ make
   $ make install

notice  that  the  "configure"  script  is  prepared  to  enable  shared
libraries  and  disable static  libraries:  this  must  not be  changed,
because  the package  is  meant to  install  a C  shared  library to  be
dynamically loaded.

  To test what a rule will do use the "-n" option; example:

    $ make install -n

  The "Makefile" supports the  "DESTDIR" environment variable to install
the files under a temporary location; example:

    $ make install DESTDIR=/tmp/marco/vicare

  After   installation,  the   makefile   rule  "vfasl-installed"   will
precompile the libraries installed in the hierarchy (vicare ---).

4.2 Install CRE2

CRE2 is a  C language wrapper for the RE2  library, which is implemented
in  C++.    RE2  is  a   fast,  safe,  thread-friendly   alternative  to
backtracking regular  expression engines from Google like  those used in
PCRE, Perl, and Python.

  Vicare  implements an  optional  built  in interface  to  CRE2; it  is
disabled by default, to enable  it we must give the "--with-cre2" option
to the "configure" script.  When using  this option we must use also the
--enable-shared  and  --disable-static  options  to avoid  installing  a
useless static library.

  At present (Jan 6, 2012), to  install RE2 we must check out a revision
from  the  repository  (see   Resources);  then  we  should  follow  the
installation instructions in the README file.  To install CRE2: download
the  latest  tarball, build  and  install it;  CRE2  relies  on the  GNU

5. Testing

Test  files  are  located  in  the "tests"  directory;  the  files  with
extension  ".sps" are  Scheme  programs.  They  are  partitioned in  two
families: the files whose name  start with "long-test" need some time to
be executed  by a  powerless computer; the  files whose name  start with
"test" can  be run in  reasonable time on  any system.  The  files whose
name contains "r6rs" are R6RS compliance tests by Matthew Flatt.

  The  "make  vfasl"  command  will  precompile  the  libraries  in  the
hierarchy (vicare ---) to be used by the test suite.

  The "make check",  "make test" and "make tests"  commands run the same
set of  "quick" tests; the "check"  makefile rule uses  the GNU Automake
infrastructure.  After  the installation: we  can run these  tests using
the "make installcheck" rule.

  The "make long-test"  and "make long-tests" commands run  the same set
of time-consuming tests.

  It  is possible  to select  a  single test  file by  using the  "file"
variable on the command line of "make"; for example:

   $ make test file=equal-hash

will run the  "test-issue-001-equal-hash.sps" file.  The "file" variable
is used to expand a file name with wildcards as in "test-*$(file)*.sps".

  It  is possible to  run "vicare"  from the  build directory  with user
selected command line arguments doing:

   $ make test-run user_flags='...'

where the contents  of the "user_flags" variable are  placed directly on
the command line.

  Some  test  files need  a  usable  directory  pathname in  the  TMPDIR
environment variable.

  The  file "test-vicare-posix.sps" contains  tests for  network sockets
which are  normally disabled because  the firewall rules on  the hosting
machine must  allo connections on  and; to
enable these tests run make with the environment variable RUN_INET_TESTS
set to something:

   $ make test file=vicare-posix RUN_INET_TESTS=1

  When included, it is possible to run tests for the bindings to foreign
libraries (like CRE2) with:

   $ make foreign-test

A. Credits

The  original Ikarus  Scheme  code  is the  work  of Abdulaziz  Ghuloum.
Vicare Scheme  is a  fork driven by  Marco Maggi.  See  the CONTRIBUTORS
file for the list of contributors to Vicare Scheme.

  The R6RS compatibility tests are  by Matthew Flatt and are distributed
under the GNU GPL version 2, or any later version.

  Barak A.  Pearlmutter provided a number  of changes for  better use of
the GNU Autotools.

  The implementation  of the function  BITWISE-REVERSE-BIT-FIELD is from
original  code  in:  Ypsilon  Scheme  System,  Copyright  (c)  2004-2009
Y. FUJITA / LittleWing  Company Limited.  See the file "COPYING.ypsilon"
for terms and conditions of use of this function.

  The implementation of EQUAL? comes from:

    Michael D.   Adams and  R.  Kent Dybvig.   "Efficient nondestructive
    equality checking for trees and graphs."  In ICFP '08: Proceeding of
    the  13th   ACM  SIGPLAN  international   conference  on  Functional
    programming,  pages 179-188.  ACM,  New York,  NY, USA,  2008.  ISBN
    978-1-59593-919-7. doi: 10.1145/1411204.1411230.

and the online distribution which is Copyright (c) 2008 Michael D. Adams
and R. Kent Dybvig, see  the file "" for the full license

  The implementation of MAKE-GUARDIAN comes from:

    Dybvig,  Bruggeman, Eby.  "Guardians  in a  Generation-Based Garbage
    Collector".   In  Proceedings  of  the  SIGPLAN  '93  Conference  on
    Programming Language Design and Implementation, 207-216, June 1993.

B. Bug reports

Bug reports  are appreciated, register  them using the issue  tracker at
Vicare's GitHub site:


C. Resources

The  latest version of  this package  can be  downloaded from  Github or
Google Code:


the home page of the Vicare project is at:


development takes place at:


and as backup at:


this project has a mailing list:


  It  is suggested to  use Vicare  Scheme along  with Nausicaa,  a large
collection of R6 Scheme libraries:


  The library Libffi can be found at:


  The library RE2 is available at:


the library CRE2 is available from:


  The home page of the R6RS standard is at:


  Other known implementations of R6 Scheme:

Chez Scheme	<>
Larceny		<>
Mosh		<>
Racket		<>
Ypsilon		<>

### end of file
# Local Variables:
# mode: text
# fill-column: 72
# paragraph-start: "*"
# End:
Something went wrong with that request. Please try again.