What exactly is wasmGc collecting?

[Guo-yyds]

The current way of using wasm is still javascript loading using wasm, and wasm memory is also allocated by JavaScript, so using JavaScript Gc directly can't solve the problem?

[rossberg]

I don't quite understand the question, can you elaborate?

In a browser, Wasm GC objects are essentially allocated on the same heap as JS objects. Hence, references to both can be passed back and forth between Wasm and JS for free. (Conceptually, Wasm memory objects are also allocated on this heap, although with somewhat special techniques. But to the engine it's just a byte array, and the Wasm/JS GC does not look at its contents.)

Outside browsers, there generally is no JavaScript, so Wasm GC has its own heap, which again is separate from memories.

[Guo-yyds]

I mean, isn't the memory that wasm manages just linear memory? Then in the linear Memory example, I found that JavaScript creates a memory object and then uses it for wasm, so I think I can directly use JavaScriptGc to manage this piece of linear memory.
That example is as follows:

memory = new WebAssembly.Memory({ initial: 10 });

function consoleLogString(offset, length) {
    const bytes = new Uint8Array(memory.buffer, offset, length);
    // 将Uint8Array转换为字母
    const letters = String.fromCharCode(...bytes);
    console.log(letters); // 输出: "ABCabc"
}
importObject = {
  console: {
    log: consoleLogString
  },
  js: {
    mem: memory
  }
};

const buf = read('D:/daima/wasm/logger2/logger2.wasm', 'binary');
WebAssembly.compile(buf).then(module => {
    // 初始化Wasm模块
    WebAssembly.instantiate(module,importObject).then(resultObject => {
        const exports = resultObject.exports;
        for (i = 0; i < 1; i++) {
            exports.write()
        }          
        // module = null
        // memory = null
        // importObject = null
        // gc();
    })
});

[rossberg]

If a managed language runtime compiles to Wasm using linear memory to allocate its objects, then it needs to implement a full-blown GC itself to manage memory inside this linear memory. JS provides zero help with that, it just sees bytes. This approach also provides no easy way of exchanging object references between JS and the runtime.