Lua - Part 11

https://luakit.github.io/

Luakit is a highly configurable browser framework based on the WebKit web content engine and the GTK+ toolkit. It is very fast, extensible with Lua, and licensed under the GNU GPLv3 license. It is primarily targeted at power users, developers and anyone who wants to have fine-grained control over their web browser’s behaviour and interface.

Luakit Overview
https://www.youtube.com/watch?v=Sqer9xgREhg


https://fennel-lang.org

Fennel is a programming language that brings together the speed, simplicity, and reach of Lua with the flexibility of a lisp syntax and macro system.


PL/Lua: Lua as a loadable procedural language for Postgres (github.com)

https://github.com/pllua/pllua

https://news.ycombinator.com/item?id=18018761


https://langserver.org/

https://microsoft.github.io/language-server-protocol/implementors/servers/

https://github.com/mascarenhas/lua-lsp

https://github.com/Alloyed/lua-lsp


when i want to work with sqlite, then i will probably need this:

https://luarocks.org/modules/dougcurrie/lsqlite3

$ luarocks install lsqlite3

lsqlite3 is a thin wrapper around the public domain SQLite3 database engine. The lsqlite3 module supports the creation and manipulation of SQLite3 databases. After a require('lsqlite3') the exported functions are called with prefix sqlite3. However, most sqlite3 functions are called via an object-oriented interface to either database or SQL statement objects.


Oct 4, 2018 HN comment

The issue from a hosting provider is the platform has to be 100% sandboxes; cpu, heap, network and file system access. Lua is the only runtime that provides this level of control. SQLite can do massive multi tenancy and acceptable performance if used correctly.


RaptorJIT 1.0: Lua implementation for high-perf low-level system programming (github.com)
https://github.com/raptorjit/raptorjit/releases/tag/v1.0.0
https://news.ycombinator.com/item?id=18224086


might be able to run corona on linux by using wine, which runs windows programs on linux.

https://forums.coronalabs.com/topic/73309-corona-on-linux-the-ultimate-guide-for-almost-beginners/


https://www.quora.com/Is-Lua-a-good-language-for-a-beginner-who-wants-to-start-creating-an-Android-game

https://platypusplatypus.com/chromebooks/run-roblox-chromebook/


router code

https://github.com/APItools/router.lua

https://github.com/APItools

Slack bots

https://api.slack.com/community#lua

https://github.com/lusis/lubot

https://github.com/ConnorVG/Lua-Slack

https://github.com/picsoung/breezBot/

HTML parsers

https://github.com/msva/lua-htmlparser - installed on Oct 26, 2018 - luarocks install htmlparser

this failed to install: https://github.com/craigbarnes/lua-gumbo

from 5 years, someone's script to parse html:

https://gist.github.com/exebetche/6126573


SciLua: Scientific Computing with LuaJIT (scilua.org)
https://news.ycombinator.com/item?id=18304314
http://scilua.org/

LAL – a Scheme like dialect of Lisp that compiles to Lua (github.com)
https://github.com/WeirdConstructor/lal

RaptorJIT 1.0: Lua implementation for high-perf low-level system programming (github.com)
https://github.com/raptorjit/raptorjit/releases/tag/v1.0.0
https://news.ycombinator.com/item?id=18224086

https://blog.callr.tech/rate-limiting-for-distributed-systems-with-redis-and-lua/

Tables (lua.org)
https://www.lua.org/pil/2.5.html
https://news.ycombinator.com/item?id=17969795 - sep 2018


https://wiki.tcl-lang.org/page/Lua

http://tset.de/ltcltk/index.html

The evolution of an extension language: a history of Lua
https://www.lua.org/history.html


Oct 30, 2018 HN thread with over 130 comments.

"A Look at the Design of Lua (acm.org)"

https://cacm.acm.org/magazines/2018/11/232214-a-look-at-the-design-of-lua/fulltext

https://news.ycombinator.com/item?id=18327661

good comments:

https://news.ycombinator.com/item?id=18338953
https://news.ycombinator.com/item?id=18334812


This is fascinating. And it's by Microsoft. !!!

"Golua – A Lua 5.3 engine implemented in Go (github.com)"
https://github.com/Azure/golua

https://news.ycombinator.com/item?id=18469672

Amazing. Microsoft releases an open source implementation of a Lua VM written in Go. I feel like I’m in the twilight zone!

"What are the goals of this project?"
https://github.com/Azure/golua/issues/36

https://www.reddit.com/r/golang/comments/9x4ksg/azuregolua_a_lua_53_engine_implemented_in_go/e9plmjw/

https://www.reddit.com/r/golang/comments/9x4ksg/azuregolua_a_lua_53_engine_implemented_in_go/

from the GH issues page:

There are several reasons:

We need a Lua 5.3 engine, and the others were not, nor where they interested in updating

The VM is designed differently (I'm encouraging Brian to write a blog post about this), but in a nutshell it is designed for better error handling and for adding a debugger

We wanted an implementation that was closer to the Lua spec than some of the others. We haven't totally nailed that, but we're getting closer by the day

We also wanted clean and idiomatic Go APIs

Before starting on this path, we had been using other Go Lua implementations for quite a while. We just finally arrived at the point where it became evident that our needs were not going to be met.

Eventually we will add more documentation to the README. We honestly didn't think people would discover (let alone use) this project the day we open-sourced it. So it's been a pleasant surprise, but one that caught us off guard.

Comment from the HN thread:

I'll admit I don't use or know Go, but I have been in the Tarantool docs lately. It is a JIT compiled "drop in replacement for Lua 5.1 or JIT" and has fibers and channels inspired from Go.

https://medium.com/tarantool-database/dbms-as-an-application-server-779402dbf485

Multiple Golang Lua interpreters exists. Amazing.

https://github.com/arnodel/golua

Another HN comment:

The above is shorter and also significantly more efficient because you're not creating the intermediate table object. Even in Go, given Lua's coroutine and tailcall semantics (assuming they were implemented) the Go compiler would likely be forced to always heap allocate the argument list table. There's a reason PUC Lua is blazingly fast, and its partly the same reason why LuaJIT is so fast--the Lua stack protocol is a thin abstraction that easily admits a simple, efficient implementation yet still managing to provide an effective interface boundary that doesn't leak (beyond the fact of the protocol itself).