mlua-rs

rlua

Rust2018–2021

mlua-rs / rlua · Archived

rlua

High level Lua bindings to Rust

Libraries & SDKs

Explore on GitHub Read Hacker News discussions

8Distinct people

9Mentions

0Explicit recommenders

1.8KGitHub stars

REPOSITORY AT A GLANCE

What to know before exploring

What it is

High level Lua bindings to Rust

GitHub

Where it is used

No documented product use has been verified yet.

What people are saying

No recommendation phrase was found in the indexed comments.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

No other repository is repeatedly linked in the same discussions.

This week on Hacker News

Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 11:56:56 AM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year9 dated mentions

Observed mentions: 2018-10-30 14:35:32 UTC to 2021-12-23 07:54:39 UTC.

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges

UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
Period	Start (UTC)	End (exclusive, UTC)	Mentions	Comments
2018	2018-01-01 00:00:00 UTC	2019-01-01 00:00:00 UTC	3	3
2019	2019-01-01 00:00:00 UTC	2020-01-01 00:00:00 UTC	0	0
2020	2020-01-01 00:00:00 UTC	2021-01-01 00:00:00 UTC	1	1
2021	2021-01-01 00:00:00 UTC	2022-01-01 00:00:00 UTC	5	5

What Hacker News says

9 sources

linkdd·Dec 23, 2021

Lua is a very nice piece of technology. Its source code is pretty easy to get into, the documentation is complete. It has its quirks yes, but if I need to add scripting to a software, I'd consider Lua before considering writing a DSL, simply because you can pretty much embed Lua's source in your C/C++ software as a static library[0]. The stack-based approach makes it so easy to interact with C/C++, and I've been looking at the Rust bindings[1] recently out of curiosity, looks promising. [0] - https://github.com/lubgr/lua-cmake [1] - https://github.com/amethyst/rlua/blob/master/examples/guided_tour.rs

In Lua: Good, Bad, and Ugly Parts (2012)

cormacrelf·Oct 11, 2021

> I agree [...] actually proving it correct is not something that the compiler does Yes. Unsafe blocks are bare assertions, no more. Everything you described about what happens in Rustc when you use it is better described as making a bare assertion to the compiler. Everything beyond that is socially constructed. Saying it's a proof sounds even more silly when you recall that Rust programmers treat it as quite the opposite -- radioactive markers of places where the program might cause UB. You were trying to characterise it as a proof because you're claiming that "Can Rust prove Linux RCU APIs correct?" is an interesting question. But you are actually asking "Will Rust compile RCU code if we assert to it that using the RCU API is safe?", and the answer is unconditionally yes. It is not an interesting question at all. Your misuse of the word

Read the rest

