Use Avalonia as the baseline

[nilslahr]

Avalonia is already the most cross platform and 'true' XAML available. Let's consider using this as the starting XAML vocabulary, but perhaps even the first reference code and system to test it with. Additionally perhaps use Avalonia as the unified XAML at Microsoft rather than rebuilding it (again).

The main GitHub location: https://github.com/AvaloniaUI/Avalonia

Some new information about the latest release: https://translate.google.com/translate?sl=auto&tl=en&js=y&prev=_t&hl=en&ie=UTF-8&u=https%3A%2F%2Fhabrahabr.ru%2Fpost%2F328684%2F&edit-text=

[NikolaySt]

Technically. The Avalonia team is much more innovative and understand MSFT technology better than the UWP team, clearly.

[dimsont]

Looking forward to get cross-platform benefits when will be releasing our products on Android. Tricks and hacks when writing Avalonia's xaml (comparing to normal WPF) should be rewarded in the end!)

[timnev]

In my company, we have used Avalonia in some commercial projects already, and despite it being fairly new, it has proven a great tool for completing fully portable and extensible XAML based UI solution.

[kekekeks]

@nilslahr Proper release notes are here: https://grokys.github.io/avalonia/avalonia-alpha5/ . You don't need to use online translator to translate them back.

[betterly]

The Avalonia project is a great effort, bringing together power and simplicity. Let's benefit from it and use it as much as possible when defining the XAML standard.

[insinfo]

The problem with Avalonia is that it is not written on top of a low-level API like OpenGL/Direct3D/Vulkan/Metal, that is a lot of overhead, which is terrible for a graphical framework/library

[insinfo]

I think Noesis Engine is much better is very well implemented, REALTIME Fast Hardware-accelerated vector graphics on GPU and Multithreading-aware architecture, NATIVE High efficient lightweight C++ library without external dependencies on third-party software, MULTIPLATFORM Write once, deploy to multiple platforms: PCs, mobile devices and game consoles, XAML BASED Markup declarative language compatible with XAML and Microsoft Expression Blend

[Mike-E-angelo]

I'm a fan of both projects, and am watching them closely. They both show more passion and knowledge of Xaml than the UWP group (but then again, who doesn't? 😉), and hold a lot of promise. Noesis is more game-centric with a business model that drives it, while Avalonia is open source with a lot of heart and purpose in recapturing and improving the original spirit and intent of WPF.

I feel both talented teams listen to feedback and properly engage their customer base and their ideas, which as this repo has aptly demonstrated has been sorely missing from MSFT for far too long.

Really encouraging to watch both these teams progress as we evolve along here. 👍

[kekekeks]

@insinfo Ehm... Avalonia runs on top of Direct2D and Skia (which in turn uses OpenGL/Vulkan for hw-acceleration and is used as main graphics engine for things like Android and Chrome). The real "issue" with Avalonia is that it's an non-commercial open-source project that doesn't have a huge budget to work with. And that's one of the reasons why we are still using Skia in sw-rendering mode: there was simply no time to port our opengl initialization code from C++ (we had a native Skia-based backend before) to be used with Skia#.

[insinfo]

@Kekekeks @betterly @Mike-EEE @NikolaySt @nilslahr @dimsont

Direct2D and Skia is already an overhead on Direct3D and Win32 I know how difficult it is to develop an open source project, and even more difficult to create a multi-platform project written from scratch using only the native APIs of each system (like Win32, Xlib, X Window, X11, Android SDK, Cocoa Touch) And low-level graphics libraries (like OpenGL,Direct3D), but it is possible to create a multiplatform project without overhead and hardware acceleration. Some examples of GUI frameworks written from scratch ~: It is well worth seeing this example.

Moe Presentation Framework A WPF-alike GUI Framework for .Net Core. Based on Direct3D and OpenGL https://github.com/sunnycase/MPF

Turbo Badger Fast UI toolkit for hardware accelerated games & applications https://github.com/fruxo/turbobadger

Otk - Open Tool Kit It is based on OpenGL

Zebra WEB based Rich UI applications. The approach sits on top of HTML5 Canvas element what makes possible to render any imaginable UI http://zebra.gravitysoft.org/

canvas.ui HTML5 Canvas UI Framework with Multitouch support https://github.com/vnoise/canvas.ui

webix https://webix.com/

To create a good GUI Framework cross-platform from scratch are many difficulties, more in the end certainly worth it:

