On Thursday, 1 December 2022 at 05:49:56 UTC, cc wrote:

Nevermind, I see now it's just a straight up termination with no message. Ouch.

On Thursday, 1 December 2022 at 11:51:23 UTC, Guillaume Piolat wrote:

From a language PoV, WASM support is 100% complete

From a runtime/std PoV it's not.. but if you are making a game it doesn't matter AT ALL!

In fact, i am even working on a game that supports WASM target using WebGL: https://www.kdom.xyz/ (it is an online multiplayer game)

I haven't updated the build on the website for a while since i'm focusing on the art/backend side of things, but i'll soon make a proper blog post about it once it's in a pleasant and playable state

My only issue so far was when certain features didn't work, and the compiler wouldn't help me with error messages, for example: working with slices

I had to copy bits of druntime's object.d, i wish i didn't have to do that

But i learned to like it and now i have a custom object.d and i can use: i32 u32 i64 u64(etc) aliases globally! That's pretty cool

Oh.. and allocating memory with WASM, this is why i wished there was a proper Allocator API available that is minimal (meaning it doesn't import anything from either druntime/phobos), so it's available right away to kickstart projects that targets esoteric platforms such as WASM

So i made one! it's basically a port of Zig's one, i yoinked it since i didn't like the ergonomics of the language for their API is cool, so i went a head and ported it, i might release a dub package in the future

We have to be careful with WASM, we should not offer a bloated solution

Writing your javascript glue code is more than enough to access browser APIs, basic WASI support is all we really need if you want to make a game

So a general purpose solution might not be the most useful one

Look at Blazor from .net and how they struggle to produce small enough wasm files

My wasm file is just 700kb (and it includes builtin textures/shaders), competitive advantage for D

My glue code for WebSocket is just this: https://www.kdom.xyz/lib/net.js

// websocket
alias ws_cb_t = extern(C) void delegate (int ws, int event, int data);
int js_ws_create(const(char)[] url, void* bufferPtr, scope ws_cb_t cb);
bool js_ws_send_data(int ws, const(void)* ptr, int len);
bool js_ws_send_str(int ws, const(char)* ptr, int len);
void js_ws_disconnect(int ws);


extern(C) export void js_cb_ws(uint ctx, uint fun, int ws, int event, int data) {
  static struct Handler {
    union {
      extern(C) void delegate(int, int, int) handle;
      struct {
        void* contextPtr;
        void* funcPtr;
      }
    }
  }
  Handler c;
  c.contextPtr = cast(void*) ctx;
  c.funcPtr = cast(void*) fun;
  c.handle(ws, event, data);
}

and i use it:

state.ws_id = js_ws_create(host.strip, cast(void*) state.ws_buffer.ptr, (ws, evt, data) {
            if (evt == 1) // onopen
            {
                state.net_info.state = ConnectState.CONNECTED;
                on_connected();
            }
            else if (evt == 2) // data str
            { }
            else if (evt == 3) // data binary
            {
                decode_packet(state.ws_buffer[0 .. data]);
            }
            else if (evt == 4) // close
            {
                state.net_info.state = ConnectState.DISCONNECTED;
                state.ws_id = 0;
                on_disconnected();
            }
            else if (evt == 5) // error
            {
                LERRO("ws: error {} {} {}", ws, evt, data);
            }
            else
                panic("shouldn't happen {} {} {}", ws, evt, data);
});

Full delegate support out of the box!

I need to become more responsible and provide blog posts, resources and more examples on github to help people.. i got this one example but no documentation and is a bit too old: https://github.com/ryuukk/dasm

Hopefully this game i am making will be a good showcase for D

On Thursday, 1 December 2022 at 12:48:04 UTC, ryuukk_ wrote:

Forgot to add, good ressources for WASM without emscripten, that's what i followed basically:

https://schellcode.github.io/webassembly-without-emscripten

Also an example of a language that follows this principle: Odin:

https://github.com/odin-lang/Odin/tree/master/vendor/wasm

This is imo the proper way to do it

And you can still use emscripten btw: https://theartofmachinery.com/2018/12/20/emscripten_d.html

So druntime/phobos might be working out of the box, but will produce rather large wasm files

I'll give that a try some day

On Thursday, 1 December 2022 at 12:55:17 UTC, ryuukk_ wrote:

Actually it dont: Instead of porting the D runtime, it uses a lightweight, runtimeless -betterC build.

Doing a simple game without GC is possible, but when you wish to use GC and standard library this is the problem.

If one wishes to offer a not bloated solution, one can use betterC, having the option for me is the best thing to do. I have done my own standard library to use in D, which avoids many templates, many imports depending from the libc, still, it is quite far from having real support on WASM.

Though I think the main problem it has is using associative arrays, I have my own implementation of ref counted associative arrays, but I'm not using. I should consider a bit about this.