Upstream release history

These translated notes describe upstream releases, not the current fork.

Historical upstream changelog (English translation). Entries below describe the original releases and are retained for historical reference.

v2.1.15 — June 24, 2020
New features
1. Added a generated-code filter.
2. Improved the performance of matching delegates to bridges during reflection lookup.
3. Fixed an issue that prevented injection into mobile builds for Unity 2019.2 and later.

Changes

Bug fixes
1. Made reflection lookup for same-named delegate bridges consistent when generated code is disabled.
2. Fixed generated-code errors for nested structs marked with PackAsTable.
3. Added stack-space checks to reflection wrapper code.
4. Fixed a Unity Android crash caused by enum definitions with thousands of values, which produced a very large function with many branches.
5. Fixed a mismatch between the chunk name and script file name.
6. Fixed generated-code errors for enums in minimum-generation mode.
7. Fixed reflection-based enum registration when multiple enum members have the same value (for example, A and B are both 1); Lua could not access B.
8. Fixed `sbyte[]` being pushed to Lua as a string under .NET 4.
9. Fixed generated-code failures caused by generics.
10. Fixed handling of `out` parameters when injecting assemblies other than Assembly-CSharp.
11. Fixed cases where `xlua.private_accessible` could fail for nested classes.
12. Fixed an offset calculation error that could occur because Cecil did not update offsets automatically after inserting instructions.

v2.1.14 — February 27, 2019
New features
1. Added Nintendo Switch support.
2. Added Unity 2018 compatibility.
3. Added Android ARM64 support.
4. Added Visual Studio 2017 support for native-library builds.
5. Added the “XLua/Generate Minimize Code” menu item.
6. Prevented projects with invalid DLLs from interrupting code generation.
7. Added a more efficient `lua_pushstring` implementation, enabled with `NATIVE_LUA_PUSHSTRING`.

Changes
1. Changed the default compiler for the Windows library to Visual Studio 2017.

Bug fixes
1. Fixed a crash when an enum had `GCOptimize` but not `LuaCallCSharp`.
2. Added filtering for Editor classes to the sample configuration.
3. Fixed UWP compatibility.
4. Implemented same-signature methods introduced by interface inheritance.
5. Fixed inconsistent extension-method behavior when generated code is disabled.
6. Fixed nullable parameters causing all other parameters to become nil when the last argument was nil.

v2.1.13 — December 5, 2018
New features
1. Added the AdaptByDelegate injection mode.
2. Added `xlua.get_generic_method` for calling generic methods.
3. Added generic syntax such as `CS.System.Collections.Generic.List(CS.System.Int32)`.
4. Added injection options to ignore compiler-generated code and to omit base-call proxies.
5. Added ready-to-use automatic configuration examples for Lua scripting and hotfixes.
6. Added GC64 support for LuaJIT.
7. Added compatible bytecode support (one bytecode format for 32-bit and 64-bit systems).
8. Added a built-in Lua memory leak detection tool.
9. Added dynamic delegate-bridge instantiation: Lua functions can be called without `CSharpCallLua` configuration when the delegate has at most four parameters, all parameters are reference types, and the return type is void or a reference type.
10. Added `util.print_func_ref_by_csharp` to show Lua functions currently referenced by C#.
11. Added a mode of operation without the `CS` global variable.

Changes
1. Upgraded the VMs from Lua 5.3.4 to Lua 5.3.5 and LuaJIT 2.1b2 to LuaJIT 2.1b3.
2. Reduced delegate bridge code size.
3. Changed code-generation checks to use the PostProcessBuild event.
4. Adapted to Xcode 10; macOS builds no longer support 32-bit.
5. Static-member access now reports misspelled namespaces or class names.
6. Prevented deletion of the `CS` global table from disrupting xLua.
7. On Windows, if CMake fails with Visual Studio 2015 arguments, the library build now retries with Visual Studio 2017.
8. When generated code is disabled in the Editor, Blacklist is now checked as it is at runtime.

