Windows 10: Building Windows Terminal with WinUI

Brink · Sep 8, 2020

WinUI and Windows Terminal have a strong relationship that goes back to the origins of Windows Terminal. This blog post goes into the history and architecture of how these two technologies came together.

History

The history of WinUI and Windows Terminal goes back to December 2017. This was around the time the first prototyping of the application that would become Windows Terminal began. We, as the Windows Terminal team, had just started getting conpty into a place that was good enough to be useful as a translation layer between the console and a terminal application. We knew that we wanted to have conpty be able to power a new terminal application, allowing us to build a new user experience for the command line on Windows.

When we were in the earliest planning stages for Terminal, we knew right off the bat that we wanted to be able to build a modern application that used the best features the Windows platform had to offer. We wanted to make sure that it was visually consistent with other inbox applications and followed Fluent Design principles.

We made the choice to build Windows Terminal as a UWP application. That would immediately grant us access to UWP XAML and the whole WinUI 2 library, which has native controls, styles, and capabilities built specifically for Windows apps. At the time, âUWP applicationsâ had special restrictions placed on them by the OS. These security features ensured that UWP apps delivered by the Microsoft Store were unable to access restricted locations within the OS, or leave artifacts laying around on disk, to simplify the uninstall process. These UWP apps are all launched inside a âlow integrity app containerâ, which basically means they have effectively no permissions on the OS. Theyâre not even allowed to change their working directory. Theyâre allowed to launch external processes, but these external processes are additionally bound by the same restrictions the app is bound to.

Therefore, if we wanted to build Terminal as a UWP app in 2018, then any of the shells that we would spawn (like cmd.exe, powershell.exe or bash) would be unable to do anything to the system. Could you imagine using your shell without being able to change directories, read file contents, or launch any other processes that you could interact with? Obviously, this was a non-starter for us.

We spent a good portion of that year discussing our options with a number of teams across the Windows organization. We considered options like a special restricted capability for launching full-trust processes from a UWP. We tried pushing on allowing UWP apps to run outside the app container. However, most of the routes we pursued ended up either as a gaping security hole, or as something that would require years of effort across the organization. (In fact, many of these discussions helped lead to the effort now known as âProject Reunionâ, as well as the WinUI 3 effort that extends the modern UI framework to Desktop apps).

XAML Islands

Fortunately for us, the solution was actually closer than we thought. Just down the hall from us was the WinUI team, and little did we know, they had been building XAML Islands for the better part of the previous year. XAML Islands would enable a traditional Win32-style application to host UWP XAML content within its window without the traditional restrictions of a UWP application. As it turns out, this was exactly what we needed.

What we ended up building was an application that was composed of two parts:

A thin Win32 window that is mostly just responsible for drawing a window to the screen and starting up the XAML Hosting infrastructure

The bulk of the application which is built as a UWP XAML Application that uses WinUI 2. This layer doesnât even know that itâs being hosted by a Win32 window. For all it knows, itâs just a normal C++/WinRT UWP application.

This model allows Terminal to get the best of both worlds. As a Win32 application, weâre able to use all of the legacy Win32 APIs that a terminal app might need to launch processes and query the filesystem. Weâve also been able to use the power of UWP XAML and WinUI 2 to help build the UI of Terminal quickly and beautifully.

Architecture

For a more detailed breakdown of Windows Terminalâs architecture, letâs refer to the following diagram:

In this figure, the top, orange box is our Win32 layer. This layer builds our final executable, and contains all the logic for manipulating our Win32 window, as well as hosting a XAML island for our XAML content.

The lower two blue boxes are both components within the Windows Terminal application. Both of these two components are essentially just UWP XAML components, which could be hosted in a traditional UWP application. They just so happen to be hosted in a Win32 app for Windows Terminal, but thereâs nothing stopping them from being reused in a pure UWP context. In fact, the Terminal repo even builds a pure UWP application that hosts the TerminalApp, to prove that itâs possible to do so.

The TerminalApp project represents all of the logic for the app itself â things like tabs, panes, settings, most of our UI elements; theyâre all a part of the TerminalApp project. As a part of the terminal application, it can host multiple terminal instances simultaneously, either in other tabs, or even side-by-side (in panes). To help us break the solution up logically, the TerminalControl is its own project: the TerminalControl project. Some day, we hope to spin out a nuget package for just the TerminalControl, so that other application developers can also make use of it inside their own applications.

