NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
Go modules
Go modules, #2045 by repository stars
Latest stable
v1.1.8
Last release 4 months ago
17 Jul 2026
Ships unpredictably
gaps range from 2 weeks to 4.3 years
Most releases are documented
notes for 7 of 8 stable releases
Nothing withdrawn
no release was ever pulled
10 years old
13 releases · first in 2016
Drag across the ruler to compare, or tap a release to open it.
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Your coding agent can read these notes before it upgrades. Set up the MCP server →
Nothing published for this version
Function calls or parenthesized expressions that are followed by table indexers are now properly compiled (Fixed #13).
pcall not returning true on success (Fixed #19).Nothing published for this version
Fun with tables! Ok, not so much fun.
Fun with tables! Ok, not so much fun.
And, another stupid little bug.
And, another stupid little bug.
[=[]==]]=] were not working properly. The lexer was not properly constructing the lexeme, and it would return the wrong number of equals signs and it would eat the last square bracket. As a bonus I greatly simplified the string lexing code. (ast/lexer.go)Not sure how I missed this one... Oh well, it should work now.
Not sure how I missed this one... Oh well, it should work now.
require was not checking package.loaded properly. (lmodpackage/functions.go)More script tests, more compiler bugs fixed. Same song, different verse.
1.1.1
More script tests, more compiler bugs fixed. Same song, different verse.
2 ^ - -2. To fix this issue I totally rewrote how operators
are parsed. (ast/parse_expr.go)and in non-boolean contexts. Also and and or may produce slightly better code now. (compile_expr.go)I was a little bored recently, so I threw together a generic metatable API. It was a quick little project, based on earlier work for one of my many to
1.1.0
I was a little bored recently, so I threw together a generic metatable API. It was a quick little project, based on earlier work for one of my many toy languages. This new API is kinda cool, but it in no way replaces proper metatables! Basically it is intended for quick projects and temporarily exposing data to scripts. It was fun to write, and so even if no one uses it, it has served its purpose :P
I really should have been working on more script tests, but this was more fun... Anyway, I have no doubt responsibility will reassert itself soon...
Anyway, I also added two new convenience methods for table iteration, as well as some minor changes to the old one (you can still use it, but it is now a thin wrapper over one of the new functions, so you shouldn't).
go fmt. I often forget to do this, but I recently switched to a new editor that formats files
automatically whenever they are saved. Anyway, everything is formatted now. (almost every file in minor ways)Protect and Recover, simple error handlers for native code. They are to be used when calling native APIs
outside of code otherwise protected (such as by a call to PCall). Recover is the old handler from PCall, wrapped
so it can be used by itself. Protect simply wraps Recover so it is easier to use. (api.go)ForEachRaw, basically ForEachInTable, but the passed in function returns a boolean specifying if you want to
break out of the loop early. In other news ForEachInTable is now depreciated. (api.go)ForEach, a version of ForEachRaw that respects the __pairs metamethod. ForEachRaw uses the table iterator
directly and does much less stack manipulation, so it is probably a little faster. (api.go)supermeta adds "generic" metatables for just about any Go type. For obvious reasons this
makes heavy use of reflection, so it is generally much faster to write your own metatables, that said this is really
nice for quickly exposing native data to scripts. From the user's perspective you just call supermeta.New(l, &object)
and object is suddenly a script value on the top of l's stack. Arrays, slices, maps, structs, etc should all work
just fine. Note that this is very new, and as of yet has received little real-world testing! (supermeta/supermeta.go,
supermeta/tables.go)testhelp contains a few test helper functions I find useful when writing tests that interact
with the VM. Better to have all this stuff in one place rather than copied and pasted all over... (testhelp/testhelp.go)testhelp rather than their own copies.
The API tests still have their own copies of some of the functions, as they need to be in the base package so they can
access internal APIs (stupid circular imports). (script_test.go)More tests, more (compiler) bugs fixed. Damn compiler will be the death of me yet...
More tests, more (compiler) bugs fixed. Damn compiler will be the death of me yet...
In addition to the inevitable compiler bugs I also fixed the way the VM handles upvalues. Before I was giving each closure its own copy of each upvalue, so multiple closures never properly shared values. This change fixes several subtle (and several not so subtle) bugs.
Oh, and pcall works now (it didn't work at all before. Sorry, I never used it).
function a:x() end). Depressingly the issue was only one
incorrect word, but it resulted in very wrong results (I am really starting to remember why I hated writing the
compiler, the VM was fun, the compiler... not.) (ast/parse.go)(...))
were not properly truncating the result to a single value. (compile_expr.go)break and continue statements are now properly patched by the compiler to close any
upvalues there may be. (compile.go)pcall script function so it actually works. (lmodbase/functions.go)One column per quarter.