Bug fixes
1. Fixed generated code for arrays of generic types.
2. Fixed `TypeExtensions` marked with `LuaCallCSharp` causing checks such as `IsValueType` in Lua to always return true.
3. Filtered functions and fields containing pointers out of generated code.
4. Supported indexer properties whose name is not `Item`.
5. Fixed code generation and injection stopping when attribute initialization throws an exception.
6. Fixed generated code for empty enums in minimize mode.
7. Split initialization functions into smaller functions to avoid Unity Android crashes when executing large functions.
8. Fixed `Assignable` handling when `obj` is null.
9. Fixed generated-code errors when a nested class is not obsolete but its outer class is obsolete.
10. Fixed missing exception details when Lua logic threw an error with inline injection.
11. Fixed same-named public methods becoming inaccessible after `xlua.private_accessible` was used.
12. Removed the `out` keyword from parameters marked `[Out]`.
13. Fixed reflection lookup sometimes returning a function that was not an adapter.
14. Added missing `get_Item` and `set_Item` to exported code in minimize mode.
15. Fixed `xlua.private_accessible` not being applied automatically in IntKey mode.

v2.1.12 — July 9, 2018
New features
1. Added nullable support.
2. Added beta support for injecting assemblies other than Assembly-CSharp.
3. `xlua.hotfix` now automatically makes the target class's private members accessible.
4. Optimized `xlua.private_accessible`: it also makes base classes' private members accessible and delays this work until the class is first accessed.
5. Added `xlua.util.state` to attach state to a C# object.
6. Added `get_Item` and `set_Item` calls for overloaded `this[string field]` and `this[object field]` operators.
7. Injection now prints errors during compilation.
8. Automatically implemented event and indexer mappings for interfaces configured with `CSharpCallLua`.
9. Removed the “WARNING: The runtime version supported by this application is unavailable” message for Unity 5.5 and later.

Changes
1. Removed the Stateful mode because `xlua.util.state` provides similar behavior.
2. Deprecated the embedded mode.

Bug fixes
1. Added underscores to generated-code local variables to prevent symbol conflicts.
2. Omitted base-call proxies when a class was not included in the Hotfix list.
3. Refactored code for readability.
4. Fixed generated-code compilation failures involving `params byte[]`.
5. Fixed `xlua.private_accessible` failing for classes with private events.
6. For constructor injection, placed injected logic between a branch and a following `Ret` instruction.
7. Changed short branches to long branches when injected instructions exceed the short-branch range.
8. Fixed `CS.namespace.classname` being empty when a delegate was not a nested type of a class.
9. Prevented name conflicts with the Editor `Util` class.
10. Filtered out generic overrides that were causing errors.
11. Fixed generated-code compilation errors for empty enums.
12. Fixed UWP IL2CPP builds being unable to access any classes.
13. Fixed generated-code compilation and injection failures when hotfixing a method with a `params` parameter of a private type.
14. Made `GetHashCode` return the same value when two `LuaBase` instances refer to the same Lua object.
15. Fixed generated-code compilation failures for parameters marked `[Out]`.
16. Fixed generated-code errors for jagged arrays combined with multidimensional arrays.

v2.1.11 — March 20, 2018
New features
1. Added support in `xlua.private_accessible` for private nested types.
2. Added `xlua.release` to explicitly release a C# object's reference from Lua.
3. Added explicit construction of nested delegates.
4. Places that expect a class (such as `xlua.private_accessible`) now accept a C# `Type` object.
5. Added support for iterating over `IEnumerable` objects with `pairs`.
6. In hotfixes, an overridden method can call the overridden implementation, corresponding to the C# `base` keyword.

Changes
1. Simplified reflection access to properties for better compatibility.

Bug fixes
1. Added iOS 11 compatibility by removing system calls.
2. Fixed structs implementing interfaces incorrectly bypassing GC-optimized code.
3. Fixed .NET compatibility for the `emit` feature.
4. Fixed handling of `ulong` constants in `emit`.
5. Fixed generated interface bridge code when a parent and child interface had same-named properties with different types.
6. Prevented coroutine pointers from being reused while repeatedly creating and destroying coroutines across multiple VMs.
7. Avoided generating code when a parameter was a generic type such as `ICollection`.

v2.1.10 — September 18, 2017
New features
1. Added `DoNotGen` configuration, allowing some methods on a type to use reflection and others generated code.
2. Added wrapper emission.
3. Added WebGL support.
4. Added interface inheritance to interfaces implemented in Lua.
5. Added Android builds from Windows (contributed by xdestiny110).
6. Packaging now reports an error if “Generate Code” has not been run.

Changes
1. Changed `async_to_sync` to report errors from `resume`.
2. Temporarily removed generic reflection calls under IL2CPP.
3. Upgraded to Lua 5.3.4 and incorporated all upstream patches through September 1, 2017.

Bug fixes
1. Fixed crashes when reflection created a Lua-function mapping for a C# type that only declared `Delegate` and `MulticastDelegate`.
2. Fixed DLL compatibility with some older Windows versions, such as Windows XP.

