Moonbit: Fast, compact and user friendly language for WebAssembly

[hongbo_zhang]

Hi, I am the lead of this project, you can try it now with our online IDE, https://try.moonbitlang.com (F5 to run)

The docs are available https://github.com/moonbitlang/moonbit-docs, the compiler would be publicly available when we reach the beta status (expected to be the end of Q2 in 2024).

Feel free to ask me any question

[sizediterable]

These are the usual questions I seek answers to first when seeing a new programming language:

  - What does writing asynchronous code look like
  - Will it have any novel or less mainstream features, e.g.
    - Algebraic effects [1]
    - Contexts/Capabilities [2]
    - Linear types [3]
  - Is the type system sound and does it support/need type casts
  - Does the language support interfaces/traits/protocols
  - How rich are generics, e.g.
    - Explicit variance annotations on type parameters
    - Lower or upper bound constraints on type parameters
    - Higher-kinded types
  - Is structural vs nominal subtyping more prevalent
  - Does it have algebraic data types? Generalized algebraic data types?

[1] https://v2.ocaml.org/manual/effects.html

[2] https://docs.hhvm.com/hack/contexts-and-capabilities/introdu...

[3] https://austral-lang.org/linear-types

[tgv]

I think people would like to know about licenses, pricing, and control over the project. Perhaps your commercial strategy doesn't benefit from divulging that information now, but secrecy and uncertainty can kill interest.

[MarcScott]

Your docs at https://moonbitlang.com/docs/syntax/ are unreadable due to the text and background colour

[curist]

Is having a dedicated fn keyword necessary? I mean, what’s the fundamental difference between a func and a fn ?

[kardianos]

* Is there a need to differentiate func and fn? * Part of the function signature is "->" to indicates what it returns. Is this arrow needed? * For new types, you use syntax "struct User". I think Go got it right in this case where types are created with "type User struct", which can also create function types for fn variables like "type AssignUser func(name: String, id: Int) -> Int". * Does it help the lexer/parser to have the ":"? In function signature, do you need the ":" in func(name: String)? Could it be "func(name String)"? Same with type declaration but not assignment "mut elems: List[Int]", could that not be "mut elems List[int]"?

I'm picking nits. Overall I like it.

[thangngoc89]

Oh hey. Wasn't you the lead developer of Bucklescript/Rescript compiler? This gonna be epic.

[brundolf]

"Moonbit makes programming easier with its automatic memory management, setting it apart from Rust."

I'm curious how it handles allocations/deallocations (seemingly) without a GC or a borrow checker?

