The analysis has come quite interesing to me. I've some doubts though, about the GML test. I wondering if the GML benchmark here addresses the VM or the YYC[LLVM C++], also, which version of vs was used to compile [last vs version available for gms is vs13]?

If the YYC hasn't been tested, It would be much to ask for a YYC test?, I find interesting to test (performance wise) GML as a c++ abstraction.

Currently it's not easy at all to find the benchmarks. Could you please restructure README such, that at the very beginning (at least before the table with results is presented) there is a list of all existing benchmarks, which are available for all the benchmarked languages? Also a direct URL pointing to the the tests/ directory is a must have.

Without this the benchmarks do not have unfortunately any value for the reader 😢.

As I understand your table right now the results of all benchmarks are shown combined. Could you split them up?

Different scenarios might have different priorities. For example, you can image that most proper game scripts are about calling native functions as fast as possible and and general interpretation overhead, not arithmetic operators.

You've got VC... :(:(:(:(:(

I expect that exception handling is usually supported by a C++ program. I wonder why your function "main" does not contain corresponding try and catch instructions so far.

How do you think about recommendations by Matthew Wilson in an article?

Would you like to adjust the implementation if you consider effects for uncaught/unhandled exceptions like they are described by Danny Kalev?

Right now the benchmarks look like they are all based on a simple fibonacci test, which I guess is a good start considering the number of runtimes being tested.

But just relying on this single type of benchmark is a bit one-sided and expanding the number of benchmarks is needed for a more accurate picture.

Perhaps we can list a few good candidates here. Two good sources I found are
https://github.com/kragen/shootout/tree/master/bench and https://github.com/attractivechaos/plb

Would be nice to pick something easy to implement but at the same time showing a different execution pattern than the fibonacci test.

This is great.

Just found this, great project, exactly what I did recently and was looking for.

Might be worth to also look at the few common lisp implementations:

• ECL (especially this)
• SBCL
• CLISP

Might be worth to also look at the Chez Scheme. It's open source now :)

Hi r-lyeh,

I would like to know whether is possible to eval ZetScript in your performance list test.

Currently ZetScript links dinamically by default but I attached the static version below,

zetscript-1.3.0_static.zip

And the equivalent Fibonacci script for ZetScript is typed below,

function fibR(n)
{
    if (n < 2) { 
     	return n; 
    }

    return fibR(n-2)+fibR(n-1);
}

print("fib: " + (fibR(34)) );

Cheers,

Jim Tcl is maintained, but not in @antirez's repository. The official GitHub mirror is at https://github.com/msteveb/jimtcl/.

Also, please consider including Tcl 8.6, the main implementation of Tcl, in the next round of your benchmark. Tcl 8.x is a versatile scripting language with a rich C API and has been used in games before, including commercial titles. If you have any questions about embedding Tcl, please ask.

• https://github.com/philburk/pforth

I was looking for some kind of a comparison of scripting languages in terms of speed. The results here are quite old so I wondered if you would be willing to re-run the benchmarks and update the table?

Kind regards,
Ingwie