v2.1.9 — August 10, 2017
New features
1. Added minimum code-generation mode, enabled with `GEN_CODE_MINIMIZE`, which can save 50% of text-section space.
2. Added `xlua.util.createdelegate`, allowing Lua to create a delegate from a C# function without Lua adaptation.
3. Added support in `xlua.private_accessible` for `public int Prop { get; private set; }`.
4. Added `xlua.getmetatable`, `xlua.setmetatable`, `xlua.setclass`, and `xlua.genaccessor`, allowing Lua to work directly with C# types.
5. Added extension-method support under reflection.
6. Lua 5.3 builds now support overloaded bitwise operators: C# bitwise operator overloads map to Lua bitwise operator overloads, and all enums gain `&` and `|` operators.

Engineering improvements
1. Added Travis continuous integration.

Changes
1. `LuaCallCSharp` now automatically excludes anonymous types.
2. Renamed `THREAD_SAFT` to `THREAD_SAFE`.
3. Deprecated `GenFlag.GCOptimize`.
4. Removed the deprecated `GenConfig` configuration method.

Bug fixes
1. Removed disabled system APIs from Windows Phone source code.
2. Fixed generated-code failures for generic constraints requiring `struct`.
3. Fixed enum generated-code errors with Unity 2017 and .NET 4.6.

v2.1.8 — June 27, 2017
New features
1. Added custom options to the Hotfix attribute: `ValueTypeBoxing`, `IgnoreProperty`, `IgnoreNotPublic`, `Inline`, and `IntKey`.
2. Optimized Hotfix code injection to reduce text-section size.
3. Hotfix configuration can now be placed in the Editor directory to reduce text-section size.
4. Added support for passing an `object` as a specified type.
5. Reflection calls to obsolete methods now print a warning in the Editor.

Changes

Bug fixes
1. Fixed generated-code failures caused by separately setting P/Invoke `In` and `Out` attributes.
2. Fixed generated-code compilation failures when a project had a class in the global namespace with the same name as a class in the xLua namespace.

v2.1.7 — May 17, 2017
New features
1. Added support for publishing UWP applications, including HoloLens, Xbox One, Windows 10 Mobile, and Windows 10 PC.
2. Added RSA + SHA-1 signatures for Lua source code.
3. Added a “please install the Tools” prompt when Tools is missing.
4. Added Linux support.
5. Added bitcode packaging support.
6. Added parameterless constructors to all structs.
7. Renamed delegate parameters to `p0` through `pn` to avoid conflicts between business-code variables and generated code during hotfixing.
8. Added support for member names that are C# keywords.
9. Added `util.loadpackage`, similar to `require`: it loads through a searcher but does not execute the file or cache it in `package.loaded`.
10. Improved template-engine performance when generating large files.
11. Added an injection mode that does not require generated code.
12. Added support for `ref` and `out` constructor parameters.
13. Added blacklist support for constructors.

Changes
1. Changed the overloaded `this[object field]` operator.
2. Made reflection data-conversion rules consistent with generated code.
3. Excluded anonymous classes and anonymous functions from injection.

Bug fixes
1. Worked around a Unity bug: `List<CustomType>` could not resolve `CustomType` with `Type.GetType` unless the assembly was specified, even though .NET did not require it when the type belonged to the executing assembly.
2. Fixed reflection passing null when a variadic argument was omitted.
3. Fixed injection failures when a type inherited from another assembly and used a protected member.
4. Removed `dlopen` and `dlsym` calls from LuaJIT.
5. Fixed the generic code-generation tool not finding its template.
6. Fixed reflection importing generic types in the generic build.
7. Fixed `LuaEnv.Dispose` failures caused by cached reflection calls to APIs with delegate parameters.
8. Made declarations compatible with older C compilers by placing declarations at the beginning.
9. Fixed injection failures caused by different hotfix-detection algorithms in code generation and the injection tool.
10. Fixed generated-code errors when an injected nested type was public but its outer type was not.
11. Prevented false destructor matches based only on method name.
12. Fixed injection failures when a non-public constructor had no matching delegate adapter.
13. Fixed extension methods being generated for all subclasses, a regression introduced by the generic feature in 2.1.6.
14. Fixed constructor overloads where only one overload could be hotfixed.
15. Worked around a possible IL2CPP bug in Unity 5.4: on iOS, a string parameter with default value `""` could appear as `Reflection.Missing` through reflection.
16. Fixed passing a Lua table to `List<>` using the final parameter instead of the table length.
17. Worked around an IL2CPP conversion failure for `ldarg` when using template injection and an output parameter occupied an argument position from 4 through 255; changed to the more compatible `ldarg.s` instruction.
18. Fixed Editor crashes during code generation when `System.Delegate` was configured for `CSharpCallLua`.
19. Fixed reflection not handling an extension method with the same name as an existing method.
20. Fixed variadic delegate calls in the generic build.
21. Changed the Unity 4 workaround for Lua 5.3 conflicts to return null; throwing an exception prevented `IsNull` from working correctly.
22. Changed failed `lua_tostring` decoding to use UTF-8.

