# OpenSilver reimplements WPF on the DOM instead of on a canvas

> OpenSilver is a C#, VB.NET or F# framework with XAML that compiles to six platforms, and the technical decision that defines it is that XAML renders to real HTML elements rather than to a canvas. That gives browser text selection, Ctrl+F and screen readers for free, and it is why the project describes itself as a reimplementation rather than an emulator.

**OpenSilver/OpenSilver** — Build Cross-Platform Apps with C#, VB.NET, or F# and XAML. One codebase. Six platforms. Powered by WebAssembly and .NET.

- Repository: https://github.com/OpenSilver/OpenSilver
- Website: https://opensilver.net
- Stars: 1,283 · Forks: 135
- Language: C#
- License: NOASSERTION
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/opensilver-opensilver

## Six targets from one XAML codebase

The positioning is a single sentence: build cross-platform applications with C#, VB.NET or F# and XAML, one codebase, six platforms, powered by WebAssembly and .NET. The targets are listed explicitly. Web comes via WebAssembly. Android, iOS, Windows and macOS come via the .NET MAUI-OpenSilver Hybrid mode. Linux comes via Photino. The description frames the project as like WPF, but cross-platform and evolved, and the point of the analogy is the programming model rather than the appearance: MVVM, data binding, commands, styles and templates are the same patterns, and OpenSilver implements a large and growing subset of the WPF API with the same namespaces and the same XAML. If you know WPF, the documentation says, you already know OpenSilver. The multi-language claim is the unusual part, since VB.NET plus XAML and F# plus XAML on the web are close to unique.

## The DOM is the renderer, and that is the whole idea

The most important technical fact in the project is that OpenSilver is not an emulator, not a wrapper and not an Electron-style bundled browser, but a complete reimplementation of the WPF and Silverlight API from scratch using modern .NET, WebAssembly and the browser's DOM. On the web, your C# compiles to WebAssembly, and XAML is rendered at runtime using real HTML elements. A `TextBox` becomes a `textarea`, a `MediaElement` becomes a `video`, a `PasswordBox` becomes a password input, an `Image` becomes an `img`. The consequences are the argument for the design: Ctrl+F search, text selection so users can copy, screen readers, SEO indexing, browser translation, mobile long-press, automated UI testing and accessibility compliance all come from using the platform's own elements rather than redrawing them. A canvas based approach has to reimplement all of that, and usually does not.

## The output is static files you can host anywhere

A consequence of the DOM approach is that the compiled application is a set of static files, the WebAssembly, the JavaScript and an index.html, and it can be hosted anywhere: Azure, AWS, GitHub Pages, or any basic web server, with no special server technology required. For teams moving an internal tool from a desktop app to a browser that is a meaningful change in what the operations team has to run. On desktop and mobile, through the MAUI-OpenSilver Hybrid mode or Photino, the UI is still HTML and CSS but the C# runs as native .NET rather than as WebAssembly. The documentation explains why that matters in both directions: it keeps full compatibility with JavaScript libraries and Blazor components because the interface is still HTML, and it adds native performance and direct access to platform APIs because the runtime is native .NET.

## Blazor components and JavaScript libraries live inside XAML

Two integration points extend the XAML model well beyond what WPF offered. Blazor integration lets you mix XAML and Razor files in the same project and embed Blazor components, with DevExpress, Syncfusion, Radzen, Blazorise and MudBlazor named in the documentation, directly inside XAML. That is a significant change for anyone coming from WPF, because it means the component library you already use may be usable in the new framework. JavaScript interop goes the other way, letting you call any JavaScript library from C#, with full access to the JS ecosystem from all target platforms, and the project keeps separate interop and JavaScript library sample collections for it. The .NET ecosystem point follows from the same place: OpenSilver and Blazor WASM share the same .NET for WebAssembly stack, so any non-UI NuGet package that works in Blazor works in OpenSilver, which is a much larger statement about package compatibility than the UI story alone.

## You can try it before installing anything

