WASM, Android, and iOS targeting is subpar, though. For multi-platform client-side targeting, Kotlin is actually more interesting.
.NET was always built for showmanship, with somewhat disappointing results when actually tried.
.NET was always built for showmanship, with somewhat disappointing results when actually tried.
What do you mean by that? I know what the term means but considering it's one of the most used programming stacks I don't understand what you mean when you use it.
Similarly I think C# excels at game development because of the many engines it is used. Maybe it began because of XNA but then got popularised because of Unity but I do not think it is due to any special features in C# itself that are not found in other languages. I am not sure about this so please correct me if I am wrong.
I don't think these were the reason behind C#'s rise in gamedev historically, but they do ensure it continues to be its mainstay.
*today you can also add powerful SIMD and BLAS-adjacent abstractions to this list, a good showcase of which would be Bepuphysics2 which is a heavily vectorized physics engine written in pure C# that is as fast as PhysX and faster than Jolt (another SIMD-using physics library written in C++)
https://developer.chrome.com/blog/wasmgc/
Kotlin's support is in Alpha right now, but works well, and it's one of the first language implementations that can target WasmGC:
https://blog.jetbrains.com/kotlin/2023/12/kotlin-for-webasse...
By comparison, .NET's Blazor targets LLVM, and they either AOT or JIT, however the client has to download a heavier runtime that has at least a garbage collector (nevermind the JIT), and is less than ideal. Basically, the original Wasm was designed for languages with linear memory and still makes a great target for C++ or Rust, but not for managed languages like Kotlin/Java. dotNET's WASM is there only to support Blazor, which is a web framework, a sort of successor to Web Forms and whose future is uncertain. Speaking of which, you're better off with MVC + HTMX, but I digress. So for more interesting use cases, Kotlin is actually ahead in their Wasm support.
For multi-platform support, the company behind it has a vested interest in targeting multiple platforms, and Kotlin Multi-platform support also has Google backing. So, for one, you can share business logic on iOS, as you can integrate Kotlin libraries into Swift applications:
https://kotlinlang.org/docs/multiplatform.html
And they have been porting Jetpack Compose to the desktop and to iOS (and can be used with Wasm in the browser, too):
https://github.com/JetBrains/compose-multiplatform
Also, see this year's keynote at KotlinConf:
https://www.youtube.com/watch?v=c4f4SCEYA5Q&t=2903s
Over on dotNET side, the blessed solution by Microsoft, for targeting iOS, Android, or the desktop, is right now .NET MAUI. So, where's Xamarin? Where's Silverlight for that matter? That's right, Microsoft changes multi-platform solutions like they change socks, and I don't understand how anyone could trust them for a multi-platform solution.
The API of WasmGC is really rudimentary.
With that said, you can track support of various WASM features by .NET here: https://github.com/dotnet/runtime/issues/94351
I don’t understand how the logic of your post works however, WASM in .NET is already used in production versus something that is an early alpha? Also, on Kotlin and targeting something that is not Android - “Java Interop” that’s all I need to say.
And even in spite of that, they had to backtrack on leaving Java behind, as Android was slowly not able to consume modern Java libraries.
Kotlin on the browser lags behind Blazor, and Kotlin/Native was so badly implemented they had to redo the whole memory management concept, originally incompatible with JVM semantics.
I’m unaware of that backtracking you’re mentioning, could you give some context?
How do you measure it lagging behind in the browser? According to Krause’s benchmarks Blazor’s WASM performance is steadily in the bottom 5% of tested frameworks, and devs generally tend to express that Blazor is suitable only for internal enterprise apps where the end users are lenient enough to accept such performance.
The limited GC in the initial Native implementation was reworked long time ago.[1]
[1]: https://kotlinlang.org/docs/whatsnew17.html#kotlin-native
Uno has been very unstable, not production ready in my books.
As for Kotlin, it’s just a language running on a JVM or any other supported target. The interop with Java is stellar. You can use Swing or JavaFX, which now goes by OpenFX, for the desktop. Vaadin and Hilla target V8. There’s also Kotlin/js. There’s really a lot. Compose is much like SwiftUI, composable, similar to React in a way.
far from the only way! (as you explain).
How so?