The Lua scripting language is integrated into the interactive shell. Unlike previous versions of FEMM (i.e. V3.4 and lower), only one instance of Lua is running at any one time. This single instance of Lua can both build and analyze a geometry and evaluate the post-processing results, simplifying the creation of various sorts of “batch” runs. Lua is very simple, and one of easiest coding languages to learn. In Dual Universe, each Element contains its own set of values and functions. An engine can exert a force, a sensor can detect an object, a door can open. Each of the values in these elements has the potential to be used in a script. An engine can be told how much force to exert.

Cairot — The cairo drawing context. Paths — Creating paths and manipulating path data. Cairopatternt — Sources for drawing. Regions — Representing a pixel-aligned area. Transformations — Manipulating the current transformation matrix. Text — Rendering text and glyphs. Raster Sources — Supplying arbitrary image data. The Lua API also provides methods for creating variables and tables via C code that will be visible for the scripts when they are run. By combining these features you can expose entire C classes to Lua. The opposite is also possible, the Lua API allows the user to modify Lua variables and call Lua functions from the native C code.

I have been programming in Lua for about 9 months and it seemed like a good time to pause and reflect on my experience with it. I have used various languages over the years -- Perl (soaplite.com and other projects, including my current consulting work), C (a DHCP/DNS server for Arduino and a ping-pong juggling robot), JavaScript (experiments with Google Maps and canvas), MATLAB (ping-pong juggling robot), and others, from Turbo Pascal to F# -- and it was interesting to see how Lua compares to the other languages I've worked with. I have done different types of projects in Lua: a remote debugger (MobDebug), extending a Lua IDE (ZeroBrane Studio), a mobile app (LuaRemote), several educational scripts (EduPack), and a demo of drawing on browser canvas with Lua.

I have come across several detailed lists that mention good and not-so-good parts of Lua (for example, Lua benefits, why Lua, why Lua is not more widely used, advantages of Lua, Lua good/bad, Lua vs. JavaScript, and Lua Gotchas), but I found that some of the features that tripped me or that I cared about were not listed, so I put together my own list. It is far from being comprehensive and some aspects of the language are not covered (for example, math and string libraries), but it captures the gist of my experience with the language.

Good

Small: 20000 lines of C code that can be built into a 182K executable interpreter (under Linux).
Portable: builds on any platform with an ANSI C compiler. You can see it running on almost anything from microcontrollers and Lego Minstorms NXT, to game engines, to mobile toolkits, to game consoles, to a browser (translated to JavaScript).
Embedded and extensible language that provides a straightforward interface to/from C/C++.
Sufficiently fast: performs well comparing to other languages and has a JIT compiler that noticeably improves performance on many tasks; those who may still be not satisfied with the performance, can implement critical parts in C and, given the ease of integration with C, still benefit from other good aspects. [Updated 3/9/2013] replaced shootout results that are no longer available with benchmarksgame.
Well documented: reference manual, book, wiki, 6-page short reference and more.
Friendly and enthusiastic community. Between the excellent documentation, the wiki, the mailing list, and StackOverflow, I didn't have any issues finding answers to my questions.
Clean and simple syntax suitable for beginners and accessible to non-programmers. Lua has borrowed most of its control syntax from Modula, the descendent of Pascal, which was widely used in education as an introductory language. I still remember using early versions of Philippe Kahn's fast and elegant Turbo PascalIDE.
Integrated interpreter: just run lua from the command line.
Native support for coroutines to implement iterators and non-preemptive multi-threading.
Incremental garbage collector that has low latency, no additional memory cost, little implementation complexity, and support for weak tables.
Powerful heterogeneous tables that store values of any type (except nil) and can be indexed by values of any type (except nil): {1, 2, 5, foo = 'bar', [func] = 'something', ['some spaces'] = value()}.
Lexical scoping.
Functional programming with first class functions and closures.
Tail calls: return functioncall().
Recursive functions don't need to be pre-declared: local function foo() ... foo() ... end; note this doesn't work with local foo = function() ... foo() ... end.
Functions return multiple values: return 1, 2, 3. The caller can expect any number of values returned: if less than three is expected, the rest is discarded and if more than three is expected, the rest is nil-initialized.
Functions allow variable number of parameters with function foo(...) local args = {...}; bar(param, ...) end.
Tables can be 'unpacked' into a list of parameters with unpack (or table.unpack in Lua 5.2): print(unpack({1, 2, 3})) prints 1 2 3.
Manipulating environments (getfenv and setfenv in Lua 5.1 and _ENV manipulation in Lua 5.2), which allows building sandboxes among other things.
Assignment to a list of variables: local a, b, c = 1, 2, x, y = y, x, or a, b = foo().
Multiline strings (using [[...]]; can be enclosed with [[...[=[...]=]...]]) and comments (--[[...]]).
Semicolon as a statement separator is optional (mostly used to resolve ambiguous cases as in a = f; (g).x(a)).
Overloading using metatables.
Metaprogramming to do things from getting and modifying an abstract syntax tree to creating a new syntax for your DSL.
The for statement has two forms: generic (loops over iterators: for a in iter() do ... end) and numeric (loops over numbers: for a = 1, 5, 0.1 do ... end); the numeric one supports all numeric values for steps (not just integers).
Syntactic sugar for function calls (f'string', f'string', f[[string]], and f{table}) and method calls (obj:m()).
Simple yet powerful debug library.
Fast and powerful JIT compiler/interpreter (LuaJIT) which includes FFI library and is ABI-compatible with Lua 5.1 (this means that it can load binary modules compiled for Lua 5.1).

Different

Tables and strings are indexed from 1 rather than 0.
Assigning nil as a value removes the element from a table. This is consistent with returning nil for non-existing element, so it makes no difference whether the element does not exist or exists with a value of nil. a = {b = nil} produces an empty table.
No integers as a separate numeric type; the number type represent real numbers. The next version of Lua (5.3) may change that.
No classes; object-orientation is implemented using tables and functions; inheritance is implemented using the metatable mechanism.
Method calls are implemented using object:method(args) notation, which is the same as object.method(object, args) notation, but with object evaluated only once.
nil and false are the only false values; 0, 0.0, '0' and all other values evaluate as true.
Non-equality operator is ~= (for example, if a ~= 1 then ... end).
not, or, and keywords used for logical operators.
Assignments are statements, which means there is no a=b=1 or if (a=1) then ... end.
No a+=1, a++, or similar shorthand forms.
No continue statement, although there is an explanation and a number of alternatives, like using

C++ Store Lua Scripts In Vector