If you compile the Rust example with optimization (-O) it just throws the result away, which gives the ~0.030 time chrisdouay found.

However, if you add a println!() around it, it has to calculate the result. Here's the running time:

    > time ./fib
    1134903170

    real    0m2.242s
    user    0m2.240s
    sys     0m0.000s

I tried the C example as well (with -O2) and found this:

    > time ./cfib
    1134903170

    real    0m4.671s
    user    0m4.670s
    sys     0m0.000s

So.. which one is faster again?

This "comparison" unfortunately seems too naïve to not be on purpose - no analysis, no real discussion, not even some reasoning about the defaults and why the big difference in numbers. It seems to be just looking for views/comments (even if negative) without any intention to produce real content. What worries me are the ones that will take this for a real benchmark and just "share on facebook" and spread more disinformation.

How was this stuff compiled? There's no way to reproduce these numbers without compiler flags, at least.

For example, with "rustc fib.rs", I get 10 seconds as a runtime. With "rustc -O fib.rs", to turn on optimizations, I get 0.034s. This makes me pretty sure that they did not turn on optimizations, which means the Rust numbers are very misleading, and possibly, the other languages as well.

I get 0.034s => this means the compiler run the code and puts directly the result in the binary file. So, when you run the binary, it only println(result)

I don't love the conclusion, a single Fibonacci benchmark is fairly light evidence to blanket state Crystal is as fast as C. It's also fairly toothless on comparison of other languages.

COUGH Tail recursion COUGH