We knew that we wanted to build the absolute fastest terminal possible on Windows. XAML text elements are quick and convenient, but the WinUI team pointed out that we could achieve even faster performance by rendering our text buffer with a custom DirectX text renderer, so we went that route.

We fortunately had already begun work on a DirectX renderer for the vintage console to replace the GDI renderer. It was relatively trivial then to be able to hook up the renderer we had already to XAMLâs SwapChainPanel class. This allowed us to not only render text incredibly quickly on the GPU, but also to reuse a large portion of the console codebase in the new Terminal. This means that improvements to Terminal also improve the inbox console.

Caveats

Thatâs not to say that the journey to building a hybrid application was totally pain-free. Weâve hit a few major roadblocks since we started working on Terminal which we didnât expect going into this process:

It has proven to be fairly difficult to get our UI into the title bar area. While Terminal now does iconically have its tab strip in the title bar, that was actually a decent amount of heavy lifting in the Win32 part of the application. Fortunately, we had the help of community member @greg904. Without him, the Terminal title bar would not be nearly as polished as it is today.

Packaging a hybrid application has had its own difficulties. The application packaging project has proven finnicky to get our dependencies placed into exactly the right folders within our project, meaning weâve had to write a lot of msbuild targets manually. This is likely because the wapproj project type wasnât really designed for these.

By constructing our own TerminalControl, instead of using existing XAML elements, we did need to build out UIA and accessibility support for the control ourselves. This ended up being a not entirely trivial process and definitely cost us more dev hours than we expected. However, it was absolutely imperative to ensure that all developers would be able to use Terminal effectively.

TabView

One of the key features that Terminal needed was tabs â users expect to have multiple terminals open with tasks running in parallel. Not only that, the tab control needed to look and feel good, just like the tab experience within a browser. When we first started looking at building a tab experience, there was no tab control within WinUI 2, though there was an initial implementation in the Windows Community Toolkit. While this initial C# implementation helped set the API direction for the control, we needed a high-performance, high-polish control that could only be found in WinUI. We worked closely with the WinUI team (who in turn worked closely with various teams within Microsoft such as the WCT folks and Edge team) to define the look and feel of the TabView control built into WinUI 2.

From our point of view, this partnership has been worthwhile because a lot of the functional requirements for TabView such as reordering and closing tabs are built by the WinUI team â and from the WinUI teamâs point of view, this partnership has been worthwhile because Terminal has helped shape the requirements and design of a general purpose TabView that can be used within other apps. Plus, the WinUI TabView is flexible â for example, Terminal includes a custom dropdown tab button that isnât found in the âstockâ TabView but is well supported within the control.

Design process

We worked with the WinUI team as well as many designers to define what TabView would look like. We went from having basic sketches to high fidelity mockups that in turn were developed as a working control. Below is a mockup we created while we were still defining what we wanted Terminal to look like.

After working with multiple designers and iterating over many mockups, TabView became what it is today and it is a staple feature inside Windows Terminal.

Looking ahead

As Windows Terminal gains more features, we are able to continually work with WinUI to add more controls as these become available. The next big item on the list is the settings UI, which will use many WinUI 2 controls that are available today. This partnership has been fantastic and we canât wait to continue to improve both Windows Terminal and WinUI with the creation of new features and controls.
Click to expand...

Source: https://blogs.windows.com/windowsdev...al-with-winui/

Tweet

— Twitter API (@user) View on Twitter
Click to expand...

:)

Brink · Sep 8, 2020

Announcing WinUI 3 Preview 2 for Windows 10

At our monthly community call this morning we announced that a new preview of WinUI 3 is ready for you all to try out – WinUI 3 Preview 2! If you’re too excited to read ahead, check out the release notes here.

WinUI 3 Preview 2 was a quality and stability-driven release. It builds directly on Preview 1 by fixing quite a few critical and serious bugs that didn’t make the cut in time for our release at Build 2020 two months ago. The team wanted to put together a small release post-Build to make sure that WinUI 3 is stable and easy to use for everyone. Our community dove right into using Preview 1 and you all provided us with tons of valuable feedback, specifically regarding the critical bugs that you found. This feedback, in addition to the team’s known issues from Preview 1, drove us towards creating the long list of bugs that we set out to fix for this release.

