Feedback

[jsuarezruiz]

The goal of this library is to have drawn controls with Cupertino, Fluent and Material support for Android, iOS, macOS, Windows and Linux. The idea is to have high performance pixel perfect controls offering the same rendering and behavior across platforms.
The list of initially supported controls will be the controls included in Xamarin.Forms Visual with the same properties and events: Button, Slider, Entry, etc.

Your feedback is welcome!

[saint4eva]

@jsuarezruiz Firstly, you are doing a nice work - keep it up. Could you produce a NuGet package so we can test the library? Thanks

[timahrentlov]

I like it! How easy will it be to extend or change the controls compared to the handler/renderer approach?

It would also be nice to get a couple of navigation controls that in combination with the MVU paradigm could be used to implement a flutter-esque SPA architecture that does not use the current XF page concept. I'm thinking of drawn replacements for NavigationPage, TabPage, Flyout page + new ones that emulates modal popups, hero navigations, better custom animation, etc.

As I see it, it is only important to make sure that we can still use high-performance native control abstractions like CollectionViews and CarouselViews, or use native controls that somehow relies on important platform features like accessibility, special keyboards, maps, etc. But there should be no reason why these native abstractions can't live in some new drawn navigational framework. I also suspect that this will be a whole lot easier to port to Linux and WASM :)

[webprofusion-chrisc]

Hi! The gold standard for cross platform is when you can do the major platforms and web. Uno tackles this with WASM, could these controls be made to work?

Very excited to see drawn controls. Accessibility is obviously the priority, followed by functionality, performance (and style-ability?)

[jsuarezruiz]

Thank you all for the feedback.

@saint4eva Having a simple way to test is definitely a better way to get feedback. For now, you can sync the repository and try the sample. Later we can generate NuGet packages on GitHub. It will be when progressing more with https://github.com/dotnet/GraphicsControls/blob/master/STATUS.md

@timahrentlov I have updated the README with an example of how it will be to create a drawn control or modify an existing control.
Will include specific examples of custom controls or an existing control by customizing how to draw any of the layers.

The initial idea is to have all the controls available in Visual Xamarin.Forms:

• ActivityIndicator
• Button
• CheckBox
• DatePicker
• Editor
• Entry
• Frame
• Picker
• ProgressBar
• Slider
• Stepper
• TimePicker

Later, yes, more possibilities can be added.

As for reaching new platforms, yes, it makes it easier. Using native controls, require a renderer to map each abstract view with a native control. In this case you only need to decide how to render on the platform (Example: Linux can use Cairo, SkiaSharp) and create the renderer for the Canvas used on that platform.

@webprofusion-chrisc These drawn controls are based on System.Graphics. In System.Graphics there are implementations for Blazor (WebGL) https://github.com/dotnet/System.Graphics/tree/5754007eb4d52cf1dc6dbdb25a44d159f97782d8/src/System.Graphics.Blazor
It could be possible.

Priorities include performance, accessibility, and customization capabilities among others.

[Cfun1]

I really enjoyed the concept because from simple things + your imagination you can build amazing things, and at the same time you don't loose performance. Also I enjoyed the video where you explained step by step the concept and how to build a control you made the task fun, it is very helpful and wish to see more maybe a part 2.

[charlesroddie]

We want this!

This is a great project. There is a huge demand for platform-independent rendering which is always blocked by the history of Xamarin. This library could end up becoming the best option for the majority of XF/Maui developers, allowing them to:

• Avoid things looking different on different platforms
• Avoid platform-dependent bugs
• Depend on a higher quality repo since contributions improve all platforms and there isn't the noise of some UI doesn't work on some platform.
• Support further platforms easily e.g. the web

Suggestion: focus on plain manually-styled controls first

Cupertino, Fluent and Material

We would not want any automatic styling: only plain styling unless indicated otherwise by specifying explicit properties. Presumably these design systems are optional things at the periphery of this library? I would highly recommend working getting feedback on the standard controls until they are very polished, before splitting off users who want to use one of these design systems, to avoid similar problems to those above (design-system-dependent bugs, noise of managing x controls on y design systems...).

[Speculative] How far can this go?

In theory Xamarin.Forms/MAUI View objects render to/are handled by GraphicsControls objects, which then render to native graphics. I wonder if XF/MAUI could then be taken out completely, and we could work directly with GraphicsControls?

[AliShahesmaeili]

@jsuarezruiz Hi, good work!
Neumorphism is a new design style!
Please consider this style as well
Some UI UX with Neumorphic

[nerocui]

This is such great work!

I was researching the other day about things like this. I know that MAUI currently has no plan to target web, but this could change so much. A lot of web apps are slow and heavy, but if this could work with WebGPU (which is much faster then WebGL) and Web Assembly, web apps could be running at near native speed. And people can finally stop using Electron just because it aligns the code base for all platforms (except mobile, but THIS does all platforms including mobile, so it's even better in that regard).

So my question is: Could this work with WebGPU and Web Assembly? MAUI and Comet are all trying to provide as much choice as possible (in terms of how controls are rendered), so experimenting on those frameworks may need to consider/implement a lot before seeing any result. So I think it could almost be beneficial to assemble some building blocks from either MAUI or Comet to have a drawn control only framework where it can target any platform including (and also most importantly) web.

Flutter has gained a lot of popularity because of this (among other reasons), but I think this could be something for the .NET ecosystem. And WebGPU running on Web Assembly could be much faster than transpiling to JavaScript (which is what Flutter does I think)

[KSemenenko]

We also need some gestures and LetterSpacing https://docs.microsoft.com/en-us/dotnet/api/skiasharp.skpaint.textscalex?view=skiasharp-1.68.1#SkiaSharp_SKPaint_TextScaleX

var paint = new SKPaint
{
    TextSize = 64.0f,
    IsAntialias = true,
    Color = new SKColor(136, 136, 136),
    TextScaleX = 1.5f
};

[danardelean]

This library should be officially be supported by Microsoft . I know that it is a lot of work but with just 2 contributors ( Javier is one and the other 3 looking at the commits still fall behind so counting as 2) this library is already really good.
I don't think we need design parity perfection (even if it would be welcomed) but the benefits on performance side would make it worth the investment.
For both Android and iOS the way Xamarin/.Net for iOs and Android drawing the controls in the runtime where we are coding (.Net) and not having proxy's to the native one (reference count or worst Java GC) should bring a real boost in performance.

[kerberosargos]

Hello when will you create nuget package?

[jsuarezruiz]

@kerberosargos By implementing animations and other small pending details. I would say that in the next few weeks the first package will be ready.

[kerberosargos]

@jsuarezruiz Thank you for your effort.