The Glasgow Haskell Compiler -- version 2.02

We are pleased to announce the first release of the Glasgow Haskell
Compiler (GHC, version 2.02) for *Haskell 1.4*.  Sources and binaries
are freely available by anonymous FTP and on the World-Wide Web;
details below.

Haskell is "the" standard lazy functional programming language; the
current language version is 1.4, agreed in March, 1997.  The Haskell
Report is online at

GHC 2.02 is a beta-quality release:

  * It is reliable.
    It has been extensively tested against a large suite of Haskell 1.2 
    programs, but not so extensively tested against Haskell 1.4 programs 
    because we don't have a comprehensive set (Donations of Haskell 1.4
    programs to our test suite are most welcome).

  * It should generate reasonably good code.
    All the optimisations that GHC 0.29 used to do are back in, with 
    the exception of specialisation.  It ought to be the case that
    GHC 2.02 outperforms GHC 0.29, because it has a much better
    handle on cross-module inlining, but we know for certain that
    this isn't always the case.  We have yet to make a systematic 
    comparison.  In short, this is not the moment to switch from 0.29
    if you Really Care about performance.  2.02 does, however,
    generate much better code than 2.01.

    (Please send us programs where 2.02 does noticeably worse than 0.29.)  

  * It is more expensive than it should be.
    GHC 2.02 has received even less attention to its own performance.
    At present it eats more space and time than GHC 0.29, especially
    for very small programs.  We'll work on this.

  * A couple of Haskell 1.4 features are incompletely supported,
    notably polymorphic strictness annotations, and Unicode.

If you want to use Haskell 1.4, this is a good moment to switch.  If
you don't need the Haskell 1.4 extensions, then stay with GHC 0.29.
If you want to hack on GHC itself, then 2.02 is definitely for you.
The release notes comment further on this point.

GHC 2.02 is substantially changed from 2.01.  Changes worth noting

  * The whole front end, which deals with the module system, has 
    been rewritten. The interface file format has changed.

  * GHC 2.02 is released together with Green Card, a C foreign language 
    interface for GHC.  Green card is a pre-processor that
    scans Haskell source files for Green Card directives, which
    it expands into tons of "ccall" boilerplate that marshalls
    your arguments to and from C.

  * GHC 2.02 is available for Win32 platforms, which, from now on,
    is a fully supported platform for GHC.

  * GHC 2.02 supports full cross module inlining.  Unlike 0.29 and
    its predecessors, inlining can happen even if the inlined body
    mentions a function or type that is not itself exported.  This is
    one place Haskell 1.4's new module system really pays off.

  * Like 2.01, GHC 2.02 aborts a compilation if it decides that
    nothing that the module imports *and acually uses* has changed.
    This decision is now taken by the compiler itself, rather than
    by a Perl script (as in 2.01) which sometimes got it wrong.

  * The ghc/lib libraries are much more systematically organised.

  * There's a completely new "make" system.  This will mainly affect people
    who want the source distribution, who will hopefully find it much, much,
    easier than grappling with the old Jmakefiles.  Even for binary
    installation, the procedure is a little simpler, though.

Please see the release notes for a complete discussion of What's New.

To run this release, you need a machine with 16+MB memory (more if
building from sources), GNU C (`gcc'), and `perl'.  We have seen GHC
2.01 work on these platforms: alpha-dec-osf2, hppa1.1-hp-hpux9,
sparc-sun-{sunos4,solaris2}, mips-sgi-irix5, and
i386-unknown-{linux,solaris2,freebsd,cygwin32}.  Similar platforms
should work with minimal hacking effort.  The installer's guide
give a full what-ports-work report.

Binaries are distributed in `bundles', e.g. a "profiling bundle" or a
"concurrency bundle" for your platform.  Just grab the ones you need.

Once you have the distribution, please follow the pointers in
ghc/README to find all of the documentation about this release.  NB:
preserve modification times when un-tarring the files (no `m' option
for tar, please)!

We run mailing lists for GHC users and bug reports; to subscribe, send
mail to [EMAIL PROTECTED]; the msg body should be:

    subscribe glasgow-haskell-<which> Your Name <[EMAIL PROTECTED]>

Please send bug reports about GHC to [EMAIL PROTECTED]

Simon Peyton Jones

Dated: March 1997

Relevant URLs on the World-Wide Web:

GHC home page   
Glasgow FP group page
comp.lang.functional FAQ

How to get GHC 2.02:

The easy way is to go to the WWW GHC distribution page, which is

Otherwise you can use the old anonymous FTP method from the main Haskell
archive sites, in the directory pub/haskell/glasgow:   (  ( (

        [BUT: the latter two sites may take a while to get up to date.]

The Glasgow site is mirrored by (, in

These are the available files (.gz files are gzipped) -- some are `on
demand', ask if you don't see them:

ghc-2.02-src.tar.gz     The source distribution; about 3MB.

ghc-2.02.ANNOUNCE       This file.

ghc-2.02.{README,RELEASE-NOTES} From the distribution; for those who
                        want to peek before FTPing...

ghc-2.02-ps-docs.tar.gz Main GHC documents in PostScript format; in
                        case your TeX setup doesn't agree with our
                        DVI files...

ghc-2.02-<platform>.tar.gz Basic binary distribution for a particular
                        <platform>.  Unpack and go: you can compile
                        and run Haskell programs with nothing but one
                        of these files.  NB: does *not* include
                        profiling (see below).

        <platform> ==>  alpha-dec-osf2


        <platform> ==>  as above
        <bundle>   ==>  prof (profiling)
                        conc (concurrent Haskell)
                        par  (parallel)
                        gran (GranSim parallel simulator)
                        ticky (`ticky-ticky' counts -- for implementors)
                        prof-conc (profiling for "conc[urrent]")
                        prof-ticky (ticky for "conc[urrent]")

ghc-2.02-hc-files.tar.gz Basic set of intermediate C (.hc) files for the
                         compiler proper, the prelude, and `Hello,
                         world'.  Used for bootstrapping the system.
                         About 4MB.

Reply via email to