... in browsers. Which at best JIT compile. There are several WASM runtimes that AOT compile and have significantly better performance (e.g. ~5-10% slower).
Very few languages have "Some Language -> C" or "Some Language -> non-common OS / arch combo". The "just" part is a whole new backend, which is a massive amount of work for common languages.
But it turns out many languages do have "Some Language -> WASM" now.
WebAssembly brings portability to the table.
The main "goal" of w2c2 so far has been allowing to port applications and libraries to as many systems as possible.
For more information, see the README of w2c2.
Just to clarify: Compared to wasm2c, w2c2 does not (yet) have sandboxing capabilities, so assumes the translated WebAssembly module is trustworthy.
The main "goal" of w2c2 so far has been allowing to port applications and libraries to as many systems as possible.
If you are looking for a more flexible solution with support for any layout and support for animations, something like iOS' UICollectionView or Android's RecyclerView, have a look at https://github.com/turbolent/collection-view.
It's object-oriented and especially designed to be extensible. The slides on the pages contain many examples. It's fairly stand-alone and isn't integrated into an IDE. However, it's small, which allows for easy implementation (see original OMeta in Smalltalk, Ometa/JS, Ometa#, etc.) and could be used as a base for implementing these IDE features.
I'd love to see a cleanup of OMeta/JS and combining it with CodeMirror.
At the beginning I tried implementing various object systems. The first one was indeed multiple inheritance with multimethods, based on C3 linearization
(http://en.wikipedia.org/wiki/C3_linearization) and didn't use the prototype chain, but wasn't finished. The second one was similar to Clojure's protocols (define-protocol, extend-protocol, ...), but wasn't very handy.
The current one is single-inheritance, because it uses the prototype chain. It's a compromise between speed and usefulness. I'd prefer having multimethods (and maybe also multiple inheritance), but speed is a bit more important, as JavaScript is already quite slow.
So far I'm quite pleased with the single-inheritance and single dispatch solution, which basically works like that: https://gist.github.com/866506
It compiles a major subset of Apple's Dylan (http://lispm.dyndns.org/documentation/prefix-dylan/book.anno...) to JavaScript, both for use on a CommonJS implementation and in the browser. A bootstrapping compiler is implemented in JS, but the same compiler is also available in Ralph itself and features define-macro (Cl-like). The whole runtime is defined in Ralph as well and provides a single-inheritance object system (including next-method): https://github.com/turbolent/ralph/blob/master/src/runtime/c...
The title is highly misleading.