The C code of all VMs was compiled with GCC 4.4.3 with the default compiler flags given in the Makefiles (except for Lua on x86 where -O2 -fomit-frame-pointer was used). The base for the comparisons are the user CPU times as reported by the shell built-in time command (i.e. The accuracy of the timings is limited by the 250Hz.

wiki

Here are functions to serialize/unserialize a table or object (usually, not always, represented as a table), which is to convert it to and from a string representation. This is typically used for display (e.g. debugging) or storing data in a file (e.g. persistence).

Design decisions include

human readability: Should the serialized output be optimized for human readability? (example: debugging)
machine readability: Should the serialized output allow reliable deserialization?
type of data: Should it be optimized for representing a certain type of data? (e.g. Metalua AST's)
format: should deserialization be accomplished via loadstring (if so what style of table construction?), binary I/O, XML, JSON, YAML, HTML, protocol buffers, etc.?
depth: Should deeply nested tables be handled? or just shallow members (e.g. table.foreach(t, print)).
size: How should tables with large size be handled? (e.g. limit depth or incremental display)
self-references: How should tables with self references (e.g. cycles) be handled?
types: How should it handle userdata? functions? functions with upvalues? tables with metatables? weak table references? transient objects (e.g. database handles)
input/output destination: Should it read/write from/to a string in memory or to a file stream?
complexity/dependencies: Should it implemented in pure Lua? Should it be simple? Is a more complex implementation ok?
security: should the deserializer be secure about arbitrary input? (If using loadstring, then a custom environment may be used, although this doesn't guard against infinite loops.)

A metatable is a regular Lua table containing a set of metamethods, which are associated with events in Lua. Events occur when Lua executes certain operations, like addition, string concatenation, comparisons etc. Metamethods are regular Lua functions which are called when a specific event occurs. The events have names like 'add' and 'concat.
Therefore, given that numbers in Lua are doubles which I don't want to change, using normal Lua tables to do the job results in a 8x overhead in terms of memory use. This is not that bad since the values are converted back to unsigned chars where needed when reading the data from C but these arrays are contained inside Lua scripts and these.

Because of these different needs, there have been many implementations.

Implementations

SaveTableToFile - save table to file/str; load table from file/str
TablePersistence - saves tables and primitive types to a file, loads such files. Forked on github.
PitLibTablestuff (old, Lua 4)
OutputLuaTableToHtmlFile - output to HTML
DataDumper - dump nearly any data (incl. closures) into a string
[Serpent] - Lua serializer and pretty-printer that implements compact and robust serialization that still produces a readable code.
MetaLua's library contains table.tostring and table.print[1] functions in its standard library (which can be used outside of Metalua). These focus on customizable pretty-printing, but do not preserve cycles or serialize functions. (See examples below.)
MetaLua also contains a robust serializer: it's result doesn't focus on indentation nor nice formatting, but on the respect of identity relationship and shared sub-parts. Additionally, this serializer does handle functions without upvalues. See 'Identity-preserving table serialization by metalua' below.
For really complete serialization (including coroutines, functions with upvalues, etc.), the right solution is to use PlutoLibrary.
[lper] persists the entire Lua state's memory using [Linux Persistent Memory (LPSM)] (via custom Lua allocator tied to LPSM).
Lua Gems chapter 3 'Vardump: The Power of Seeing What's Behind' (LuaBooks) explains a simple table dump function for debugging display purposes (no cycles).
Lua Gems chapter 4 'Serialization with Pluto' (LuaBooks) explains the basic operation of Pluto as well as gives a brief overview of LuaPickle? and lper.
EngramProposal - serializing data using the Lua string.dump format (VM opcodes)
PersistentTablesSqlite - using SQLite to persist tables
[Tony Finch's table serializer] posted to lua-l
[penlight] has an implementation
[lua-nucleo] offers several implementations in plain Lua, serializing to Lua code:
- [tstr] fastest, no cycles, no functions or userdata; primarily for one-line logging
- [tserialize] fast, with cycles, no functions or userdata; for proper serialization
- [tpretty] slower, no cycles, no functions or userdata; for multiline readable serialization
[luabins] implements fast binary serialization (no cycles, no functions or userdata), supports function-call-like tuples
[luatexts] implements fast human-readable serialization (no cycles, no functions or userdata), supports function-call-like tuples
[luainspect dump.lua] has an implementation for AST nodes.
[lua-marshall] - Fast table serialization for Lua. Serializes tables, which may contain cycles, Lua functions with upvalues and basic data type. [discussion and benchmarks]
[inspect.lua] Not a serialization library - its output is not valid Lua code, but it's extremely human-readable. It's supposed to be used for debugging. Keys are sorted out alphabetically, nested tables are properly indented, table loops are detected and signaled, and metatable information is also included.
[lua-MessagePack] in pur Lua. [lua-cmsgpack] in C for Lua - Fast serialization for Lua in [MessagePack] format.
[prtr-dump] - Nice human readable Lua-compatible output, support very large tables.
[Ser] - robust, fast, simple and richly-featured table serialisation library. Especially made to have no learning curve whatsoever.
[lua-capnproto] Very fast serialization for Lua in [Cap'n Proto] format.
[LTCN] Deserializes Lua Table Constructor Notation by parsing with LPeg as a safe alternative to load/loadstring. Similar in purpose to JSON.parse() vs. JavaScript eval().

Identity-preserving table serialization by Metalua

This example doesn't focus on the readability of the serialized table. Instead, and contrary to other examples in this page, it conserves shared sub-structures. Here's an example of a test that would be passed by metalua serialization, but not by pretty-printers:

Sources for this serializer are available on the MetaLua repository: [2].

Metalua table.tostring and table.print

These functions are intended for pretty-printing rather than serialization: they don't preserve identity. They will terminate, though: if a table references itself, the inner occurrence will be printed as '[table: 0x12345678]' in order to avoid infinite recursion.

Print a table recursively

ISSUE: this should return a string rather than assume how the user wants to output the text.

Universal tostring

Example

This prints

(the above code was originally from TableUtils)

PHP-like print_r

Based on [PHP print_r]. Based on code by Nick Gammon, hacked by DracoBlue to fit to [PHP print_r]-Style.

Example: print_r{ 5,3,{5,3} } -->

Compatibility: Lua 5.0 and 5.1

Here is a more complete version of print_r:

Sorry for the length!

A test:

The output:

What's Comparable To A Lua Table In C