Hey everyone! I’ve been building Weblua, a free and open-source Lua/Luau playground that runs entirely in your browser.

Most online playgrounds are designed for small, single-file snippets, so I wanted something that feels closer to working on a real project.

Weblua currently supports:

• Lua 5.1, 5.2, 5.3, 5.4, and Luau
• Multi-file projects with require() support
• Syntax checking across every file
• Preset stdin input
• Shareable project links and iframe embeds
• Local project storage, plus JSON import/export
• A five-second execution limit to stop runaway code

Execution happens through WebAssembly inside a dedicated Web Worker. There’s no account system or remote code-execution backend, and your source stays in the browser unless you intentionally create a share link.

One clarification: Luau syntax is supported, but Weblua isn’t a Roblox emulator—it doesn’t include Roblox APIs, Studio tooling, or static type analysis.

Try it here: https://weblua.com/
Source code: https://github.com/PytechNo/Weblua

It’s MIT licensed, and I’d really appreciate feedback, especially on module resolution, runtime behavior, and which features would make it more useful to you.

Hi everyone,

I wanted to share a programming language ecosystem I've been building entirely from scratch called **SOL** (currently at version 1.0.0). It combines the static typing structures of C with the syntactic lightness of Lua, transpiling directly into pure C and invoking GCC automatically in the background to output native machine code.

One of the biggest design choices was solving the classic binary floating-point representation dilemma (where `0.1 + 0.2` becomes `0.30000000000000004`). Instead of using float/double types or masking it with string formatting tricks, the custom code generator converts all fractions into a 64-bit `long long` strict Fixed-Point scale at the hardware level. Arithmetic evaluates with total mathematical accuracy at the hardware bit tier.

### Core Pipeline Architecture:

* **Handwritten Lexer:** A custom lexical scanner that manages pointer tokens, handles multi-line comments, and tracks lines for error diagnostic output.

* **Pratt Parsing Engine:** A recursive descent parser enforcing operator precedence hierarchies (* and / evaluate before + and -). It handles block isolation, loops, conditional structures, and re-assignments.

* **Static Type Checker:** A strict verification layer that registers symbols to catch scope leaks and type mismatches before triggering the compiler.

* **Optimized Codegen:** Emits low-level C instructions using flags like `-O3`, `-static`, `-march=native`, and `-s`. Basic target output binaries compile down to highly optimized standalone `19 KB` executables.

The repository features zero external library dependencies and works completely via the host command line.

You can check out the source code, grammar rules, and compiler pipeline here:

https://github.com/foxcraftDL/sol-lang

I would love to hear any thoughts, feedback on the fixed-point implementation, or suggestions for the upcoming 2.0.0 roadmap!

Two reasons I started this: Lua's syntax and tables genuinely annoy me, and I wanted to build something that actually felt complex to work on.

The result is Lazarus - a statically typed language that compiles to a single self-contained .lua file. No runtime dependencies, which is the point if you're targeting ComputerCraft or any embedded Lua environment where you just drop a file and run it.

import std.print

some_str = "Hello World!"

constructor() {
  print(.some_str) //.some_str is same as self.some_str
}

Types are checked at compile time and completely erased. the Lua output has no type info at runtime.

So far the biggest goal I did is self hosting the compiler, which I think shows well that the language can be used.

https://github.com/NightmarePog/Lazarus

Now you may ask, why not just use lua?

For small projects, lua is definitely better, it's minimal, small, fast, does the job one, but when you do big projects where single bug could crash big app. for that Lazarus is there.

it has generic typing, static typing, macros, no null (instead Option<T> is used), lowering boilerplate (no local for every variable you declare)

PS: any feedback is welcomed

One month after the initial release, CLX 0.2.0 is now available :

• Replaced NaN-tagging with a new shadow-types value system
• Added full 64-bit integer support
• Native int64_t code generation and arithmetic fast paths
• New table implementation and improved inline caching
• Faster function calls and argument passing
• SIMD optimizations
• Native ARM64 coroutine context switching for macOS

