I've just done a little benchmarking of the ray tracer written in Scheme and
compiled using Stalin. Here are the results. On x86 (900MHz Athlon T-bird):

$ g++ -O3 -march=athlon-tbird -ffast-math ray.cpp -o ray
$ time ./ray 6 160 >image.pgm
real    0m2.152s

$ mlton ray.sml
$ time ./ray 6 160 >image.pgm
real    0m2.435s

$ ocamlopt -inline 100 -ffast-math ray.ml -o ray
$ time ./ray 6 160 >image.pgm
real    0m3.255s

$ stalin -d0 -d1 -d5 -d6 -On -q -d -architecture IA32-align-double
-no-clone-size-limit -split-even-if-no-widening -copt -O2 -copt
-fomit-frame-pointer -copt -malign-double ray
$ time ./ray 6 160 >image.pgm
real    0m3.712s

On AMD64 (1.8GHz Athlon64):

$ g++ -O3 -march=athlon-tbird -ffast-math ray.cpp -o ray
$ time ./ray 6 160 >image.pgm
real    0m0.987s

$ mlton ray.sml
$ time ./ray 6 160 >image.pgm
real    0m1.056s

$ ocamlopt -inline 100 -ffast-math ray.ml -o ray
$ time ./ray 6 160 >image.pgm
real    0m1.037s

$ stalin -d0 -d1 -d5 -d6 -On -q -d -architecture IA32-align-double
-no-clone-size-limit -split-even-if-no-widening -copt -O2 -copt
-fomit-frame-pointer -copt -malign-double ray
$ time ./ray 6 160 >image.pgm
real    0m1.773s

I hadn't expected a simple Lisp or Scheme implementation to be able to
compete in terms of performance but only 70% slower on 32-bit AMD64 when
C++ and OCaml are fully 64-bit is very impressive, IMHO.

Anyway, perhaps you could try the following options for stalin? I got
better results with these:

   -d0 -d1 -d5 -d6 -On -k -Ob -Om -Or -Ot -q -d -architecture
IA32-align-double -no-clone-size-limit -split-even-if-no-widening -copt
-O3 -copt -fomit-frame-pointer
-copt -malign-double -copt -ffast-math -copt -freg-struct-return

In other words, I was expecting fast Lisp/Scheme implementations of the ray
tracer to be obfuscated compared to the other languages but that doesn't
seem to be the case.

Do you think that OCaml its error messages are better? The problem
often in functional codes: ther error itself is often not related to
the place where it occurs.

Stalin is indeed an outstanding unsurpassed project. However, do you
really want to use Stalin in a professional environment? Bigloo its
manpower is as tiny
as Stalin its one. However, Bigloo has a much better presentation
home-page-wise, documenation, support, etc.

I've tried using Stalin 0.10alpha2, with little luck.  It can compile
simple things like "hello.sc" and "xhello.sc", but apart from that it
can't compile anything, even it's own benchmarks.

They do emit warnings telling the programmer where the type problems are but
that is no substitute for having the compiler do the work for you.

Greetings,
        -- Jorgen

Here are the compile lines I used on x86:

ocamlopt -inline 100 -ffast-math ray.ml -o ray
g++ -O3 -march=athlon-tbird -ffast-math ray.cpp -o ray
mlton ray.sml
javac ray.java
stalin -d0 -d1 -d5 -d6 -On -q -d -architecture IA32-align-double
-no-clone-size-limit -split-even-if-no-widening -copt -O2 -copt
-fomit-frame-pointer -copt -malign-double qobi

Running times for level=9, n=512 and ss=4 on 900MHz Athlon T-bird:

46.181s OCaml
33.086s C++ (gcc)
35.298s SML (MLton)
147.242s Java (Sun JDK 1.5)
73.976s Scheme (Stalin)

Compile times:

0.349s OCaml
5.205s C++ (gcc)
17.093s SML (MLton)
7.361s Java (Sun JDK 1.5)
94.647s Scheme (Stalin)

Here are the compile lines I used on AMD64:

ocamlopt -inline 100 ray.ml -o ray
g++ -O3 ray.cpp -o ray
mlton ray.sml
javac ray.java
stalin -d0 -d1 -d5 -d6 -On -q -d -architecture IA32-align-double
-no-clone-size-limit -split-even-if-no-widening -copt -O2 -copt
-fomit-frame-pointer -copt -malign-double qobi
(load (compile-file "nathan.lisp"))

Running times for level=9, n=512 and ss=4 on 1.8GHz Athlon64:

12.154s OCaml
12.226s C++ (gcc)
12.407s SML (MLton)
21.616s Java (Sun JDK 1.5)
26.867s Scheme (Stalin)
56.366s Lisp (SBCL)

MLton, Stalin and SBCL are run from 32-bit mode. All others from 64-bit
mode.

Compile times:

1.378s OCaml
2.279s C++ (gcc)
7.786s SML (MLton)
2.650s Java (Sun JDK 1.5)
94.647s Scheme (Stalin)
0.445s Lisp (SBCL)

Here's the Stalin implementation "qobi.sc" that I used:

(define-structure point x y z)

(define-structure obj c r objs)

(define-structure hit lam normal)