Some notable additions and fixes in this release include:

INotifyCollectionChangedand INotifyPropertyChanged are now working in C# Desktop apps

WinUI 3 Preview 2 is now compatible with .NET 5 Preview 5 for Desktop apps

Point, Rect, and Size members are now Double-typed in the C# projection of the APIs for Desktop apps

Crash fixes for Input Validation and other text scenarios

You can see the exhaustive list of bugs fixed in our release notes.

Preview 2 is logistically set up the same way as Preview 1. You’ll have to download a new .VSIX file, make sure you’ve upgraded to .NET 5 Preview 5, and install a new NuGet package. Step-by-step instructions can be found here for Desktop apps and here for UWP apps. You can also test out WinUI 3 Preview 2 without writing any code – just clone and build the Preview 2 branch of the XAML Controls Gallery and navigate through the app to see how the controls are all working with the new fixes put in place.

Preview 2 is not yet ready for use in production apps and we will be continuing to listen to customer feedback and trying to improve your experience throughout subsequent releases. We have a list of our known limitations here and you can also file issues on our GitHub repository for anything new that you run into.

Up next for the team is getting Preview 3 ready for this fall! Preview 3 is going to be a fun and exciting release – it’ll be packed with new features and capabilities! We hope you enjoy experimenting with Preview 2 and are as excited for WinUI to continue evolving as we are.

Ana Wishnoff
Program Manager for WinUI
Click to expand...

Source: Announcing WinUI 3 Preview 2 - Windows Developer Blog

Tweet

— Twitter API (@user) View on Twitter
Click to expand...

Brink · Sep 8, 2020

Microsoft introduces WinUI 3 Preview 1

Today at Microsoft Build 2020 the WinUI team is excited to announce the latest version of WinUI 3 available for public preview: WinUI 3 Preview 1. This preview expands the world of WinUI to an even wider audience of developers – the previously-released WinUI 3 Alpha was only available to UWP app developers, but Preview 1 now enables WinUI usage in Desktop (Win32) apps as well!

What is WinUI?

WinUI is Microsoft’s most advanced user interface technology for building Windows apps. There are two versions of WinUI in active development: WinUI 2 and WinUI 3. WinUI 2 is a library of Fluent-based UI controls & styles for UWP XAML apps; it was first shipped in Oct 2018 and its latest release is v2.4 which came out recently on May 8th.

WinUI 3 is a currently-in-development, dramatic expansion of this library into a full-fledged, end-to-end, standalone UI framework. This UI framework continues the tradition of WinUI and UWP XAML, providing the very latest graphical capabilities and Fluent Design styling that embraces today’s modern devices, hardware, and inputs. Technically, WinUI 3 decouples the XAML, Composition, and Input layers of Windows 10, and ships them independently via NuGet for any app targeting Windows 10 1803 and above. It can be used in both C++ and .NET-based apps.

WinUI 3 Preview 1 is the first pre-release of WinUI 3 that can be used in both UWP and Desktop apps, allowing every developer a chance to tap into the very latest UI technologies from Microsoft for building Windows apps. You can learn more about WinUI here.

What’s new in WinUI 3 Preview 1?

In addition to the aforementioned ability to use WinUI from Desktop apps, Preview 1 will also support .NET 5 when run in this Desktop context. Preview 1 is also the first preview of WinUI 3 to include the SwapChainPanel control – this is key for developers working with DirectX for providing custom graphical rendering as a part of their user experience.

In February, the WinUI team released an Alpha of WinUI 3 with an all-new Chromium-based WebView2 control. This same control carries through to Preview 1 and has been updated with several improvements. Preview 1 also offers several other advancements compared to the February Alpha:

Support for the .NET versions of several interfaces when using .NET 5. In Preview1, .NET 5 is used with Desktop apps. The interfaces (and a class) are: INotifyPropertyChanged, INotifyCollectionChanged, ObervableCollection<T>, and ICommand.

New, recently released controls ported forward from WinUI v2.4.

Several important bug fixes & stability improvements.

A full articulation of the capabilities and limitations of Preview 1 can be found in the WinUI 3 Preview 1 Release Notes. Of special note: Preview 1 should not be used in production apps, as it does not guarantee forward compatibility and may break in future updates we make to Windows 10.