proof led you there, so I am suggesting you stop calling the unsafe keyword a proof. In the broader scheme of things, yes, the way in which Rust encourages you to isolate unsafety is helpful, and so if you wanted something formally verified Rust is a good language for that. That doesn't really translate to RCU, because the hypothetical Rust API would not be an implementation of RCU. All the Iris proofs that have come out of the RustBelt project are bad examples here, because they were actual implementations of things, not APIs around black box implementations that change under your feet when you set kconfigs. As a final thought, here is a supposedly safe-encapsulated Rust API for RCU, I would invite anyone to suggest how writing down this very simple API or similar + a few calls to extern "C" wrappers for the RCU macros could possibly help "prove Linux RCU APIs correct", whatever that means: https://docs.rs/rcu-clean/0.1.6/rcu_clean/struct.ArcRcu.html (Little edit: if you're interested in what circumstances will lead Rust wrappers of C code to elucidate safety, look into rlua, a project to create a safe wrapper for Lua (https://github.com/amethyst/rlua). Arguably the main outcome is that we now know that the Lua API cannot be wrapped safely with zero cost, in no small part due to the use of longjmp. Some of RCU's APIs require you do not sleep or block in any way while using it, lest you wake up with the GC train having left the station. For this reason I imagine you won't be able to encode all the usage requirements in the Rust type system, let alone make an actual safe zero-cost API, let alone turn that into a proof of anything.)

In So You Want to Rust the Linux Kernel?

m0th87·Sep 22, 2021

I wrote up some rust low-level bindings for guile [1]. The problem is that Guile liberally uses setjmp/longjmp, which breaks rust destructors. It might be possible to fix this by wrapping every call the way rlua does [2], but I'm not familiar enough with Guile to know. 1: https://github.com/ysimonson/guile-sys 2: https://github.com/amethyst/rlua/issues/21

In Ketos: Lisp dialect scripting and extension language for Rust programs

atweiden·Jun 9, 2021

Similarly, Fennel [1] is a Lisp which compiles to Lua, and Lua is well supported in both C++ [2] and Rust [3]. Fennel’s a very reasonable option for delivering S-expression based user interactivity — e.g. REPLs and scriptable config [4]. [1]: https://fennel-lang.org/ [2]: https://github.com/ThePhD/sol2 [3]: https://github.com/amethyst/rlua [4]: https://git.sr.ht/~ioiojo/include-fnl

In Embedding Lisp in C++ – A Recipe

atweiden·May 28, 2021

Janet is what introduced me to Fennel. Conjure [1] sold me on Fennel over Janet. The Neovim community is rallying around Lua. (And in fact, what sold me on Rust was its truly excellent Lua FFI support [2].) [1]: https://github.com/Olical/conjure [2]: https://github.com/amethyst/rlua

In Show HN: I open sourced a game I just released on Steam, written in Lua

steveklabnik·Nov 25, 2020

there’s a number of Lua bindings, but some of the semantics are indeed very tough. The game dev community is maintaining the most famous bindings https://github.com/amethyst/rlua/issues/174

In Why AWS loves Rust, and how we’d like to help

mitchtbaum·Nov 16, 2018

Rust has good bindings for PUC Lua, but this looks like it could have several advantages over Rio's runtime. I did a quick search for any Rust bindings to Go libraries but haven't found any yet. I opened an issue in rlua to discuss bindings to golua, even though that would definitely be a separate project, but we have discussed there before other Lua runtimes. If anyone else is interested in using this library in Rust, here are those issues: https://github.com/kyren/rlua/issues/100 https://github.com/kyren/rlua/issues/39 Edits.. Resources found so far: https://users.rust-lang.org/t/can-rust-interface-with-go-lib... https://medium.com/learning-the-go-programming-language/call... https://github.com/softprops/shiplift (okay, here's a Rust interface to Go)

In Golua – A Lua 5.3 engine implemented in Go

kibwen·Nov 16, 2018

Idiomatic Go code tries to use cgo sparingly, if at all. And the Lua embedding API makes calls into C with a very high frequency. I haven't tried, but I suspect that the combination of these two factors would make embedding a Lua engine written in C (or, say, in Rust with a C ABI) into a Go program disastrous for the performance of Go's green threading runtime. Alternatively, while it would be nice to have a Lua engine entirely in Rust, Rust goes to great lengths to make calling into C have no runtime cost, so you generally just see people writing Rust wrappers over the C API, which tend to impose varying degrees of additional safety on top (Lua internally does a ton of setjmp/longjmp, among other things, so it's not easy). A good example of "wrap and add safety" is Chucklefish's wrapper, being used for their game Witchbrook: https://git

Read the rest

hub.com/kyren/rlua

In Golua – A Lua 5.3 engine implemented in Go

pornel·Oct 30, 2018

Fortunately, you don't have to use C for this any more. Rust has bindings for making extensions for Ruby, Python, Lua and Node, and generally it's very well suited for making zero-cost cleaner APIs on top of C FFI. https://github.com/tildeio/helix https://github.com/PyO3/pyo3 https://github.com/kyren/rlua https://github.com/neon-bindings/neon

In Teaching C (2016)