Two browser-hosted options let you evaluate the framework with no local setup. XAML.io lets you write and run C# and XAML directly in the browser, which the documentation presents as useful for quick experiments, for learning and for sharing code snippets. The sample site carries over 200 interactive C# and XAML samples running live, with a toggle to switch the source between C#, VB.NET and F#, and it includes examples of Blazor component integration, and there is a source repository for it. The same samples also exist as a mobile app on Android and iOS, which is a neat demonstration that they run on the hybrid path. The gallery page on the project site shows real world applications, and the documentation site is separate from the marketing site.

## A visual designer that runs in three editors and online

The designer story is a competitive differentiator rather than a technical one, and it is worth weighing separately from the rendering model. OpenSilver ships a drag-and-drop XAML designer for Visual Studio, for VS Code on Windows, macOS and Linux, and online at XAML.io, and the documentation claims it is the first XAML designer for VS Code.

## Where the framework stands

The repository is developed on the `develop` branch, with the source under `src/`, a `build/` directory and a `scripts/` directory, and a `BUILDING.md` that covers building from source alongside the `CONTRIBUTING.md`. The licence is stated in a `LICENSE.txt` at the root, and there is a `THIRD-PARTY-NOTICES.txt` file, which is expected for a framework that pulls in third party components. The NuGet package is `OpenSilver`, and there are helper scripts in the root for restoring packages and for clearing the bin and obj directories. The last push to the develop branch was on 2026-10-14, and the project has no GitHub releases, so the published versions live on NuGet. The documentation table of contents also carries a migrating from WPF, Silverlight or LightSwitch section and a performance tips section, and those two are the sections to read first, because both questions are what anyone arriving from WPF actually has.

## Conclusion

Adopt OpenSilver if you have WPF or Silverlight code you want to run in a browser without rewriting the interface in HTML, since the XAML and the C# carry over and the DOM rendering gives you accessibility and text selection for free. Do not adopt it for a greenfield web app, because the whole value proposition is compatibility with an existing WPF-shaped codebase. Verify first how much of the WPF API you actually use, since the documentation is explicit that it implements a large and growing subset rather than all of it, and read the performance tips in the documentation before you commit to a data-heavy interface.

## FAQ

### What is OpenSilver?

It is a modern, open-source framework for building cross-platform applications using C#, VB.NET or F# combined with XAML. You write the code once and deploy to the web via WebAssembly, to Android, iOS, Windows and macOS via MAUI-OpenSilver Hybrid, and to Linux via Photino.

### Is OpenSilver an emulator or a wrapper around a browser?

No. The documentation is explicit that it is not an emulator, a wrapper, or an Electron-style bundled browser, but a complete reimplementation of the WPF and Silverlight API from scratch using modern .NET, WebAssembly and the browser's DOM.

### How does OpenSilver render XAML on the web?

At runtime, using real HTML elements. A TextBox becomes a textarea, a MediaElement becomes a video, a PasswordBox becomes a password input and an Image becomes an img, which is what gives you Ctrl+F, text selection, screen readers and SEO indexing.

### Can I use my existing WPF knowledge with OpenSilver?

Yes, within limits. OpenSilver implements a large and growing subset of the WPF API with the same namespaces, the same XAML and the same patterns including MVVM, data binding, commands, styles and templates. The documentation recommends checking the performance tips before committing to a data-heavy interface.

### How do I try OpenSilver without installing anything?

XAML.io lets you write and run C# and XAML in the browser with no installation, and the sample site runs over 200 live samples with a source toggle between C#, VB.NET and F#. The documentation is at doc.opensilver.net and the project site is at opensilver.net.

## Sources

- [Issues](https://github.com/OpenSilver/OpenSilver/issues)
- [OpenSilver/OpenSilver on GitHub](https://github.com/OpenSilver/OpenSilver)
- [Project website](https://opensilver.net)
- [README](https://github.com/OpenSilver/OpenSilver/blob/develop/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/opensilver-opensilver