Edit: I see you mention a GC in another comment (https://news.ycombinator.com/item?id=37186990), but the binary is really small despite that. Does Moonbit just plan to lean on Wasm's proposed built-in GC, once that's ready? And if so, I'm curious how some of the examples in the docs work right now since (I believe) that proposal hasn't been shipped anywhere yet

[abusaidm]

Nice demo, I tried some of the examples and tweaked to see what happens. I noticed no mention of UTF-8 and I tried to add some arabic letters and other RTL letters and it printed garbage chars.

Are langs other than english supported?

[azdavis]

Glad to see new languages designed around having good support for IDEs. matklad (rust analyzer) and I wrote a bit about this:

- https://matklad.github.io/2023/08/01/on-modularity-of-lexica...

- https://azdavis.net/posts/pl-idea-tooling/

I think pure functions, sum/product types, and pattern matching are generally accepted as an excellent way to model and manipulate pure data. I wonder what the team’s thoughts are about handling less pure things like asynchrony and I/O, as well as more interesting control flow like exceptions/panicking, coroutines, generators, iterators, etc.

[jackcviers3]

In the lexical closure doc example, why choose to show variable name shadowing? What is the purpose of `let x = 3` in the below?

let x = 3 func foo(x: Int) { fn inc() { x + 1 } // OK, will return x + 1 fn fail() { y + 1 } // fail: The value identifier y is unbound. }

`foo` also captures the global `x`, but shadows it with the parameter `x`.

Can `Generics` be generic - are there higher kinds? Are they all invariant, or do they have variance and if so what is the notation?

Maybe I missed it - can methods be destructured from structs? Can enums have methods?

Is there partial application for methods and functions?

[10000truths]

The docs don't seem to cover how you're supposed to interact with the host environment from within Moonbit. How do you define imported and exported functions?

[andsoitis]

I loaded the IDE but don't see examples of doing graphics or UI. The docs are also silent on this topic, as far as I can tell.

Is graphics or UI programming possible in MoonBit?

[Lerc]

I couldn't see any reference to default parameters. Are they a thing?

I would quite like the ability to have something like

func makeBox(width: Int = 100, height: Int = width) -> BoxThing

everything else I've seen, I like the look of. One of my litmus tests for languages is to have the ability to make decent Vector types, tuples and operator overloading should perform that function nicely.

[ledgerdev]

Very cool, I really love to see these new wasm native languages, very exciting.

Do you have any plans for a standard library? Build one specific for the language, or will perhaps try use or create/collaborate on a cross language standard library based on wasm component model? Is this even possible or good idea?

May I ask the toolchain you're using to build Moonbit?

[DonHopkins]

Is there anything for binding Moonbit code to JavaScript, like Emscripten's Embind?

https://emscripten.org/docs/porting/connecting_cpp_and_javas...

What do you think of that approach?

Will things change as WebAssembly evolves?

[ice-bergg]

Why not go for global type inference? Should be possible with the relatively simple type system

[Corsome]

Will the compiler be open sourced?

[afavour]

The site compares it to Rust and Go but to me the comparison is AssemblyScript. It’s also WASM-native and new with relatively little ecosystem around it. But compared to Moonbit it’s a familiar language to anyone that’s used TypeScript. So why use Moonbit over AssemblyScript?

[noelwelsh]

Because Moonbit is a modern language, while AssemblyScript is carrying forward the mistakes of the past. For example, Moonbit supports pattern matching and most language constructs are expressions. AS doesn't have pattern matching and consists primarily of statements. Moonbit has algebraic data types; it's not clear to me that AS does.

There might be other differences at runtime, but it's difficult to tell from just the website.

[NoThisIsMe]

Looks much closer to Grain [1] than AssemblyScript

1. https://grain-lang.org/

[csjh]

I think the Rust and Go comparisons are because they’re popular languages with first class WASM support but I agree

[garganzol]

Having `func` keyword for a top function definition, but `fn` keyword for a nested function definition is evil. It should be either `func` or `fn` independently of a particular context.

[brundolf]

It might be because nested functions are closures, which are optionally-named, optionally-typed, and can capture values, unlike top-level declarations. It's not unusual for languages to have a special closure/lambda syntax (whether that's really necessary or good is another question, but there's a lot of precedent)

[tritipsocial]

I think it's an elegant design decision, because it allows the use of a more compact and readable function definition for nested functions. The 'fn' allows you to omit names and types, and so the shorter keyword (fn vs func) indicates the function definition may also be shorter.

[Touche]

Really, "evil"?

[noelwelsh]

I'm excited to see a modern GCed language that is targetting WASM. Closest comparison is probably Grain (https://grain-lang.org/).

[frou_dh]

Apparently the Grain compiler is written in ReasonML rather than plain OCaml. Isn't it a bit comedic how readily these niche things are stacked up?

[tempodox]

Grain does look interesting, thanks for the link!

[homarp]

"The development of an entire language toolchain, previously spanning years or even a decade, has been streamlined through our accrued experience and the establishment of a dedicated talented team from Moonbit's inception. We expect Moonbit to reach beta status by the end of Q2 of 2024, indicating a phase of relative stability, minimal bugs, and a robust Foreign Function Interface (FFI) for interactions with the Wasm host. We will make the source code publicly available once we reach beta quality. Our strategic plans involve Wasm GC integration for Wasm 2.0 and our homebrewed GC for Wasm 1.0, in line with Wasm proposals."

so https://github.com/moonbitlang/ is empty for now

[hongbo_zhang]

The docs are available here: https://github.com/moonbitlang/moonbit-docs

You can also try our online IDE https://try.moonbitlang.com

[homarp]

Sample code at https://try.moonbitlang.com/

[fovc]

I see from comments here that Moonbit has a GC. However, the resulting binary for Fibonacci is 253 bytes, which presumably does not include a GC. Is that using the proposed WASM-native GC, or is the build system smart enough to omit the GC since it’s not needed here?

[andsoitis]

When you right-click on the file and choose Compile to Wat (second last menu item), you can see the WASM text directly.

This is the output of the Fibonacci example:

(module (import "spectest" "print_i32" (func $printi (param $i i32))) (memory $rael.memory (export "memory") 1) (table $rael.global funcref (elem)) (func $fib.fn/2 (param $n/1 i32) (result i32) (local $x/12 i32) (local.get $n/1) (local.set $x/12) (block $join:11 (local.get $x/12) (i32.const 0) (i32.eq) (if (result i32) (then (i32.const 0)) (else (local.get $x/12) (i32.const 1) (i32.eq) (if (result i32) (then (i32.const 1)) (else (br $join:11))))) (return)) (local.get $n/1) (i32.const 1) (i32.sub) (call $fib.fn/2) (local.get $n/1) (i32.const 2) (i32.sub) (call $fib.fn/2) (i32.add)) (func $fib2.fn/1 (param $num/2 i32) (result i32) (local $n/4 i32) (local $acc1/5 i32) (local $acc2/6 i32) (local $x/16 i32) (block $join:3 (local.get $num/2) (i32.const 0) (i32.const 1) (local.set $acc2/6) (local.set $acc1/5) (local.set $n/4) (br $join:3)) (loop $join:3 (result i32) (local.get $n/4) (local.set $x/16) (block $join:15 (block $join:14 (block $join:13 (local.get $x/16) (i32.const 0) (i32.eq) (if (result i32) (then (br $join:13)) (else (local.get $x/16) (i32.const 1) (i32.eq) (if (result i32) (then (br $join:14)) (else (br $join:15))))) (return)) (local.get $acc1/5) (return)) (local.get $acc2/6) (return)) (local.get $n/4) (i32.const 1) (i32.sub) (local.get $acc2/6) (local.get $acc1/5) (local.get $acc2/6) (i32.add) (local.set $acc2/6) (local.set $acc1/5) (local.set $n/4) (br $join:3))) (func $init/3 (i32.const 3) (call $fib.fn/2) (call $printi) (i32.const 46) (call $fib2.fn/1) (call $printi)) (export "_start" (func $init/3)))

[csjh]

Probably smart enough, since code size is part of their mission statement

[conaclos]

This makes me think about Grain [0] - another Wasm-first programming language. This could be nice to add Grain to the comparison.

[0] https://grain-lang.org/

[pmontra]

About Team links to a edu.cn page in Chinese. It seems a university project but I can't confirm. The Join Us page is another Chinese one. The examples on the home page seem to require JavaScript from baidu.com.

[Erlangen]

Demos still work with umatrix plugin on. It requires script from unpkg and msecnd(microsoft domain), but not baidu.

[taklimakan]

That’s not how you’d implement fibonacci in Go

[spion]

I'm not a fan of Go, but I have to admit that benchmark doesn't make any sense. If you use tail calls in a language that doesn't support TCO, then of course you'll get bad results.

I guess its easier to just throw in some numbers than compare idiomatic implementations and then discuss tradeoffs with some nuance.

Even if its just a language teaser, I'd still add a note on TCO to avoid misleading people though.

[makapuf]

Yes, using WASM and Go in an contrived example and not mentioning tinyGo is not very honest.

[tgv]

That's not how you'd implement it in rust either. It's a pretty bad benchmark. From my experience, I'd guess it's lack of tail recursion and the switch statement. That one can be slow in Go.

It is however a good teaser for Moonbit.

[MikeTheRocker]

Is this project associated with Meta? The creator Hongbo Zhang worked at Meta on some of their open source programming language projects (ReasonML and Flow). According to LinkedIn, he's still employed there.

[depr]

Who funds the development? Will there be paid features?

[iFire]

No license.

https://github.com/moonbitlang/moonbit-docs/

[HL33tibCe7]

https://github.com/moonbitlang/moonbit-docs/blob/8be949ff902...

> (* Copyright International Digital Economy Academy, all rights reserved *)

[gmerc]

I’m wondering what the game here is. A language itself dies with lack of adoption, I’m not sure there’s a business model here. Tools maybe but then why not have a license on the language.

[pxeger1]

Interesting how this is written like a corporate press release.

[jacquesm]

What is your long term plan?

Do you intend to support this language indefinitely?

[hongbo_zhang]

Yes, it will be my last project before retirement, we have a very ambitious goal and long term vision.

[lemper]

in an era where there are too many choices for writing things, if you don't show how your language is different and/or better compared to other languages which almost definitely more popular, then you'll lost before you start. I mean, show some example and I'll decide if it's worth to try. for this language? sorry, I'm not sold in the slightest.

[loeg]

Halfway down the page is some (tiny) comparisons to Go and Rust, highlighting some differences and then elaborating (in prose) as to why that's better. We're both reading the same article, right? "A taste of MoonBit."

[phosphorco]

Well. I am very excited by this. We've built our front end in F# with Fable and our backend/engine is in Rust which compiles to WASM.

The WASM story came second, and it'd be really cool to eventually lean into something like this, particularly given the much faster compilation time.

Have followed your work on Rescript, and excited to see that this is where you've taken things.

[thefounder]

I like it a lot tbh b/c it looks a lot like Go.

Unfortunately Go is unusuable as wasm target for browsers due its huge binary. The browser needs a lot of time to download and parse it. Not to mention it starts to crash if your app is large enough(i.e a complete SPA in Go only).

[aatd86]

Yeah, Go has to embed the whole runtime and that amkes for huge payloads.

I'm interested in your experience as I've been working on wasm SPA with Go.

How does it crash? Seems to me that there are examples of stable webapps (for instance using go-app).

Were you using a framework or raw syscall/js call?

Have you tried compiling with tinyGo?

[bbkane]

Looks quite nice, but you should add a banner to the load screen for https://try.moonbitlang.com that it will take quite a while to load and the page is not broken.

[lolinder]

I'd assume that's not normal and is just due to being on the front page of HN.

[neoneye2]

Suggestion. Rename from `func` to `fn` so it's more aligned with Rust.

[tritipsocial]

The `fn` keyword is already used for local functions, which allow a more compact function definition than `func`.

[csjh]

I’ve been considering trying my hand at a C-like WASM language, with most features mapping directly to WASM instructions. Surprised no one’s done something like that yet. Very cool tech

[moron4hire]

What about AssemblyScript? https://www.assemblyscript.org/

[WhiteNoiz3]

There are a few.. Zig compiles to webassembly and looks fairly C-like. You can also use Cheerp or Emscripten to compile C to WebAssembly (though they both assume you are targeting the browser).

Also +1 for Assemblyscript which is fairly C-ish. It's based on Javascript / Typescript but really works more like C if you are doing anything low level (also it doesn't support Closures etc).

[keithalewis]

Looking forward to a "container-free Cloud IDE with offline capabilities, accessible from any location with a browser".

[mmastrac]

The module-level init seems like a great idea. I have been pondering how to get something like this right.

[simon_void]

how do you intend to handle nulls? allow nulls, nullable types or Option/Maybe type?

[DoesntMatter22]

There are now more programming languages coming out than JD frameworks! Hard to keep up

[andsoitis]

Unless you're deeply interesting the programming language space for its own sake, the good news is you don't really have to keep up because they're unlikely to make any dent anytime soon.

Even if you are interested in the programming language space, most are not groundbreaking.

[revskill]

Can i SSR a WASM module ?

[mijoharas]

I tried clicking through to find some syntax and got to this page[0] which seems to show things but the text is illegible on a dark background (something to do with picking up a dark mode setting on my device maybe?)

[0] https://moonbitlang.com/docs/syntax/

[jwl4fun]

Thanks for your feedback, the back background should works now.

[pjmlp]

So why bother with this, when compared against AssemblyScript and Grain, both more mature and existing communities?

[hongbo_zhang]

It depends on how you are measuring maturity.

Moonbit is indeed only developed for less than a year(very fast moving), but it already has a full working IDE, optimizing compiler, fast build system and experimental package manager. We have a dedicated team working on this with professional experience for over a decade, we expect we will reach the maturity on par with Rust in terms of Wasm experience in a couple of years.

[noelwelsh]

I would say Grain is very close to Moonbit. They are both MLs for WASM. AssemblyScript is not. No pattern matching, not expression oriented, no ADTs AFAICT, etc.

[IshKebab]

Grain miserably fails rule 0 of programming language websites - show me the language! They expect you to go through installation, IDE setup, hello world before they tell you anything about it.

The front page doesn't even tell you anything about its unique features. This Moonbit page is a million times better. I might actually try it. I'm not going to try Grain. Why would I?

[TuringTest]

Rust-like features and performance with Go-like usability are big selling points.

Also we don't known how it will be licensed, but if it's proprietary that could also be a selling point with companies that won't touch Grain's LGPL license.

[IshKebab]

Do you really avoid pointers by making everything a pointer?

[TuringTest]

Yes, if the reference is immutable. The main problem with pointers is ad-hoc memory management anyway.

[xmonkee]

Absolutely nothing about memory management?

[ledauphin]

"Moonbit makes programming easier with its automatic memory management" isn't absolutely nothing.

they apparently have their own GC and intend to use the one that comes with WASM 2.0.