Who’s using WinUI?

At Build 2020 we’ll share stories of customers and ecosystem partners we’re working with to improve & develop WinUI 3. Examples of these partnerships that will be referenced during the conference include:

Magix, a developer of audio & video solutions for creators, who’s showcasing how they’ve harnessed the power of WinUI to modernize some of the UI components in their Win32-based VEGAS Pro app

Esri, market leader in geographic information system (GIS) software, using ArcGIS Runtime, .NET and SwapChainPanel with WinUI 3 Preview 1 to render gigabytes of geospatial data in rich, high performance mapping components

Telerik, a leading vendor of high quality .NET and JavaScript components for building modern, high performance, feature rich web, mobile and desktop apps

Uno platform, an open source platform for building apps that span across mobile endpoints, Windows, macOS, and the Web

These are just some of the great companies exploring and engaging with us as we develop WinUI 3, and in the coming months you’ll learn more about these and other engagements as we prepare for the eventual release of WinUI 3.0 for general availability.

How can I get started?

To start with WinUI 3.0 Preview 1, head over to our download and release notes page. You can also find more information and technical setup details in our documentation on creating a Desktop app with WinUI.
Click to expand...

Source: https://blogs.windows.com/windowsdev...i-3-preview-1/

Tweet

— Twitter API (@user) View on Twitter
Click to expand...

Brink · Sep 8, 2020

Announcing Open Source of WPF, Windows Forms, and WinUI

At Build 2018, I outlined our approach to helping you be more productive when developing apps, including the introduction of .NET Core 3.0. We also started decoupling many parts of the Windows development platform, so you can adopt technologies incrementally. Today at Microsoft Connect(); 2018 Conference we shared the next steps – specifically to support innovations in UI:

.NET Core 3.0 Preview 1 adds support for building client apps using Windows Presentation Foundation (WPF), Windows Forms, and XAML Islands.

WPF, Windows Forms, and Windows UI XAML Library (WinUI) are now open source, so you can create experiences with the freedom you want.

.NET Core 3.0 Preview 1 available

As Scott Guthrie announced today, the first preview of .NET Core 3.0 is available. This version of .NET adds support for building Windows desktop apps using WPF and Windows Forms. You will now be able to:

Run multiple instances of .NET Core 3.0 side-by-side on the same computer so you can update WPF and Windows Forms apps to a new version of .NET without updating the entire OS.

Use modern controls and Fluent styling from the WinUI XAML Library via XAML Islands from .NET Core 3.0 apps.

Read about .NET Core 3.0 Preview 1, try out the preview, and give us feedback. The next version of the .NET Framework, .NET Framework 4.8, will include new controls that use the latest browser and media players in Windows 10, support the latest standards, and WPF and Windows Forms apps will have access to WinUI via XAML Islands for modern look and touch support. The .NET Team blog details the differences and compatibility between .NET Core and .NET Framework moving forward.

WPF, Windows Forms, and WinUI ready for your contributions

This journey is our continued commitment to creating the development platform with you, through open source. Our three, popular Windows UX frameworks are ready for your contributions on GitHub: WPF, Windows Forms, and WinUI. Open sourcing these technologies provides transparency between the product team and the community, helps democratize Windows development, and enables the community to engage and contribute to these repos.

We look forward to your contributions. You can get started with Windows Forms and WinUI now. WPF is starting with System.Xaml, with more to come over the following months.
Click to expand...

Source: Announcing Open Source of WPF, Windows Forms, and WinUI at Microsoft Connect(); 2018 - Windows Developer Blog

See also: .NET Core 3 Preview 1 and Open Source Windows Desktop Frameworks - Windows 10 Forums

Tweet

— Twitter API (@user) View on Twiiter

Windows 10: Building Windows Terminal with WinUI

Building Windows Terminal with WinUI

Building Windows Terminal with WinUI

Building Windows Terminal with WinUI

Building Windows Terminal with WinUI - Similar Threads - Building Terminal WinUI

windows terminal

windows terminal

windows terminal

windows terminal

Feature Support - #WPF #WinUI

Announcing WinUI 3 Preview 3

Announcing WinUI 3 Preview 2 for Windows 10

Windows Terminal Build 2019 FAQ

Announcing Open Source of WPF, Windows Forms, and WinUI