>>25285
What about TCL? Is it also small enough?

>>25335
TCL is a few megabytes
Lua is WAY smaller, it's not even close.

>>25336
What about TinyLisp?

>>25334
256kb WASM or even less that can run lua and manipulate DOM would be awesome

>>25332
Yea, I know.

>>25338
I haven't worked on it for a while, but the latest I had it compiling down to 375kb. With certain emcc flags I managed to bring it down to closer to 250kb but it hurt the Lua VM performance a lot, so under 400kb is a more reasonable target.
A lot of that is the JS side (type marshaling alone is 1k lines of JavaShit) and additional logic in Lua, like an extension of the garbage collector for circular references between JS and Lua heap.
God I really need to work on this again. I would personally eat my own dogfood and use it over the alternatives already even though it's not done yet since Lua in the browser is just so underserved (there's not many options)
I'm considering removing a bunch of stuff from it just so I can reduce debugging complexity and get it to a state I'm comfortable putting on github.

>>25340
lua and js are close enough that requiring a luajit-sized (300 kb) blob just for running one vm in another is just tragic and a loss of performance, compared to transpiling.

>>25341
They are close on the surface but their VMs are nothing alike.

>>25341
Coroutines and most metamethods can't be represented in JS btw. So you wouldn't be able to support the whole language spec this way.

>>25343
lua coroutines map into js generators, metamethods map into js proxy and/or replacing operators with explicit function calls.

>>25344
Using generators as ghetto coroutines is going to be harder than it looks when you have stuff like a coroutine resuming a coroutine resuming a coroutine, etc. but yeah it could work.

aren't there like five different and backwards-incompatible Lua's? each version is slightly different and each JIT is slightly different.

>>25346
Not really. The closest thing I can think of to what you're implying is that Lua 5.2 changed how function environments work (a 5.1 feature) but that's about it. Lua 5.5 is backwards compatible with Lua 5.2 and most Lua 5.2 code that doesn't touch fenvs will also work with 5.1.
>each JIT
There is only 1 LuaJIT, written by Mike Pall, which is the 5.1 spec with some 5.2 features backported.

>>25347
thanks. as for JITs I meant various commercially-supported forks like Luau (Roblox), GLua (Facepunch), OpenResty LuaJIT etc

>>25348
GLua is just PUC Lua 5, and OpenResty uses Mike Pall's LuaJIT
Luau yeah I guess.

>>25349
5.1*

>>25333
Funny you say that, once upon a time back in like '02 I hacked together an experiment like that.

>>25349
>GLua is just PUC Lua 5
GLua has C-style logic operators and comments

>>25315
Ive only seen nocoders cry about this

>>25285
Mike Pall returns to discuss new syntax additions to be added in LuaJIT 3.0
https://github.com/LuaJIT/LuaJIT/issues/1475
Some of them are already backported to LuaJIT 2.1
https://github.com/LuaJIT/LuaJIT/issues/1476
My favorite are
>ternary
>short functions
>safe navigation operator

>>25354
>returns
Pretty active on github actually, idk why I thought he was gone

>>25354
>ternary
bro you literally call already do that with "and" and "or". do you really think saving to type 3 characters is a significant improvement?

>>25354
I love the idea of short functions, but that syntax is kind of garbage.
The safe navigation operator is definitely my favorite from the list, if I had to pick 1 feature to add to keep Lua de-bloated that would be the one.
>>25356
Not a ternary operator, that's just short-circuited logical operators. Try it yourself and see `a and false or b` returns `b` regardless of whether `a` is true or not. If it was a real ternary operator then it would return false if a was true and b if a was false.

>>25285
I just recently looked into Lua because I got interested into prototype based OOP languages like self and io and to me their object model implementation makes more sense than a class-instance based one

Lua is already similar in terms of delegation to prototype OOP and it's really easy to implement it under Lua. I asked chatgpt to write a simple library and seems to work pretty fine, at least for toying around


-- object.lua

local Object = {}
local Meta = {}

local function lookup(self, key)
local value = rawget(self, key)

if value ~= nil then
return value
end

local proto = rawget(self, "__proto")

if proto then
return lookup(proto, key)
end
end

Meta.__index = function(self, key)
local value = lookup(rawget(self, "__proto"), key)

if value ~= nil then
return value
end

local forward = lookup(self, "forward")

if forward then
return forward(self, key)
end
end

function Object:clone(slots)
local obj = slots or {}
rawset(obj, "__proto", self)
return setmetatable(obj, Meta)
end

function Object:proto()
return rawget(self, "__proto")
end

function Object:slotNames()
local names = {}

for name in pairs(self) do
if name ~= "__proto" then
names[#names + 1] = name
end
end

return names
end

function Object:forward(name)
error("message not understood: " .. tostring(name), 2)
end

setmetatable(Object, Meta)

return Object




So I can do

local Animal = Object:clone {
speak = function()
print(self.sound .. "!")
end
}

local Dog = Animal:clone {
sound = "woof"
}

Dog:speak()

>>25358
I personally don't like it (tables are enough) but people have been doing this for a really long time, it's a completely valid use of metatables
http://lua-users.org/wiki/SimpleLuaClasses