v2.1.6 — March 1, 2017
New features
1. Added constrained generic support (by forsakenyang).
2. Added support for non-Unity .NET environments.
3. Added a small-tool mode for code injection that does not require copying the Cecil library, avoiding mismatched Cecil versions and conflicts with Unity or Visual Studio plug-ins.
4. Hotfix configuration now supports fields and properties.
5. Made Unity coroutine hotfixes easier to use.
6. Added event triggering from hotfixes.
7. Added `ForEach` and `Length` to `LuaTable`.
8. Improved CMake project generation while preserving the source-file directory structure.
9. Protected access to disposed `LuaEnv` instances. `Dispose` now checks that all callbacks have been released and reports an error if any remain.
10. Added support for releasing Hotfix callbacks.

Changes
1. Changed constructors to run the original logic before calling Lua.
2. Removed support for the overloaded `this[string field]` operator because it affected inherited calls.
3. Changed code injection in the Editor to a manual operation.

Bug fixes
1. Prevented generated-code name conflicts when a class defined both a `get_xx` method and an `xx` property.
2. Fixed struct injection code not taking effect.
3. Added a namespace to `Utils` to prevent conflicts with application code.
4. Prevented generated-code conflicts for delegates returning fixed-length multidimensional arrays.
5. Fixed variadic argument expansion for interfaces and when code generation was disabled in the Editor.
6. Fixed `ManifestModule` unsupported errors under IL2CPP when generated code was disabled.
7. Worked around a Unity 4 Editor crash when accessing a destroyed `UnityEngine.Object`; this did not occur in Unity 5 or the LuaJIT build.
8. Fixed an issue introduced in the previous version where `xlua_setglobal` left a value on the stack, making some 32-bit applications unstable.
9. Fixed overload conflicts between delegate parameters that differed only by `ref` versus `out`.

v2.1.5 — January 13, 2017
New features
1. Added cross-platform hotfixes.
2. Added thread-safe mode, enabled with the `THREAD_SAFT` macro.
3. Added simpler configuration; see “XLua Configuration” under `XLua/Doc`.
4. Added automatic disposal for multiple VM instances.
5. Reduced memory use for anonymous-closure-to-delegate mappings, `LuaFunction`, and `LuaTable`; reduced GC when mapping Lua tables to C# interfaces.
6. Improved code-generation speed.
7. Added direct cloning of C# structs from Lua.
8. Added a no-GC call API to `LuaFunction`.

Changes
1. All delegates now require `[CSharpCallLua]` for C#-to-Lua callbacks. Previously, adding it to one delegate was enough when parameter and return types matched.
2. Restored automatic conversion from strings and numbers to enums.

Bug fixes
1. Fixed first use of an enum without generated code creating two different userdata objects.
2. Fixed `System.Type` generated code failing to load because of a circular reference between arrays and `System.Type`.
3. Made exception handling safer: wrapped exceptions from `lua_setglobal` and `lua_getglobal`, and ensured C# callbacks catch all C# exceptions and convert them to Lua errors.

v2.1.4 — November 29, 2016
New features
1. `ReflectionUse` now automatically adds entries to `link.xml`, preventing reflection from failing due to stripping under IL2CPP.
2. Opened the code-generation engine for extension, including generating custom plug-ins, required code, or configuration.
3. Optimized `GetInPath` and `SetInPath` to avoid C# GC allocations.
4. Lua tables can now be converted automatically to complex types marked with `GCOptimize`, and to one-dimensional arrays of those types, without reflection. Pure value types in this path also avoid C# GC allocations.

Changes
1. For consistency and performance, removed silent conversion from numbers and strings to enums; call the enum type's `__CastFrom` explicitly.
2. Renamed the namespace from `LuaInterface` to `XLua`.
3. Marked several `LuaTable` APIs that could cause GC as obsolete.
4. When no return type is specified, an integer-valued number is now preferentially converted to an integer.