(define fail #f)

(define (fold-right f i l)
 (if (null? l) i (f (car l) (fold-right f i (cdr l)))))

(define infinity (/ 1.0 0.0))

(define epsilon 1e-15)

(define (s*v s b)
 (make-point (* s (point-x b)) (* s (point-y b)) (* s (point-z b))))

(define (v+v a b)
 (make-point (+ (point-x a) (point-x b))
             (+ (point-y a) (point-y b))
             (+ (point-z a) (point-z b))))

(define (v-v a b)
 (make-point (- (point-x a) (point-x b))
             (- (point-y a) (point-y b))
             (- (point-z a) (point-z b))))

(define (cpsv-v a b receiver)
 (receiver (- (point-x a) (point-x b))
           (- (point-y a) (point-y b))
           (- (point-z a) (point-z b))))

(define (dot a b)
 (+ (* (point-x a) (point-x b))
    (* (point-y a) (point-y b))
    (* (point-z a) (point-z b))))

(define (dot1 ax ay az b)
 (+ (* ax (point-x b)) (* ay (point-y b)) (* az (point-z b))))

(define (dot2 ax ay az bx by bz) (+ (* ax bx) (* ay by) (* az bz)))

(define (unitise r) (s*v (/ 1.0 (sqrt (dot r r))) r))

(define (ray-sphere orig dir center radius)
 (cpsv-v
  center
  orig
  (lambda (vx vy vz)
   (let* ((b (dot1 vx vy vz dir))
          (disc (+ (- (* b b) (dot2 vx vy vz vx vy vz)) (* radius radius))))
    (if (< disc 0.0)
        infinity
        (let ((t2 (+ b (sqrt disc))))
         (if (< t2 0.0)
             infinity
             (let ((t1 (- b (sqrt disc))))
              (if (> t1 0.0) t1 t2)))))))))

(define zero (make-point 0.0 0.0 0.0))

(define (intersect orig dir obj)
 (let lp ((obj obj) (hit (make-hit infinity zero)))
  (let ((l (ray-sphere orig dir (obj-c obj) (obj-r obj))))
   (cond ((>= l (hit-lam hit)) hit)
         ((pair? (obj-objs obj)) (fold-right lp hit (obj-objs obj)))
         ((null? (obj-objs obj))
          (make-hit l (unitise (v+v orig (v-v (s*v l dir) (obj-c obj))))))
         (else (display "Bad obj") (display obj) (newline))))))

(define neg_light (unitise (make-point 1.0 3.0 -2.0)))

(define orig (make-point 0.0 0.0 -4.0))

(define (ray-trace dir scene)
 (let* ((hit (intersect orig dir scene))
        (lam (hit-lam hit))
        (normal (hit-normal hit)))
  (cond ((>= lam infinity) 0.0)
        ((< (hit-lam
             (intersect
              (v+v orig (v+v (s*v lam dir) (s*v (sqrt epsilon) normal)))
              neg_light
              scene))
            infinity)
         0.0)
        (else (max 0.0 (dot normal neg_light))))))

(define (create level c r)
 (let ((obj (make-obj c r '()))
       (a (* 3.0 (/ r (sqrt 12.0)))))
  (if (= level 1)
      obj
      (let ((aux (lambda (x z)
                  (create (- level 1) (v+v c (make-point x a z)) (* 0.5
r)))))
       (make-obj c
                 (* 3.0 r)
                 (list obj
                       (aux (- a) (- a))
                       (aux a (- a))
                       (aux (- a) a)
                       (aux a a)))))))

(define level 6)
(define level (or (and (= (length argv) 3)
                       (string->number (vector-ref argv 1))) 9))

(define n 160)
(define n (or (and (= (length argv) 3)
                   (string->number (vector-ref argv 2))) 512))

(define ss 4)

(define scene (create level (make-point 0.0 -1.0 0.0) 1.0))

(define ss2 (* ss ss))

(define (aux x d) (+ (- x (/ n 2.0)) (/ d ss)))

(define (g x y)
 (do ((dx  0 (+ dx 1))
      (sum 0 (do ((dy    0 (+ dy 1))
                  (sum sum (+ sum
                              (ray-trace (unitise
                                          (make-point (aux x dx)
                                                      (aux (- (- n 1) y) dy)
                                                      (exact->inexact n)))
                                         scene))))
               ((>= dy ss) sum))))
   ((>= dx ss) sum)))

(define (pixel x y)
 (write-char
  (integer->char (inexact->exact (truncate (+ 0.5 (* 255 (/ (g x y)
ss2))))))))

(define n2 n)

(define (go)
 (with-output-to-file "scheme.pgm"
  (lambda ()
   (display "P5")
   (newline)
   (display n)
   (display " ")
   (display n)
   (newline)
   (display 255)
   (newline)
   (do ((y 0 (+ y 1))) ((>= y n2))
    (do ((x 0 (+ x 1))) ((>= x n))
     (pixel x y))))))

(go)

Compile line:

time stalin -d0 -d1 -d5 -d6 -On -q -d -architecture IA32-align-double
-no-clone-size-limit -split-even-if-no-widening -copt -O3 -copt
-fomit-frame-pointer -copt -malign-double -copt -march=athlon-tbird -copt
-ffast-mathqobi

Running time:

64.191s

Compile time:

574.331s

I have 3 missions:

a) Man must believe in God

b) Scheme is highly recommended for *scientific numerical calculations"

c) EVERY Scheme implementation has a lot to offer. The Scheme language
standard is a beauty in itslef. Although, Bigloo for example goes
farther and will give you pattern-matching for example:

==
(module test)

(define
   (map2e::obj fun::obj lis1::pair-nil lis2::pair-nil)
   (match-case (list lis2 lis2)
      [(() ()) '()]
      [((?h1 ???t1) (?h2 ???t2))
         (cons
            (fun h1 h2)
            (map2 fun t1 t2))]
      [(?- ?-) (error "map2" "invalid list argument" (list lis
lis2))]))

(print (map2 (lambda (x y) (+ x y))
       (list 2 34)
       (list 2 3)))
==

You shouldn't go with the impression Scheme is a tiny standard.