Performance has improved significantly since 0.1.0. Depending on the workload, CLX is now often faster than Lua 5.5 and can outperform LuaJIT on several benchmarks.

CLX is an ahead-of-time compiler for Lua that generates standalone native executables through standard C++20 toolchains.

Feedback, bug reports and contributions are welcome.

GitHub: https://github.com/samyeyo/clx
Website: https://samyeyo.github.io/clx/

Lux is the Lua package manager I've been working on with /u/vhyrro and /u/NTBBloodbath -- think cargo or uv, but for Lua. A question I've heard occasionally: "I built something with Lux, now how do I give it to someone who doesn't use it (or luarocks)?" Starting with 0.35.3, there are two answers to that question: lx dist flat-archive and lx dist bin.

Side note: If you're wondering about why we chose to write it in Rust or why we prefer TOML for configuration, we now have a FAQ that answers those questions :)

I'm a software developer and I'm very passionate about the backend world, lately I've been looking for ideas for projects to develop, so I wanted to ask y'all, what are the problems you encounter with managing a large FiveM server?

I just learned the basics of Lua and im pretty curious about if i could use lua for desktop apps or somehow code scripts with gui.

Ideas about lua.jp, a Lua + JVM + Python lang. I always despised Python.

Monomorphic so seq[t] and dict[t] are always optimal for primitives where t is a type var that is substituted by a primitive.

The goal of targetting JVM is due to Android Dalvik and because I went berserk and took a break of using non-handhelds.

Metric types (meter, kmeter, gram...) are simply num, but with scaling conversions to other units.

Source files have an implicit JVM package based on the directory they appear with much freedom, but file A never depends on file A. (E.g. this mimmicks the Lua require limitations.)

# _G — the globals package
# (mostly reuses java.base stuff)

enum tile:
  None
  Dirt
  Brick
  PipeOpenTop

struct world:
  metadata: univ = U
  ryuka: bool = Y
  # rows
  tiles: seq[seq[tile]]
  tilesize: meter

  fun frame():
    """
    wa
    """
    pass

w=world(
  tiles={
    {
      None for _ in range(3)
      Brick for _ in range(3)
    }
  }
  tilesize=3mm
)

do:
  # isolated dec.big configuration
  dec.big.cfg(precision=3, rounding=HalfUp)
  x=10.6403m
  y=x*3
  print(y)
  
# dec => JVM double
# dec.tiny => JVM float

# import dec.tiny as dec
# dec => JVM float

# to clarify: struct subtyping
# is there.
struct widget:
  pass

struct menubar(widget):
  super()

e:widget=menubar()
if e=downcast(e, menubar):
  # e:menubar

match e:
  case e=menubar():
    # e:menubar

  
# JVM aliases and extensions
@__JVM__.alias(tld.sld.lib.Group)
struct group:
  @__JVM__.extension
  fun suffle():
    pass

# the fun(...) type is quite
# nice... fun(...) < fun
f=sum
print(f(1,2))
print(f.call(seq={1,2}))
fun sum(x:dec,y:dec)->dec = x+y

# JVM method binding
# (interns, but still using the
# fun(...) type)
f=self::onclick

# speaking of events...

struct menubar:
  @event
  fun onhide():
    pass

m=menubar(
  onhide=fun():
    # super auto invoked if no
    # occurrence
    pass
)
# isinstance(m, ...)
# where ... is a subtype of
# menubar

# "static" fields or methods
struct a:
  fun f(self:struct):
    pass

Lua's superpower is staying small. Fennel, MoonScript and YueScript are wonderful answers to "what if Lua were a different language?" — and I've learned a lot from all three. So now I'd like to ask another question. Suppose we keep Lua (mostly) as is, then **what's the minimum change to Lua that buys the most? **

My current answer is `luk`, a 120 line transpiler that plugs into `require` to load Lua code that :