Bug fixes
1. Fixed types with implicit conversions from `int`, `long`, or `decimal` being passed to Lua as decimal.
2. Fixed reflection overload matching incorrectly accepting a mismatched variadic argument.
3. Fixed variadic overloads reporting invalid arguments when no variadic values were passed.
4. Fixed extension methods marked with `LuaCallCSharp` being unavailable in the Editor when code generation was disabled.

v2.1.3 — November 9, 2016
New features
1. Added generic `Get<TKey, TValue>` and `Set<TKey, TValue>` interfaces to `LuaTable`, allowing table access with value types and no GC allocation.
2. Added `decimal` support without precision loss or GC allocation when passing values to Lua.
3. Added `LuaEnv.LoadString<T>` to specify the delegate type returned.
4. Refreshed examples with Hello World, no-GC calls, Lua object-oriented programming, and coroutine examples.
5. Optimized enums: passing them to Lua and converting from integers or strings now avoids GC allocations.
6. Doubled the performance of event `+`/`-` operations and removed their GC allocations.
7. Simplified generated code.

Changes
1. Mapped `uint` to `lua_Integer` in Lua 5.3.
2. Lowered the priority of loading from StreamingAssets.

Bug fixes
1. Fixed generated code throwing when a `LuaTable` or `LuaFunction` parameter was null.
2. Fixed silent conversion from floating-point values to enums failing under Lua 5.3.
3. Fixed reflection throwing for struct parameters with default values.
4. Fixed `Length` returning a floating-point value under Lua 5.3.

v2.1.2 — October 8, 2016
New features
1. Added Lua 5.3 support, including Apple bitcode, native 64-bit integers, bitwise operations, and UTF-8 features.
2. Added CMake builds to make third-party plug-ins easier to include.
3. Optimized array access performance and GC behavior.
4. Reduced one Lua GC operation when C# called a Lua function.
5. Improved startup time.
6. Reduced GC during type loading.
7. Reduced `ObjectPool` memory use.
8. Reduced GC when passing short strings to Lua.
9. Added `LuaTable.Cast` to convert a `LuaTable` to other types such as interfaces.
10. Added `LuaFunction.Cast` to convert a `LuaFunction` to a delegate.

Changes
1. Lua internally uses only signed 64-bit integers; added a library for unsigned integers.
2. To use extension methods through reflection without generating code for them, add `ReflectionUse`.

Bug fixes
1. Fixed a memory leak in automatic release of references to destroyed `UnityEngine.Object` instances in `ObjectPool`.
2. Worked around a Unity memory leak in some versions, known to include 5.3.3.
3. Fixed generated code for delegates returning `LuaTable` or `LuaFunction`.

v2.1.1 — August 29, 2016
New features
1. Added Editor execution without generated code.
2. Added `IntPtr` support.
3. Added automatic release of references to destroyed `UnityEngine.Object` instances in `ObjectPool`.
4. Added wrappers around `lua_gc` to `LuaEnv`.

Bug fixes
1. Made generated-code and reflection behavior consistent when passing a `LuaFunction` or `LuaTable` to Lua. Generated code passed a C# object; reflection passed the Lua function or table, which is the appropriate behavior.
2. Fixed conflicts between same-named static and instance methods.
3. Fixed generated `CSharpCallLua` code for interfaces with indexers.
4. Fixed the Editor creating a new xLua instance after running.
5. Fixed generated calls failing when a function had both variadic parameters and default values and no arguments were passed.
6. Fixed the socket library not being found while debugging.

Changes
1. Kept reflection overload ordering fixed and consistent with generated code.
2. Added `fade_id` to i64 for safer parameter passing.
3. Restored `tdr.from_file` support.

v2.1.0 — August 8, 2016
New features
1. Added no-GC passing of eligible structs to Lua. To qualify, a struct may contain nested structs but it and all nested structs may contain only these primitive types: `byte`, `sbyte`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `float`, and `double`. The struct and its use sites must have `LuaCallCSharp` and `GCOptimize` configured.
2. Reimplemented reflection to work more easily with generated code:
   a. Added extension-method support and `Enum.__CastFrom`.
   b. Added reflection event support on iOS.
   c. Aligned type mapping and variadic calls with generated code.
   d. Improved performance and reduced GC.
3. Simplified the code-generation menu and added a “Generate Minimum” option.
4. Allowed generated-code configuration files to be placed in the Editor directory.