1. Mouse placement of the caret has to be reimplemented.
2. Keyboard movement of the caret has to be reimplemented (possibly across lines, for multiline text input).
3. Scrolling of the text field has to be implemented (horizontally for long lines, vertically for multiline input).
4. Native features such as copy-and-paste have to be reimplemented.
5. Native features such as spell-checking have to be reimplemented.
6. Native features such as drag-and-drop have to be reimplemented.
7. Native features such as page-wide text search have to be reimplemented.
8. Native features specific to the user, for example custom text services, have to be reimplemented. This is close to impossible since each user might have different services installed, and there is an unbounded set of possible such services.
9. Bidirectional text editing has to be reimplemented.
10. For multiline text editing, line wrapping has to be implemented for all relevant languages.
11. Text selection has to be reimplemented.
12. Dragging of bidirectional text selections has to be reimplemented.
13. Platform-native keyboard shortcuts have to be reimplemented.
14. Platform-native input method editors (IMEs) have to be reimplemented.
15. Undo and redo functionality has to be reimplemented.
16. Accessibility features such as magnification following the caret or selection have to be reimplemented.

[kekekeks]

Well, we have a really simple graphics backend API (which closely resembles one from WPF) and a big set of tests for rendering subsystems, if anyone feels competent enough and has sufficient resources to write one on top of low-level graphics API, we'd be happy to help. Due to the lack of such individual, we are working with what we have, which is industrial grade 2D graphics libraries that can already do proper tessellation of complex 2D geometry with curves and self intersections, proper font rendering, etc.

[kekekeks]

Xlib, X Window, X11

1) Xlib is considered outdated, the usage of libxcb is advised instead. 2) X11 alone is not sufficient for apps. One needs at least system file dialogs that are usually provided by GTK/Qt 3) With upcoming migration to wayland apps will be required to draw window decorations on client's side. So it's pretty much required to rely on GTK/Qt to render them with proper theme.

[nilslahr]

I think the idea here is that there won't be a single XAML system and each will have their own benefits. Some will focus on performance, 3D and gaming, while others might focus on Mobile and Platform compatibility. Noesis is an amazing package with guys I've met on the phone... great smart people. They have their own challenges using C++ to back-end XAML, while they have their advantages on being able to render the output into other engines, such as Unity.

The goal is that we end up with a XAML specification that works regardless of the optimizations of the rendering engine. The rendering can be swapped out, modified, upgraded over time.

It would be nice to couple the XAML 'standard' specification this project is proposing to create with a strong open source cross platform version that represents the standard, and one that everyone can view in C# and test against. I have seen an Avalonia application running on Windows 10 and iOS (with little to no changes!) with all custom controls and providing advanced analytics, video and graphic visualizations. Some here say it needs to be more 'native' but frankly it is SUPER fast today.

So while we look to building the XAML Standard Spec, I'd still suggest that Avalonia is the closest open source project that can allow testing on multiple platforms of the spec. Eventually Microsoft will implement the spec also, perhaps their own way and driven into their products. Essentially duplicating Avalonia internally and/or finding a way to use Avalonia and then introduce more native rendering where/when necessary.

[insinfo]

@kekekeks I saw that the interface "IDrawingContextImpl" is very similar to Direct2D, it is already an interesting starting point. I believe a good multiplatform graphical framework does not need and should not depend on "system file dialogs" making its own implementation. Wayland is something that can also be implemented in the future, by any graphic framework, more at the moment X Window still dominates the Linux like universe

Dependency of GTK/Qt is very bad as it is more of an overhead, and there may be code wrap or even the project may end. Already the system kernel and its low level APIs as a graphical X Windows server, it takes a lot of time to undergo major changes. For example the Win32 API that exists long time ago and has undergone little or no modification. It has super old applications that still run on Windows 10.

[kekekeks]

should not depend on "system file dialogs"

You severely underestimate the complexity of them. They don't simply browse file systems and provide thumbnails, they are also responsible for mounting network file systems, keeping the list of user-profile-wide favotite/recent locations, etc. It's an integral part of the user experience provided by the operating system.

[meteorsnows]

We knew the complexity that Windows UI is achieve, and much more efficient with whole lot of features.

But the newest WinUI only support Windows 10 above is kinda disappointing. Although Windows 8 is coming to end of Support Lifecycle

In Today fast changing world, if you don't want all the App build using Electron/ Flutter...with getting started app use around 40-100MB easily. I know that possibly 10MB-80MB difference than WPF or UWP.

If Microsoft want to declare the win is Chromium like MS Edge Chromium, just build a WebViewNew class that using MS Edge Chromium based ....

Actually there is no much alternative to have base Cross platform OS integration like Electron had, and accessible to modern web feature

Problem Solved. Let deal with the 10MB-80MB memory usage.