Uno Platform serves as a foundation for constructing multi-platform .NET applications, enabling developers to streamline their workflow by utilizing a single codebase across diverse platforms.

Support for C#Markup has been added in the 5.0 release. According to the project’s maintainers, C# Markup has been desired by developers because it allows them to build a complete application using only this language.

“A massive bit of feedback from the community has been the need to learn multiple languages to build an Uno Platform application,” the Uno Platform Team explained in a blog post.

C# Markup demonstrates its versatility by offering support for a wide array of controls, including standard WinUI, Uno.Toolkit, and Uno.Extensions controls. Alternatively, developers can harness the C# Markup support generator to seamlessly integrate third-party controls. In addition, C# Markup is enriched with an array of powerful features such as data binding, styles, resources, templates, and visual states.

One of its standout advantages is the ability to create application user interfaces declaratively, establishing a clear demarcation between the UI and the underlying business logic.

Moreover, the Uno Platform Team has introduced addition: the Figma to C# Markup plugin, drawing inspiration from the Figma-to-XAML plugin. This innovative tool promises to further streamline the design and development process.

The team also created a course for learning about Hot Reload. The hands-on workshop guides developers through building a simple calculator that takes advantage of this feature. It also created another workshop that teaches how to build an app for streaming YouTube videos that can be deployed across multiple platforms, which also highlights the benefits of MVUX.

Other improvements in Uno Platform 5.0 include MP4 camera capture for iOS, improved composition support for Skia targets, improved DPI scaling and theming support for GTK, and more.

New controls such as Pips Pager and TabBar with vertical orientation, as well as the ItemsRepeater feature, offer even more flexibility to create interactive designs. The Uno platform also introduced new features that provide users with greater flexibility in managing the themes and colors of their applications. These features enable the visual appearance of apps to be customized, resulting in a personalized and visual user experience.

The feature to look out for is the import of the Design System Package (DSP), which allows users to create and save custom color palettes for materials that can be easily imported into the Uno Figma plugin to quickly change the theme of the application. This feature streamlines the process of applying consistent colors across different designs and layouts, and provides greater control and flexibility in applying color to application designs.

Uno Platform has added a custom color feature. This feature removes restrictions on the number of colors used in a design and allows designers and developers to create colors that meet their specific requirements.

Preview 5 also offers two important updates to the image preview and display features. The image placeholder has been enhanced to help designers create more accurate visual representations of their designs, and the need to modify images in a randomly generated preview image from the plugin has been removed. That is, images will now appear in the plugin exactly as they appear in the Figma file.

It consists of two parts: one is for WebAssembly and Skia (Gtk+WPF), the software library for graphics processing, and the other is for mobile purposes such as iOS, Android, Catalyst and macOS.

Adding the .NET 7 binaries allows the use of new JSImport/JSExport APIs to improve the performance of WebAssembly apps beyond the netstandard2.0 that was used previously. For .NET Mobile, .NET 7 allows Uno.UI to use iOS 16 APIs as well as others.

Uno Platform 4.6 also introduces a highly requested ability for NuGet packages and in-solution library projects to include content assets deployed as part of the app. The new feature opens up the path to having fonts included as standalone packages and can automatically be enabled when creating a new Cross-Platform library.

Support for SVG will make it easier to display high-res images on a wide range of display resolutions and densities.

Other enhancements in Uno Platform 4.6 include support for Android 13, the new WebAssembly Bootstrap 7.0, and the ASP.NET Core Hosting Project. According to a Uno blog post, developers using Uno Platform 4.6 can also expect a 20 to 50 percent performance increase in critical paths.

WebAssembly is a low-level, assembly-like language with a compact binary format that runs with near-native performance in web browsers. Hailed as a way to both improve web application performance and allow languages other than JavaScript to be used in the development of browser apps. WebAssembly has led to the development of a range of new technologies, including whole new programming languages, that harness its power. So, here are 10 language projects that have made big bets on WebAssembly.

Blazor WebAssembly

Blazor WebAssembly is a framework for building interactive, client-side, single-page web apps using .NET and hosting those apps in modern browsers (including mobile browsers) on a WebAssembly-based .NET runtime. No plug-ins or recompiling of code into other languages is required. The runtime enables the .NET code to access browser functionality via WebAssembly’s JavaScript APIs.

When a Blazor WebAssembly app is run in the browser, C# code files and Razor files are compiled into .NET assemblies, which are downloaded to the browser along with the .NET runtime. The apps can be deployed standalone or with server-side support.

Cheerp

Leaning Technologies’ Cheerp is positioned as an enterprise-grade C/C++ compiler for the web, compiling C and C++, up to C++ 17, into WebAssembly, JavaScript, or a combination of the two. Cheerp is integrated into LLVM/Clang infrastructure, with custom optimizations intended to improve performance and minimize the size of the compiled output. Primarily used to port existing C/C++ libraries and applications to HTML5, Cheerp also can be used to write web applications and WebAssembly components. Cheerp is offered under open source and commercial licenses.

Binaryen