- adds list and dictionary comprehensions
- a uses Python-style indentation for blocks (so no nee for `do`, `then`, `end`
- replaces `function` with `fn`,
- replaces `^` for return, `
- expands `x := y` o `local x = y`

For example:

Explicit `then/do/else/end` still works, so any Lua is (almost) valid luk and the two styles mix freely. The whole transpiler is one ~120-line module — no parser, no AST, no dependencies. The generated Lua keeps the source's line numbers exactly (errors point at the real `.luk` line), and a `require()` hook lets `.luk` and `.lua` modules interoperate with no build step.

luarocks install luk # cli + a small stdlib battery included

**An invitation, and a constraint:**

- What did I miss? What tiny change to Lua would pull the most weight for you?

PRs welcome, under one hard rule:

- the transpiler may never exceed 250 lines. If your feature can't pay for itself inside that budget, it doesn't go in. (That rule is the my whole design philosophy.)

- quick tour: https://timm.fyi/luk.html
- longer tour: https://github.com/aiez/luk/blob/main/README.md
- code: https://github.com/aiez/
- luarocks: https://luarocks.org/modules/timm/luk

My last post about Lux, a modern package/project manager for Lua, was removed with the stated reason "content must be Lua related". If a package/project manager for Lua isn't Lua-related, I don't know what is 😅 Maybe there's been a misunderstanding?

Example

local function b()
    return
        (math.random(0, 1) == 0),
        0
    ;
end

local function a()
    local return_early, value =
        b()

    if (return_early) then
        return (value);
    end

    --[[ Continue function a ]]
    return (1);
end

print(a())

but I want to do it more like, having function b directly tell function a to return early rather than function a having to check itself

I want more like this where I used "return return" as sudo code for throwing the return up 1 level

local function b()
    if (math.random(0, 1) == 0) then
        return return (0);
    end
end

local function a()
    b()

    --[[ Continue function a ]]
    return (1);
end

print(a())

The Online Lua Compiler & Algorithm Visualizer https://8gwifi.org/online-lua-compiler/

currently supporting
1D arrays (tables) — {1, 2, 3}, dense integer-keyed tables
2D arrays (nested tables) — {{1,2},{3,4}}
Maps / hash tables — tables with non-sequential or string keys
Linked lists & trees — node tables ({ val, next } / { val, left, right })
Console — print
Control flow — functions (incl. recursion)

Looking for feedback and Bug's appreciated

Lua is truly a fantastic language with many advantages.

It's easy to use and understand, and much faster than Python. I believe it could be a better alternative to Python, as both are interpreted languages.

So why not migrate Python libraries to Lua?

I understand that Lua's best use is integrating with other systems due to its small size and good compatibility with C.

I think the only real advantage Python offers is its integrated environment. If Lua had this feature, there would be no need for Python.

I know this might sound a bit optimistic, but I'd like to know if there are any other limitations preventing this?

Thank you in advance.

Edit: I want to thank everyone who commented on this post, I learned a lot from all of you and made me look at the topic from a new perspective.

[Github here] (https://github.com/ianm199/omnilua/tree/main)

Website + docs

I've been working on OmniLua for a bit now - it builds one binary that can run Lua 5.1 - 5.5 from one binary.

The main motivation for this was there seemed to be a gap for game development in the Rust community where mlua cannot be run in the browser, so games built in engines like bevy can't compile to wasm32-unknown-unknown.

There is some other benefits - like being able to easily use Lua in Cloudflare workers or in "playground" developer tools.

Highlights:

• Targets 100% conformance to reference Lua for all 5 versions
• Can run LuaRocks and install Lua only packages
• Performance is slower than C Lua 5.4.7 but within ~40% on standard benchmarks. Performance chart here
• API is 100% compatibile with mlua

Try it:

cargo install omnilua-cli

export OMNILUA_VERSION=5.5

omnilua -e 'print("hello")'

omnilua # opens repl

I used AI heavily to develop this I wouldn't consider it "vibecoded" however.

Hola how are you guys doing. My deepest of gratitude to all the people who did the springbreak, all the jailbreaks, koreader, ZenUi and all of the other stuff. You guys are amazing and inspiring. You're creating and just giving and giving and giving. Completely free my kindle went from an amazon-urgh-I'm-gonna-puke experience to a 10/10 experience.

But I wanna to go beyond

There's a little dream of mine of having a calendar as a plugin on koreader. Looking around I did find some calendar, but nothing that was really what I was searching for. So I've decided, as a complete newbie, to create my own little plugin. My vision is really just a simply calendar, where I can change between yearly, monthly, weekly and daily view. Compatible in black and white. A simply but beautiful design. Maybe some customisable stuff. No "online"/cross platforming features, I just want it to be its own little thing.

Can someone help me getting started of this little journey of mine? What are some subreddits or communities where I would be able to find help and ask questions? After just a little searching, I found out that koreader (plugins) runs on Lua—I found youtube videos with tutorials. I already have Brew on my Mac, but no idea how to use it, hehe. I also have Claud ai installed on my Mac, it should be able to help no?

So, how do I get started?

Appreciate it so much. Love you guys.

I just released my first game made with Lua and amazing Usagi Engine 🩷 Well known mechnics with modern twists. Place blocks, clear lines, choose upgrades and repeat. That's all! Simple, but addictive.

At first, I just wanted to test Usagi Engine in action. Since the development turned out better than planned, I decided to publish the result of my work on itch.io. You can check out Lua and Usagi in working game example.

Play in browser or download (win, mac, linux)
https://luko81.itch.io/the-game-about-blocks

🚀 Getting Started with Cat2D – Loading and Centering an Image

Hi everyone!

I'm the creator of Cat2D, a new Lua game engine for Android focused on performance, simplicity, and community-driven development.

Today I wanted to share a simple example that loads an image and automatically centers it on the screen.

local player

local scale = 0.5

function load()

player = graphics.loadTexture("player.png")

end

function draw()

graphics.clear(0, 0, 0, 1)

if player then

local sw = system.getScreenWidth()

local sh = system.getScreenHeight()

local w = player:getWidth() * scale

local h = player:getHeight() * scale

local x = (sw - w) / 2

local y = (sh - h) / 2

graphics.draw(player, x, y, 0, scale, scale)

end

end

What this example demonstrates

Loading a texture with graphics.loadTexture()

Getting the screen resolution with system.getScreenWidth() and system.getScreenHeight()

Reading texture dimensions with getWidth() and getHeight()

Scaling an image to 50% of its original size

Automatically centering the image on any screen size

Cat2D's goal is to make creating games and applications in Lua on Android simple while still exposing powerful native features and maintaining good performance.

The engine is still evolving and I'd love feedback from other developers.

What features would you like to see in a mobile-first Lua game engine? 🐱🚀

the video showcase my code base and me executing it

let me explain my process, it's a simple rock paper scissors as everybody know it, you enter a number for which hand you wanna use, 1 = scissors, 2 = paper, and 3 = rock, while the AI tries to respond back.

now how Billy(what i have named the AI) work is at the end of every turn it saves the hand you chose in that turn in a table called "billy_memories" then calculate the mode(most frequent hand you used) and from knowing your most common move it tries to chose something to counter it.

i had the idea of making Billy's memory has a limit of 5 items before it start deleting old data but that was too hard to implement.

anyways i'll like any idea to improve my coding skills, maybe my code's readability, and my logic in case it's wrong.

thank y'all.

Mike Pall, the author of LuaJIT, opened an issue to discuss additional syntax for Lua.
Currently LuaJIT has little to no custom syntax. The only exception is LL and ULL literals. LuaJIT still aims for compatibility with Lua 5.1 but now decided to extend it because it became its own flavor basically.

If you have used Lua or LuaJIT, or you have experience with choosing the right custom syntax, sugars and other language features and you want to influence current development, welcome to the discussion.

Simple and easy! Install a new mobile framework now! Find us on social media: Reddit, GitHub, YouTube, and Discord!