I think it would be more interesting and useful to have the source for WPF, given that WPF is an actual GUI toolkit implementing its own widgets, whereas WinForms is basically just a wrapper around Win32.

Just a quick plug then for my own project: https://github.com/grokys/Perspex/

And WPF seems pretty slick. I've only used it as a developer who has little UI skill, but it seemed to be far better than other UI kits. The design seemed rather coherent. Too bad performance and rendering issues hurt it for the first half decade of its life.

Unfortunately, I think a lot of the interesting parts of WPF are just wrappers around DirectX APIs.

That's just for rendering. All the controls and data-binding mechanisms are straight-up C#.

For example: http://referencesource.microsoft.com/#PresentationFramework/...

Java Swing turned out to be a failure because it didn't look native on any platform.

I would recommend something like Eto.Forms (https://github.com/picoe/Eto) which is an abstraction over native GUI toolkits (WPF, WinForms, GTK+, Cocoa)

Works really well and mature.

My impression of Java UI components was that they looked boring and old-fashioned. It's a subjective judgement, but I guess others would have thought that way too. If Java Swing or other parts of the Java UI toolkit looked better than many native GUIs then there would have been more interest.

There has been a lot of interest. There are thousands upon thousands of big applications out there built on Swing, you just don't use them, because Java has never caught on in desktop consumer apps. But JetBrains' IDEs are based on Swing, as is NetBeans, and they look great.

I think looking great is entirely subjective.. I think that the JetBrains' IDEs look horrible... the skinning as it stands is inconsistent at best. They are cross platform.. but even looking like something built with bootstrap+fontawesome would look better. VS looks awesome (tends to run like ass though) by comparison.

NetBeans looks very native.

Yup, it was different and it was worse. And full of bugs, particularly w.r.t. focus-handling, which even Sun's own (presumably correctly written) Swing applications were afflicted with.

Ironic, then, that many of the most popular IDEs in the world right now are based on Swing.

I don't think they are going to open-source legacy stuff that they want people to forget. .Net, ASP.NET, CLR -- all of it is technology they want to keep.

I wish.

One of the projects I am currently working on, a greenfield application, requires WindowsForms for reasons I cannot expose here.

WinForms is a pretty great UI toolkit. It's easy to use, fast, and requires very little system resources.

This. It might appear a bit clunky at first sight, and it might not provide the shiniest eye candy out of the box but in terms of development velocity to get something practical done - provided it is combined with the tooling in Visual Studio - it's really nice.

Velocity? Only for simple, boring UI.

Any non-standard control requires GDI+ rendering, which is not very maintainable. WPF offers a far superior composition ability.

I agree I would not suggest doing anything non-standard with it. And yes, it looks dated and ugly. But in some places visual appearance of widgets is not that important.

Often, boring UI:s are good. The tool should fade into the background and let the user focus on getting her work done.

While I love shiny things the real world accepts good enough solutions that are economic to develop.

Theoretically I just adore WPF:s scenegraph oriented paradigm since it feels the right way but... I've observed that for a large projects practically it needs a lot of work to get anything usefull done compared to forms. Perhaps the overall architecture is a bit big-org oriented where every tiny widget will have its own development team. Which is understandable but means for simple UI:s WPF might be a lot more expensive. I haven't done anything massive with it myself but have just observed a few projects from my work. I hope there are counterexamples.

"Non-standard" doesn't necessarily mean "shiny". Often you need to compose elements in a way that makes a certain UI feature possible, or convenient. Such compositions aren't inherently shiny; they can even be ugly. But functional.

In WF it's very hard & tedious.

I love using simple boring UIs because they are predictable. WPF encourages non-standard custom drawn stuff that only serves to distract from usability in my opinion. WPF also still has weird focus rectangles and font issues.

Yes it is quite nice, but WPF/XAML is better.

Doesn't sound very greenfield if you're already forced to use an aging legacy technology.

I'm implementing a brand-new GUI application in Win32 right now, for three reasons:

1) It's going to be used in conjunction with other legacy applications that only run on Windows PCs anyway.

2) GUIs designed for both phones and PCs don't work well on either, it seems to me.

3) In fancy high-level frameworks you often eventually end up calling a bunch of Win32 functions, so I might as well learn it. :)

The application is greenfield, the environment where it needs to run, not.

I ported Mono's WinForms implementation to .NET Core some time ago as a proof of concept: https://twitter.com/akoeplinger/status/546832629010817024

Would be great if MS open-sourced WinForms as well so we could fill in the gaps.

I'm still waiting for a good cross-platform UI toolkit with good tools and ecosystems around it without resorting to C++ (Qt) or JS approach (atom/nw).

C++ tooling is behind its time (CMake, no dependency management) and JS approach seems kludgy right now.

Java was pretty close (JDK .. or NetBeans, support packaging to Windows or Mac AppStore) but the UI component for OSX is not pleasing and would be nice if it can produce something for Ubuntu/Redhat at least (don't care Arch or the rest at the moment).

Basically I want something better than what Oracle Java has to offer today :)

PS: I would require a great IDE, unit-testing/automation-testing, good scriptable build (Maven/Gradle style, not Ant/NAnt/MSBuild).

You should look at JavaFX. I just finished an app based on it. It's the official replacement for Swing and is quite WPF like in nature (scene graph oriented, etc).

Although there are skins that can make it look native on each platform, I didn't bother with this for my app. Trying to match native on a cross platform app is a fools errand. A few months after you ship your app, the OS developers will decide to reskin everything and anything not using their native toolkit will look out of place. So my app takes its inspiration from Twitter Bootstrap and just doesn't even try to look native. You can skin JavaFX with CSS so it's quite easy to match the look, at least in some ways. Nobody has complained and quite a few people said the app looks great. I would definitely do this again for my future apps. Pick a nice design that isn't native to any platform in particular, and people won't hate you for it.

BTW Java now comes with a packager tool that makes self contained native installers which don't depend on the user having Java installed. Deployment is a lot more practical these days.

I agree. Xamarin guys have done a great job at delivering cross platform UI, making C# first class on most platform, but their API's still lag behind .Net official framework and are stuck to the .Net 4.0 era.

Sounds like the only thing that would fit your bill would be IntelliJ IDEA using Java bindings for either wxWidgets, Qt or GTK+?