Binaryen is a compiler toolchain infrastructure library for WebAssembly. Written in C++, Binaryen is intended to make compiling to WebAssembly easy, effective, and fast. It has a C API in a single header, and it can be used from JavaScript. Input is accepted in WebAssembly-like form but a general control graph also is accepted for compilers that prefer it.

The internal IR (intermediate representation) of Binaryen uses compact data structures and draws on all CPU cores for parallel collagen and optimization. The IR also compiles down to WebAssembly easily because it is essentially a subset of WebAssembly. WebAssembly-specific optimizations improve both code size and speed, making Binaryen useful as a compiler back end by itself.

CheerpJ

Billed as “the Java compiler for the web,” this LLVM-based compiler converts any Java client application into WebAssembly, JavaScript, and HTML, enabling Java client applications to run in modern browsers. CheerpJ leverages three components: an AOT compiler, a runtime in WebAssembly and JavaScript, and JavaScript DOM interoperability APIs, to access the DOM from Java. With CheerpJ, JAR archives can be compiled using the AOT compiler. CheerpJ does not require any server-side support.

Emscripten

This open-source compiler toolchain compiles C and C++, or any other language using LLVM compiler technology, into WebAssembly for deployment on the web, Node.js, or a Wasm runtime such as Wasmer. Emscripten has been used to convert a list of real-world codebases into WebAssembly, including commercial codebases such as the Unreal Engine 4 game engine and Unity 3D platform. Emscripten supports the C and C++ standard libraries, C++ exceptions, and OpenGL/WebGL graphics commands. The Emscripten SDK used to install the Emscripten toolchain can be used on Linux, macOS, and Windows.

Forest

Forest is a functional programming language that compiles to WebAssembly. The goal behind Forest is to provide a language that makes it easier to create web apps that are complex, interactive, and functional, but without the traditional overhead of that approach, developer Nick Johnstone said.

Currently described as “pre-alpha, experimental, conceptual research software,” Forest features static typing, pattern matching, immutable data structures, multiple syntaxes, and automatic code formatting. The first syntax in development is inspired by Elm and Haskell.

Design principles of the Forest language include ease of collaboration, painless-as-possible testing, and agreement on structure and semantics while agreeing to disagree on syntax. Johnstone strives to make Forest fast enough for building complex games so that normal web apps will be “blazing fast.”

JWebAssembly

JWebAssembly, from I-Net Software, is a Java bytecode to WebAssembly compiler that takes Java class files as input and generates WebAssembly binary format (.wasm file) or text format (.wat file) as output. The target is to run natively in the browser with WebAssembly. In theory, JWebAssembly can compile any language that compiles to Java bytecode such as Clojure, Groovy, JRuby, Kotlin, and Scala, pending testing.

JWebAssembly is not yet production-ready. Although everything necessary for the JWebAssembly 1.0 release has been implemented, testing still remains to be done. The version 1.0 roadmap calls for capabilities such as a Java bytecode parser, a test framework, and a Gradle plug-in. I-Net Software expects to ship JWebAssembly 1.0 this year.

Uno Platform

An alternative to the Xamarin mobile app platform, Uno Platform is a UI platform for .NET teams to build single-codebase applications for WebAssembly, the web, Windows, macOS, Linux, iOS, and Android, using C# and XAML. Uno leverages the Mono-WASM runtime in .NET 5 to run C# code in all of the major web browsers and serves as a bridge for WinUI and UWP (Universal Windows Platform) apps to run natively on WebAssembly. For building web apps with Uno, developers can use Visual Studio or Visual Studio Code.

Pyodide

The Pyodide project, which recently moved from Mozilla to become an independent project, compiles Python and the Python scientific stack to WebAssembly, bringing the Python 3.8 runtime, NumPy, SciPy, Matplotlib, Scikit-learn, and dozens of other packages to the browser. Pyodide provides transparent conversion of objects between JavaScript and Python and gives Python access to web APIs. Pyodide began in 2018 as part of the Iodide project for doing data science in a browser. Pyodide can be tried from a REPL in the browser.

TeaVM

An ahead-of-time compiler for Java bytecode, TeaVM emits WebAssembly and JavaScript to run in the browser. However, note that WebAssembly support is currently experimental. Like close cousin GWT (Google Web Toolkit), TeaVM allows developers to write applications in Java and deploy them as JavaScript. Unlike GWT, TeaVM works with compiled class files, not source code. In addition, TeaVM relies on existing compilers such as javac, kotlinc, and scalac, so can compile Kotlin and Scala code as well as Java. TeaVM is primarily a web development tool; it’s not designed for taking large codebases in Java or Kotlin and producing JavaScript. A TeaVM subproject, Flavour, serves as a framework for writing single-page web applications.

Grain

The Grain language brings features from academic and functional languages to the 21st century, the project website states. Compiling to WebAssembly via the Binaryen toolchain and compiler infrastructure, Grain can run in the browser, on the server, and potentially anywhere. There are no runtime type errors and no need for type annotations. The Grain toolchain features a CLI, compiler, runtime, and standard library, shipping as a single binary. Developers will need Node.js and Yarn to build Grain from source, and binaries are available for Linux, macOS, and Windows.