After half a year of hard work by the Mun Community and Core Team, we are happy to present Mun v0.2.0. With the addition of hot reloadable structs, this forms a big step forward in terms of hot reloadability for the language.

What's Mun?

Mun is an embeddable programming language empowering creation through iteration. The idea to create Mun originated out of frustration with the Lua dynamic scripting language and a desire to have similar hot reloading functionality available in Rust. As such, it's not a direct competitor with Rust, but instead is intended to be used with Rust (or C/C++) as a host/embedded language pairing. Actually, Mun is completely written in Rust, building on similar crates as rust-analyzer and rustc. It's key features include:

• Ahead of time compilation - Mun is compiled ahead of time (AOT), as opposed to being interpreted or compiled just in time (JIT).
• Statically typed - Mun resolves types at compilation time instead of at runtime, resulting in immediate feedback when writing code and opening the door for powerful refactoring tools.
• First class hot-reloading - Every aspect of Mun is designed with hot reloading in mind. Hot reloading is the process of changing code and resources of a live application, removing the need to start, stop and recompile an application whenever a function or value is changed.

What's new?

Mun v0.2 brings a ton of updates. For a full list have a look at the changelog, but the main new features are:

• Hot reloadable data structures
• Marshalling of data structures to Rust, C, and C++
• Garbage collection for data structures (with opt-out at the struct-level)
• loop, while, break and explicitreturn expressions
• Full operator support for numeric and boolean types
• Incremental compilation
• Benchmark support

What's next?

Mun is still in early development, so there is a lot to do. The Mun Core Team operates according to a tick-tock release cycle. Development of a tick release (Mun v0.2) focuses on implementing new features, whereas a tock release (Mun v0.3) focuses on using and improving existing features.

In particular, we'll focus on making a Rust+Mun game demo that showcases Mun's hot reloading capabilities and we'll be working on a cargo-like application for better Mun project management. For a complete roadmap, please visit our GitHub Project.

As Mun consists of a separate language, runtime, and an ABI that forms the communication protocol between the two; any language can benefit from the Mun Runtime's hot reloading capabilities. This leaves room for other's to integrate the Mun ABI with (a semantic subset) of other languages such as Rust.

How can I learn more?

For more information, please visit our website or read our blog.

To get started, read the Mun Book and have a look at our Rust and C++ examples.

If you are interested in helping develop Mun feel free to reach out to us on Discord or Twitter, or pick up one of our good first issues on GitHub.

If you cannot personally contribute but would still like to support our cause, please consider donating to our Open Collective.

Acknowledgments

This release would not have been possible without the incredible contributions from the Mun Community and the generous support of Mozilla - in the form of the MOSS grant. We are extremely grateful to all of you!