Changes
1. Upgraded all LuaJIT builds to 2.1.0b2.
2. Changed LuaSocket to load on demand.
3. Allowed string and `byte[]` arguments in overloaded methods to be nil.
4. Accessing a subclass no longer triggers loading of its parent class.
5. Changes to a struct `ref` parameter now update the corresponding Lua-side argument.
6. Changed generated-code loading from reflection to static loading.
7. Simplified the menus.
8. Disabled TDR loading by default.
9. Deprecated loading Lua from StreamingAssets.

Bug fixes
1. Fixed generated-code compilation errors for arrays of generic classes and two-dimensional arrays used as parameters or return values.
2. Fixed generated-code compilation errors for abstract classes.
3. Removed a warning from generated `Clear` code.
4. Fixed the profiler and i64 libraries not supporting multiple instances.

v2.0.5 — May 18, 2016
New features
1. Added `util.async_to_sync`, which uses Lua coroutines for synchronous-style programming with asynchronous execution, or asynchronous waiting for WWW and similar operations.
2. Improved generated-code style to remove some tool warnings.

Bug fixes
1. Fixed a race window during Lua GC between removing a weak-table entry and calling `__gc`: pushing the same object during that window could create distinct userdata for the same C# object.
2. Included the Lua memory tool that was missing from the previous release package.
3. Fixed code generation for nested types.

v2.0.4 — May 4, 2016
New features
1. Added function call-duration reports.
2. Added a Lua memory leak locator.
3. Added unsigned 64-bit integer support on the Lua side.

Changes
1. Allowed multiple delegates to bind to one closure; previously one closure could correspond to only one delegate type.

Bug fixes
1. Fixed TDR handling of arrays of length one: unpacking should produce `{[1] = {a = 1}}`, not `{{a=1}}`.
2. Fixed TDR numeric conversion where `int` value -1 could unpack as a very large positive number.

v2.0.3 — April 13, 2016
New features
1. Added “Advanced Gen”, allowing users to customize the scope of generated code.
2. Added static pushers for libraries.

Changes
1. Changed `LuaTable` and `InterfaceBridge` to trigger metatables.
2. Extension methods are no longer added automatically to the types they extend; add them to the generation list.
3. Removed the special value-type optimization.

Bug fixes
1. Fixed generated-code syntax errors for private extension methods.
2. Fixed generated-code syntax errors for overloaded functions containing `ulong`.
3. Fixed default-value handling in reflection calls.
4. Fixed string-length handling for Chinese characters passed from C# to Lua.

v2.0.2 — April 6, 2016
Changes
1. Supported multiple generated-code configuration files for libraries to simplify project modularization.
2. Merged generated enum code into one file.
3. Improved exception handling.
4. Separated libraries, tutorials, and examples in release packages for a cleaner layout.
5. Fixed minor bugs.

Upgrade guide
Because some files changed, replacing the old library in place causes errors. Instead:
1. Delete the old XLua directory.
2. Extract `xlua_v2.0.2.zip` under `Assets`.
3. Run code generation again.

v2.0.1 — March 24, 2016
1. Added C# extension-method support.
2. Added Lua debugging support.
3. Fixed Android `require` potentially succeeding for a Lua file that did not exist.
4. Updated the TDR 4 Lua library.
5. Tested compatibility across multiple device models.

v2.0.0 — March 8, 2016
1. Improved performance; see the project homepage for the comparison report.
2. Added TDR for the official Lua version.
3. Added 64-bit integer support.
4. Fixed instability caused by `pcall` handling C# exceptions in Lua.
5. Improved ease of use.
6. Fixed other bugs.

1.0.2 — December 9, 2015
1. Fixed access to `streamAssetsPath` in a constructor, which was disallowed in newer versions (known to include 5.2).
2. Added Windows x64 support.
3. Added conditional compilation for code used only by the Web version, reducing its impact on mobile release packages.
4. Removed `+` from generated-code file names.
5. Removed .NET 4.6 generated code to avoid references to obsolete APIs in newer versions.

v1.0.1 — November 30, 2015
1. Added support for catching C# exceptions with `pcall`.
2. Added a cast method for cases where the implementation class is declared `internal` and only an interface is exposed.
3. Fixed generated-code compilation errors for interfaces containing events.
4. Fixed generated-code compilation errors for obsolete interface methods and fields.
5. Fixed generated-code compilation errors for default getters/setters containing `private` accessors.
6. Fixed generated code for classes in the global namespace being unusable.
7. Fixed return-value handling in bridge code.

v1.0.0 — March 30, 2015
First release.