Lua vs Tcl

One of the best features of Lua is its very well designed C API. This is very useful if you have an existing C library you need to integrate with Lua or quickly get a Lua script running on the C side of the game.

Finally Lua plays so nice with C that if you need to optimise for speed you can re-write it in C a lot easier than other languages.

The official Lua documentation is very helpful and thorough. There are also a large number of online resources or books with lots of helpful information for beginners and advanced users alike.

Lua can be built on any platform with a ANSI C compiler.

Other than that, Lua is extremely small. For example, the tarball for Lua 5.2.1 is only 245K compressed and 960K uncompressed (including documentation).

When built on Linux, the Lua interpreter built with the standard libraries takes 182K and the Lua library takes 243K.

The small size and the ability to build with a C compiler make Lua an extremely portable language that can run on a lot of different systems and computers.

Easy to learn.

Lua's performance compares very well to other languages, If performance needs to be further improved you can:

1. Implement critical parts in C
2. Use the LuaJIT compiler. The LuaJIT compiler is a drop in replacement for the stock compiler and provides significant performance improvements. From the overview page:

LuaJIT speeds can rival code written in C.

Many different game engines (e.g. Elder Scrolls series, ToME) use Lua for scripting, and it's runtime is designed for embedded use.

The Lua syntax is modeled from Modula, a language known for being a fantastic introduction to programming.

The Lua syntax also has the following key characteristics:

• Semicolon as a statement separator is optional (mostly used to resolve ambiguous cases as in a = f; (g).x(a)).
• Syntactic sugar for function calls (f'string', f"string", f[[string]], and f{table}) and method calls (obj:m()).

Due to the growing popularity, Lua has a rather large and helpful community surrounding it.

Unlike *sh Tcl has a rich standard library.

Unlike in sh you don't need to quote your variable substitutions ('"$1"').
Expanding of arguments occurs mostly explicit and if yet expected in-place (e. g. using eval or subst) it follows strict and well clear rules.
So exec test $argv would execute test with single argument.
And appending {*} before $argv would execute test with all arguments (list expansion).

With a little care you can have the same script work on Linux, *BSD, OS X and Windows.

You can expect a reasonably recent version of Tcl to either installed or available in the repositories of any popular open source *nix.

Tcl can operate at the same level of abstraction as the POSIX shell, which makes it easier to manipulate the output of other programs.

Tcl enables easy deployment through self-contained binaries known as starpacks.

Want to run something 5 times? Here you go: set i 0; time { puts done-[incr i] } 5
If you need real conditional cycle? Not a problem: for {set ready 0; set i 1} {$i <= 100 && !$ready} {incr i} { if {[exec do-some-thing] eq "ready" } {set ready 1} }
Want to measure performance of something or repeat it max 300 times and not longer than 1 seconds? Very simple: timerate { after 20 } 1000 300
How about notifying yourself when some http-server is back online? Sure thing: while {[catch { close [socket localhost 80] }]} { after 1000 }; puts "\7\7\7ONLINE!"
And you can do it also fully asynchronously using events etc.