OpenSilver has recently made its presence known and announced that Silverlight, like disco, is in fact not dead and is still more relevant than ever – albiet in a fairly changed form.
As a former Silverlight developer and XAML specialist, let me lay out for you what Silverlight was, how OpenSilver is different, and my initial take on whether this matters (and who it might matter to).
If you’re like many new developers I speak with, you may not be familiar with Silverlight or even XAML, so let me set the stage for you.
Back in 2006 Microsoft released .NET Framework 3.0, including a new desktop technology called Windows Presentation Foundation (WPF). WPF was (and is) an extremely powerful way to build and customize desktop user interfaces. It addressed many of the issues with Windows Forms and aimed to build a user interface technology centered around something called XAML.
XAML stands for eXtensible Application Markup Language and was a way of building a user interface in a tool-agnostic format based on a superset of XML, so designers could work with XAML in one tool and developers could use another.
WPF was a hit and its technologies made for an amazing development experience that still continues today with WPF being supported in .NET Core. Numerous other technologies have adopted XAML for their user interfaces, including Silverlight, Windows Phone, Universal Windows Platform (UWP), Xamarin, Uno, and potentially a few others I’m forgetting at the moment.
Silverlight rose as a way of taking WPF’s rich application capabilities and applying them to applications hosted inside the browser.
Instead, browsers relied on plugins such as Flash and Silverlight to deliver these rich capabilities to end users. This relied on individual browsers to support plugins and to continue to support them.
Unfortunately, plugins constituted security vulnerabilities and slowed down the browsing experience for end users so browsers, starting with Chrome, discontinued plugin support.
With the announcement that browsers would no longer support Plugins, Silverlight became a very expensive investment for organizations that had developed applications in that framework as they now had a fixed point in time when they would no longer run for end users.
This effectively stopped future Silverlight development and set plugin-reliant communities such as Flash and Silverlight into a search for something new.
Author’s Note: I moved from Silverlight to Angular and loved it. React works well from folks coming from a MVC codebase, but Angular was well suited to MVVM architectures.
With the maturity of web standards came the arrival of Web Assembly and a new wild west of development that is still in the early days of playing itself out.
One of the early contenders in the Web Assembly arena has been Microsoft’s Blazor technology which aims to have .NET assemblies running in the user’s browser. This technology has just reached the early stages of maturity and adoption and it’s an exciting space to watch for .NET developers.
Unlike Silverlight, Blazor is built on established web standards and also focuses on using MVC / Razor style syntax instead of XAML.
Yesterday the OpenSilver team announced OpenSilver and a way of running Silverlight inside of modern browsers.
How is this different than Silverlight?
To be clear: this is not Silverlight. This is, in fact, a re-implementation of Silverlight that uses Web Assembly instead of browser plugins to achieve its goals.
This means that OpenSilver plays by established web standards and will work with browsers that support them. Under the covers, OpenSilver appears to do a lot of the same things that Blazor does, with Web Assembly and Mono.
Silverlight is also significantly more mature than OpenSilver for obvious reasons given the recent unveiling of OpenSilver. OpenSilver is notably lacking ahead of time compilation and significant tuning and additional patches, though these should come over time throughout the rest of 2020 and into the future.
How is this different than Blazor?
Less positively, Blazor is backed by Microsoft’s full power and force, OpenSilver is not. This means that it’s not guaranteed to get the same level of tooling support and treatment that other dialects of XAML and other .NET technologies get. That’s not to suggest malicious intent, just that it’s potentially less of a priority.
Okay, so OpenSilver isn’t Silverlight, but lets you do the same types of things with XAML you could with Silverlight. It doesn’t have the same plugin weakness that Silverlight did, and it’s still getting better. But does it matter?
The answer to that is the same as any new technology: it depends.
If you’re a .NET shop with a significant skills or code investment in XAML, it absolutely matters.
If you’re a team that’s more comfortable with MVC / Blazor or existing single page application frameworks, then OpenSilver matters significantly less to you.
With OpenSilver still maturing and with missing pieces like ahead of time compilation you won’t be writing production code with OpenSilver anytime soon. However, this early adopter stage doesn’t mean you shouldn’t watch and consider OpenSilver.
Helpful links for getting started:
The ability to write code in one place that runs in many platforms is the prize we’ve all sought after for decades since the invention of the internet. OpenSilver is the latest contender in this arena and it won’t be the last, but it is absolutely worth watching.