Release - Mun v0.3.0

It’s been almost eleven months since the previous major Mun release. A lot has happened; in the world, in the Core Team members’ personal lives, and with Mun. The ambitions that we set for Mun v0.3 were big - and the delays equally so - but we are excited to finally present Mun v0.3.0. This tock-release was focused on usability improvements; multi-file projects, a language server with diagnostics and autocompletion, and improvements to robustness and developer workflow to name a few.

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. Its 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.3 brings an insane amount of updates. When we say insane, we mean insane! In total, this release contains 52 pull requests from 7 of our community contributors and our two Core Team members. For a full list have a look at the changelog, but the main improvements are:

• Type inferencing

  fn integer() -> i32 {
    0 // inferred as i32
  }
  fn large_unsigned_integer() -> u128 {
    0 // inferred as u128
  }
  fn with_let() -> u16 {
    let b = 4;    // inferred as u16
    let a = 4;    // inferred as u16
    a
  }

• Modules & multi-file projects

  // mod.mun
  struct Foo;
  fn main() -> self::Foo {
      Foo
  }
  fn bar() -> Foo {
      super::Foo  // undefined value
  }
  fn baz() -> Foo {
      package::Foo
  }
  // foo.mun
  struct Foo;
  fn bar() -> Foo {
      super::Foo  // mismatched type
  }
  fn baz() -> package::Foo {
      super::Foo
  }
  fn nested() -> self::Foo {
      package::foo::Foo
  }

• Visibility & use keyword

  // /foo.mun
  pub struct Ok;
  
  // /bar.mun
  pub use package::foo::Ok as ReallyOk;
  pub struct Ok;
  
  // /baz.mun
  use package::bar::ReallyOk;

• Autocompletion in editors through LSP

  

• Diagnostics in editors through LSP

  

• Type aliases

  type Foo = u32;
  fn main() {
    let a: Foo = 1;
  }

• Better compile times, hot reload times, and runtime marshalling times

  
• Decreased unsafe code usage and simplified code
• Automatic testing of C/C++ bindings & documentation
• Better developer tools
• Assorted bug fixes

Make It or Break It

A new release also means the end of our first season of Make It or Break It. Our request for contenders, was answered by a lot of reporters filing bugs in the Break It track, but we only had a single contributor in the Make It track. After some discussion, we decided to skip a poll and instead decide on the - to us - unanimous winner: this Spaceship game created by legendiguess using Mun & Rust:

Congratulations, your contribution will forever be remembered on our Make It or Break It hall of fame!

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 tock release (Mun v0.3) focuses on using and improving existing features, whereas a tick release (Mun v0.4) focuses on implementing new features.

When planning Mun v0.3, we bit off more than we could chew, resulting in large delays. To avoid the same pitfalls, we’re limiting the scope Mun v0.4. In particular, we’ll focus on adding support for arrays and optimising our Mun ABI format. For a complete roadmap, please visit our GitHub milestones.

How can I learn more?

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 or Github Sponsors.

Acknowledgments

This release would not have been possible without the incredible contributions from the Mun Community. We are extremely grateful to all of you!