How does Rembulan handle Lua coroutines on the JVM?

Rembulan implements coroutines using state machines and exception-based control flow, as detailed in the CoroutinesOverview.md, to work around JVM limitations without native support.

Is Rembulan compatible with Lua 5.4?

No, Rembulan implements Lua 5.3 as per the Lua Reference Manual, so it lacks newer features from Lua 5.4, which might be a deal-breaker for projects requiring the latest Lua version.

How to sandbox untrusted Lua code with Rembulan?

Use the CPU accounting feature via DirectCallExecutor with tick limits, which pauses execution after a set number of operations, as demonstrated in the infinite loop example from the README.

Can I use existing Lua modules with Rembulan?

Only if they are pure Lua or adapted to Rembulan's Java interface; modules relying on the Lua C API won't work out-of-the-box, requiring rewrites or alternative implementations.

Rembulan or LuaJ for Java Lua embedding?

Rembulan is better for sandboxing untrusted code with built-in CPU limits, while LuaJ might offer more maturity and broader Lua compatibility but less focus on security features. Evaluate based on your security needs.

How to compile Lua scripts to Java bytecode with Rembulan?

Use the CompilerChunkLoader from the rembulan-compiler module to load text chunks, as shown in the HelloWorld example, which compiles Lua source directly into Java classes for execution.

Open-Awesome

Rembulan

Apache-2.0Java

A pure Java implementation of Lua 5.3 for the JVM, designed for sandboxed scripting and embedding.

GitHub

170 stars28 forks0 contributors

What is Rembulan?

Rembulan is an implementation of the Lua 5.3 programming language that runs on the Java Virtual Machine. It allows developers to embed Lua as a scripting language within Java applications, with a strong focus on sandboxing untrusted code. The project compiles Lua source directly to Java bytecode and provides a standalone REPL that mimics the standard Lua interpreter.

Target Audience

Java developers who need to embed a secure, sandboxed scripting language into their applications, or those requiring a Lua environment on the JVM for running untrusted scripts.

Value Proposition

Rembulan offers a pure Java, dependency-light implementation of Lua 5.3 with built-in sandboxing capabilities, making it ideal for secure scripting scenarios where running untrusted code is a requirement.

Overview

Rembulan, an implementation of Lua 5.3 for the Java Virtual Machine

Use Cases

Best For

Embedding Lua as a scripting language in Java applications
Running untrusted Lua scripts in a secure, sandboxed JVM environment
Adding scripting capabilities to Java software with CPU and resource limits
Replacing the standard Lua interpreter with a JVM-based drop-in alternative
Developing educational tools or REPLs for Lua on Java platforms
Integrating Lua coroutines and metamodels within JVM-based systems

Not Ideal For

Projects that depend on the Lua C API for integrating existing native Lua libraries
Applications requiring maximum Lua execution speed without JVM startup or bytecode compilation overhead
Teams distributing pre-compiled Lua bytecode for performance or obfuscation purposes
Non-Java environments where Lua needs to be embedded in other programming languages

Pros & Cons

Pros

Lua 5.3 Compliance

Implements the language as specified by the Lua Reference Manual, aiming to mimic PUC-Lua behavior including metamethods and coroutines, ensuring compatibility for scripting needs.

Secure Sandboxing

Designed explicitly for running untrusted Lua programs with features like CPU accounting and operation limits, as shown in the infinite loop example with CallPausedException.

Pure Java Implementation

Built with minimal dependencies, requiring only JRE 7 or higher and avoiding native code, making it portable and easy to integrate into Java ecosystems.

Java Bytecode Compilation

Compiles Lua source directly to Java bytecode using static type inference, rather than interpreting Lua bytecode, which can lead to better performance on the JVM.

Cons

Incomplete Standard Library

The completeness table indicates that not all standard library functions are fully implemented, which may break compatibility with some Lua scripts or libraries.

No Lua C API Support

Requires libraries to be written against its Java interface, limiting portability from existing Lua ecosystems and forcing custom adaptations for native integrations.

Complex Setup and Immaturity

Only SNAPSHOT versions are available with no stable releases, and building requires Maven and JDK 7+, adding friction for production use and long-term stability.

Frequently Asked Questions

Related Projects

Frege

Frege is a Haskell for the JVM. It brings purely functional programing to the Java platform.

Stars3,702

Forks148

Last commit13 days ago

JPHP

JPHP - an implementation of PHP on Java VM

Stars1,712

Forks166

Last commit4 years ago

gojava

GoJava - Java bindings for Go packages

Stars183

Forks16

Last commit8 years ago

Kawa

Extension of the Scheme language, which is in the Lisp family of programming languages

Stars0

Forks0

Last commit

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub