Skip to main content

Introduction: Evo in a Nutshell

If you're completely new, this article can give you quick answers

What problem does Evo solve?​

Lua is an embedded scripting language, and doesn't have many features out of the box. While this minimalism is by design, it means that you almost always need additional libraries to do something that's actually useful. These libraries are frequently outdated, severely underdocumented, difficult to use, or just don't work very well/at all. Evo is an effort to create a standalone platform that gives users access to the most important libraries, so that they can focus on just writing code instead of having to deal with all of the above.

How does it work?​

Evo is a standalone application written in C++, which embeds Mike Pall's LuaJIT engine alongside a host of general-purpose C and C++ libraries. Then it adds more tooling, custom Lua libraries and everything that the runtime doesn't already provide on top. This results in a fast, flexible, and powerful Lua interpreter (with included just-in-time compiler) which can - only in principle, not in terms of maturity or features (!) - be compared to runtimes for other languages, like Node.js (JavaScript), PyPy (Python), Mono (.NET), and the JVM.

The above is only an approximation since all engines work differently and feature unique library ecosystems. But generally, Evo is most closely related to NodeJS because it is based on a similar event loop mechanism. It even uses the same C library, which is called libuv.

What are the key features?​

Here is a short list covering some of the things that you can do with Evo:

  • Network programming (DNS, TCP, UDP, HTTP, and WebSockets)
  • File system access, both buffered and via data streaming
  • Multithreading, launching subshells, timers, and inter-process communication
  • Data compression, decompression, and integrity checks
  • Running fully-powered web applications (in a native browser window), inside of the Lua runtime
  • If all else fails: Easily integrate other C and C++ libraries with your Lua program to add what's missing

There's much more to discover, so feel free to take a look around!

How can it be used?​

In the most simple case, you tell Evo to execute a Lua program (on the command line) and then it goes off and runs it. Realistically, you will quickly need more than just the standard Lua libraries and that's where it gets interesting: If you're looking to implement more advanced program functionality, such as networking via sockets, reading/writing files, data compression or even 3D rendering, you can call into special Lua APIs to use the builtin libraries. All this becomes much simpler to do in Evo and it often runs faster, too. The most important benefit is that you can accomplish a lot of the above even with relatively little experience - entirely from Lua (and not C/C++).

Can it be integrated with other libraries?​

As for compatibility with the standard Lua ecosystem: There's nothing preventing you from using the existing libraries. However, due to the asynchronous nature of Evo's event loop, many of the more complex tasks (such as file system access or networking) function very differently here than they do in popular libraries like LuaFileSystem or LuaSocket. This means that, were you to use these libraries, your program could potentially run much slower than it should. Essentially, the library calls will prevent the runtime from doing its job.

The good news is that you shouldn't really need any of those "problematic" libraries, because Evo can do many things out of the box. Other libraries and tools written for Lua 5.1 should work without hiccups, though newer versions are only partially supported by the LuaJIT runtime. In any event, you can always add more functionality by accessing libraries written in C or C++. Integrating native code would normally be a somewhat painful and error-prone process, but with LuaJIT's foreign function interface it doesn't take much work.

What is the development status?​

Since documentation like this can easily become outdated, you should check for yourself. Follow the activity of the evo-lua container organization on GitHub if you're interested to see where this is going. Even better: You can help propel development forward by giving feedback, making suggestions, or other contributions (including code, testing, and documentation) if you think the effort is worthwhile.

How do I get started?​

The documentation is right here, so all that's left is to install Evo and give it a spin! If your platform doesn't have release binaries, you can take the code and build Evo from source, provided your platform is already supported. If it is not, please open an issue (after checking that none already exists for your platform) and let me know so I can look into what it would take to support it. Please do understand that I can't feasibly support every obscure configuration - or at least not fully - unless users are willing to pitch in and help.

Where can I get support?​

Please open an issue describing your problem in as much detail as possible. If you don't provide enough context, I can't assist you.

How can I contribute?​

All contributions are very welcome! This guide can help you get started. If you need assistance, please use GitHub issues deliberately.

What is the governance model?​

There isn't one. Evo is developed by a single developer (the humble author of these pages), in their free time. See also: BDFL

What are the license and terms of use?​

Evo is licensed under the Mozilla Public License, Version 2 (GPL-compatible). You can read the full license text on GitHub.

This is a free and permissible license that should suit most use cases. If you would prefer a different license model, please get in touch.