I was looking for something like this after .NET Core 1.0 announce. I am just waiting for it to be compatible with .NET Core. Any plans for making it compatible?

Great job!

Yep! The main thing that's holding me back personally is that we'd have to convert our .csprojs to project.json... And then convert them back in a few months/a year when core moves back to .csproj. So seems like wasted effort to me right now...

Nice work. Looking forward to .NET Core support.

I assume this is the relevant issue? https://github.com/AvaloniaUI/Avalonia/issues/314

Why are they moving back to .csproj?

See the official statement here: https://blogs.msdn.microsoft.com/dotnet/2016/05/23/changes-t...

There was nothing wrong with csproj, apart from the MSBuild verbosity baggage. JSON's a terrible format for anything like this due to lack of comments and visual noise. (The mandatory quotes all over the place makes it hard to read.)

But I can't imagine it is hard to convert between them. Most .csproj's are basically a list of references and a <Compile><Include>*.cs.

For a non professional developer, it is almost entertaining to watch all the fads coming and going.

XML is fantastic, all data XML!

XML is horrendous. All data in JSON. I can't believed we were using this awful XML!

JSON is sooo lame. XML is the new JSON!

Same for languages, frameworks, programming patterns, etc...

Even more volatile than fashions.

While some people get a bit cargo cult about things there is a rough consensus that XML is good for some things and terrible for others whilst JSON is the exact reverse ;-)

I personally rather like YAML for anything intended for humans to read and edit.

If XML didn't have those idiotic verbose closing tags, this probably wouldn't even be a discussion. Or if JSON had comments and didn't require quoting all keys.

What's funnier is seeing the HTTP/JSON folks re-invent SOAP. But maybe this time it'll actually be Simple.

> due to lack of comments

Visual Studio Code handles this by just allowing comments in JSON used for configuration, heh.

In other words it handles this by not actually using JSON. Sorta proves the point.

Do you have any plans to implement accessibility? On Windows, you should probably implement a UI Automation provider. For GTK-based platforms, I guess you need to use ATK. You'll need an accessibility API of your own to abstract over the multiple back-ends; maybe copy what Gecko has in its nsIAccessible and related interfaces.

Yes this is definitely something we need to do. Unfortunately it's not something I'm very familiar with, but contributions welcome! ;)

Are there any plans to support styling so you can get a native look-and-feel on non "Modern" Windows operating systems?

There's already https://github.com/picoe/Eto if you want to use native controls - if that's what you need go for it! But there's a need for both approaches IMO and hopefully Avalonia can start to fill one of those!

EDIT: Ah you edited your question: yes controls are fully styleable - the reason we've got the "modern" look so far is simply because it's easy! More themes, and "native" looking themes are definitely welcome.

It looks like Eto doesn't plan to support .NET Core. https://github.com/picoe/Eto/issues/457

But this might change if a framework like Avalonia adds Core support.

Any chance you plan on supporting UI's for Unity3d?

Not really thought about unity in particular, but we do have game ui as a potential use-case.

Would this potentially work with Monogame, as that's built on the same framework?

Honestly - no idea. However our backends are pluggable so in theory you should be able to adapt it.

However, I imagine our performance at the moment exclude use in games. It's something that needs to be optimized.

What graphics backend do you use there?

If you want it to be used in games then on Windows, for example, Direct2D is the only reasonable option.

It will allow to render UI on layers inside DirectX 3D scenes: http://sciter.com/sciter-and-directx/

Yep, we have a Direct2D backend (in fact that's our main one - the others are lagging behind a little)

Anything around graphing yet? Or Is that still something that I would need to roll with SyncFusion, Telerik or something similar.

No not currently - were still working on the core at the moment, though I think we're just about ready for it now if anyone was interested in starting on it.

Maybe Avalonia support can be added to OxyPlot (https://github.com/oxyplot/oxyplot/tree/develop/Source). It's already portable with a bunch of rendering targets.

what is the support for custom controls like? (i.e. inheriting from a canvas and drawing themselves, while being added as a new widget type to the layout code.)

Custom controls are supported, although I'm not sure that inheriting from Canvas is the best way to do that. See e.g. https://github.com/Core2D/Core2D for an example of an application with lots of custom controls.

The support is great, you can see this example [1] of using custom rendering in Canvas being part of UI layout [2]. You can also see Avalonia in action here [3].

[1] https://github.com/wieslawsoltes/SpiroNet/blob/master/src/Sp...

[2] https://github.com/wieslawsoltes/SpiroNet/blob/master/src/Sp...

[3] https://youtu.be/wZK9MPR_UeE