1. It's very very hard to find out what's intuitive, yet powerful to use. Unlike implementing some algorithms, creating a good UI requires feedback from users.

2. It takes a lot of time and you frequently have to start over once you find out that what you thought works well, doesn't work well for others.

3. From anecdotical experience, I'd say that user interface design isn't what open source developers are interested in. It's a distraction from what they actually want to work on.

Personally, I find Inkscapes UI okay to use. Blender and Gimp, on the other hand, are a horrible, unintuitive mess. Whenever I need to do some image manipulation, I try to get by with Irfan View and Inkscape (even for raster graphics) as much as possible, just to avoid having to mess around with Gimp.

In the case of Blender once you get the hang of it, you'll feel more confortable than with other similar tools that do the same. I would say its kinda like vim.

Also why don't you use Krita?

> Also why don't you use Krita?

Because GIMP is for general image & photo manipulation and the product vision for Krita is to be a painting application.

I just fund out about Pinta yesterday - and it's a pretty nice alternative for folks who don't like GIMP UI.

GIMP is a mixed bag though. For the chrome of the application they definitely need more work, better icons, better toolbars, organisation of the UI etc. However, their on-screen tools (selection tool, path tool, gradients...) I find the GIMP UI much superior to all other programs I have tried.

I've been using Gimp for 10+ years, the UI doesn't bother me at all in fact, one could say hit has become intuitive.

No-one ever said Photoshop 3's UI was unintuitive, yet that's what Gimp feels like to me (having used PS from vers 1 through 4)

For an example of a great UI (and a good CAD program) see solvespace: http://solvespace.com/index.pl

It has nowhere near as many features though. I think part of the UI problem is handling a huge number of tools and features like in Inkscape and Blender.

Blender's UI is great, highly productive and ergonomic, the way Vim UI is great.

It does have a learning curve. But the same applies to 3DMax or whatever else you might consider using professionally.

Blender's UI is pretty good, much better than it used to be. It takes some getting used to, but once you learn the keyboard shortcuts, it's pretty quick to navigate.

That said, Andrew Price's improved UI mock-up did look pretty amazing, and I'd love to see something like that.

> Andrew Price's improved UI mock-up did look pretty amazing

https://www.youtube.com/watch?v=UWacQrEcMHk if anyone's looking

E: After watching it, I have to say it has a lot of good ideas, although the dynamic ribbon stuff is probably too much (how did I get here, how do I go back?)

Mr. Price did some re-thinking and a follow-up presentation on that same subject, which is also interesting viewing.

https://www.youtube.com/watch?v=6aIA2LaB2Iw

Thanks for that. UIs really are not what people thinks, anyone interested in them should watch the video.

I was going to say exactly what you said. Unlike Gimp I love Blender's UI..

I took two attempts to get the hang of Blender but the UI was so alien I gave up. Maybe I'm going to try a 3rd time because Blender is just such a powerful tool, but I'm not doing 3D full time so it's difficult to justify 3+ weeks learning.

For casual 3D work, I've always been a big fan of SketchUp, but there's nothing like it for Linux. A couple years ago I tried to run SketchUp via wine which to my great surprise almost worked, but when I wanted to save my model it crashed :(

For CAD work get solvespace: http://solvespace.com/index.pl

Inkscape now has a design team, started by Xaviju of rethinkscape (see the link in another comment). Do join the fun in the dev mailing list and IRC #inkscape-devel

Unfortunately, rethinkscape was never followed up.

https://news.ycombinator.com/item?id=9883145

That link you posted is dated 540 days ago. The situation now is that Xaviju met Inkscape devs at the last Libre Graphics Meeting and the forming of the design team was decided.

I don't get your point. We are talking about professional software here, there is no "user friendly" Illustrator or Photoshop either. They all require a heavy use of keyboard shortcuts and have learning curves that a broader audience simply cannot get past and all need input devices that a broader audience simply doesn't posses. It takes equally long time to get productive in any of them. The real difference is not in their UIs, but in features, tools, performance, especially performance, Adobe just has more resources to throw at it, and those things can make you noticeable more productive in the long run.

Why is it good for professional programming languages to value clarity and elegance, but not professional applications?

Andrew Price explains better in his talk about Blender redesing than I could: https://www.youtube.com/watch?v=6aIA2LaB2Iw

Many things in UX design apply to programming languages as well.

"git usability discussions"

That could be a glorious thing.

It's mostly because good UX testing costs a ton of money and these projects are mostly created by pure developers and not designers.

I'll bite.

The same could be said for programming: it costs a lot to produce code. In fact, if you run sloccount on Inkscape you end up with about 470.000 lines of code. Whatever way you slice it: that's a considerable effort. Yet people have contributed that for free.

Does this mean that UX-designers aren't interested in working on open source projects? Or does it mean that it is hard for them to collaborate with open source developers? If so: what are those problems?

The reason I'm wondering this is that if I were a UX designer wanting to make a name for myself, making some piece of open source software UX really good would seem like the best possible way to promote myself.

I think it's a slightly different issue. A UX designer usually does not have the ability to run a project independently from the beginning. A programmer can, even if it results in a crappy UI.

Successful open source projects don't usually start with teams. They start with programmers with an itch to scratch. It's hard to get investment in a group of people. Everyone is always keen at the beginning, but drift away as the realities of the daily grind kick in.

So if you are non-programming UX person, you are dependent on a programmer who might not stick around. Then you are shopping around for programmers (which never show up). If you are a programmer who wants a UX specialist, the one you start with usually wanders off and then you are shopping for a new one (which never shows up).

The result is that programmers develop a culture of building these kinds of apps and UX designers don't. Even if a UX designer shows up late in the process, they now have to fight all the programmers who have gotten used to making the decisions. And one of the perks of running your own project is not having to listen to other people. If you want to do what other people tell you, you can get paid a lot more ;-).

I have a theory. There's a much weaker positive feedback loop. If a commercial product is nicer looking and easier to use, more people will buy it so there's more money to fund development. Management will demand redesigns and improvements because that creates more revenue.

With open source, the feedback loop from users to developers is much weaker because it's not powered by money. It turns out changes in cash flow are a valuable signaling mechanism. I think this is an issue with many aspects of Open Source development, not just UI.

I'm not in any way saying this is an unresolvable issue or that it dooms OS projects, or anything like that. I just think it's a factor.

My two cents:

- UX designers that are actually good at their job seem to rarer than good programmers

- Hence the pool that would or could contribute to FOSS is smaller

- Getting UX changes in is likely something that maintainers don't really like, because it's harder and more time consuming to review (eg. the code you can just look at, but to review a .XML UI you need to apply patches, compile/build, play with it etc.), also UI changes will almost certainly require a bunch of code changes, so if you're changing a ton of lines to "improve UX", then it's not really a great incentive for a maintainer to invest his time into merging that (because it's "just UX").

UX also tends to be opinionated, the guy who wrote the interface originally probably has no issues using it himself, but is probably somewhat opposed-by-default to changing it (works for me™).

Also, if the UX human isn't also a good coder she probably needs to find someone who works with her to make the necessary code changes to support her UX changes, which would be quite challenging in many projects. (Why would I invest a lot of time to work with someone - that I don't know, has no reputation in the project - on something where maintainers will probably not give some sort of "yeah we'll merge that"-waiver?).

- Good UX has a lot to do with consistency. So fixing up an inconsistent project will mean tons of changes, exacerbating all the issues above. It might be as big a change as porting to a different language or framework. How likely is maintainer acceptance for such changes?

So unless there is a process for doing UX in a project, and all the project maintainers back the process, and the process is actually somewhat sane, it's unlikely that it'll work out. This might mean things like having an UX review queue and UX review for new interfaces. Imposing strict UX guides on code/feature contributions might also deter contributions. So you also have to balance these things.

«to review a .XML UI you need to apply patches, compile/build, play with it etc.»

That's also assuming that you have an XML or designer friendly UI toolkit at all. A lot of Open Source is built with GUI toolkits that use essentially 100% code and don't have good designer-friendly tooling (because the programmers were busy scratching other needs first). That definitely narrows a lot of designer input to designers that also can code.

A lot of people give Electron flak, but if there is one benefit to Electron becoming more common in the wild for open source projects, its the relatively much more designer friendliness of HTML/CSS(/SVG/etc) as opposed to classical C++ macros and duct tape UI toolkits.

For that matter, and bringing things a bit more on topic, I'd think Inkscape could be a good application to "dogfood" their own tool and own code a bit further and build more of their UI/UX elements in SVG itself. (Maybe even in a way that others could piggy back off of for future applications.)

"Don't have good designer-friendly tooling (because the programmers were busy scratching other needs first). That definitely narrows a lot of designer input to designers that also can code."

This is essentially the case with GTK+. Glade, though it has potential, is practically useless in it's current state. I've searched far and wide to find a mature project using it - so I can learn how to use it on the next level - and came up empty handed. There is no next level.

As far as it goes with GTK+, the only people designing UIs are programmers. It's all either hard coded in C or Vala (or sometimes C++), or defined in XML using tons of features that aren't implemented in Glade at all, and require an intimate knowledge of the GTK+ API.

As a free software enthusiast trying to work on a GTK+ application, I'll be the first to say, things could be (need to be) much better here! Beyond a couple trivial examples, the reference, and a couple dated books, documentation is extremely scarce. The tooling is incomplete, and it seems that the majority of people working in GTK+ have either grown used to working like this, or moved to another UI stack. Making GTK+ programming more accessible doesn't seem to be a priority (and adding more language bindings, or entirely new languages don't help nearly as much as a couple solid books on GTK+/GTKmm and a first class Glade would).

The only way to really learn the ropes seems to be by meticulously dissecting dozens of free software projects. No one will ever invest their time do this commercially when they can hit the ground running with Qt. It only seems remotely possible for stubborn people who write software as a hobby, and people who have matured to the point they can sell their knowledge. For a UX designer to end up here, they would have developed much more valuable skills in the process.

Two things:

- Consistency. A good UI requires consistency throughout, which requires a good understanding of the entirety of a piece of software, and a willingness to work at a high level. For open source packages there’s rarely a UI standard to hold individual problems up against.

- User testing. UX design doesn’t work in a vacuum, it requires user testing to be effective. This costs a lot of time and effort to organise, and isn’t something you can hack on for a few nights. It’s possible to to A/B testing to gain data of course, but then you have to persuade your friendly developers to implement a testing framework and have some place to store data while waiting for the results to analyse.

The easiest way to get consistency is to have a single person in charge of the UI. It doesn't need to be a UX designer specifically, just someone with a strong sense of style.

For a contrary opinion on the cost of usability testing, see "hallway usability testing" at https://www.joelonsoftware.com/2000/08/09/the-joel-test-12-s...

Part of good UX is consistency and getting that kind of requires a consistent team or an all-knowing overlord. My guess is that's why it's hard to get to and keep a good UX in OSS. Once the UX is good there shouldn't be much work for a designer to do and they're not gonna sit around, not getting paid, just to make sure someone doesn't mess it up, that is boring.

I'll add another potential reason - culture. Many (most) developers grew around open source, or at least interacted with it in significant ways during their (work and/or hobby) career. Many if not most of the tools they (we) use for programming come from open source too. So we're kind of used to this environment of collaboration. You see a project you like and have some spare time, it's natural to contribute.

I doubt UX specialists live in such a culture. I might be wrong, but from my experience with artists and designers, it's much more of an individualistic culture with stronger commercial interest. I.e. "I do it for myself" and then "want my work - pay me".

If that is true, then there's simply much less UX specialists with spare time and interest in open source than there are such developers.

I think the big thing is that most open source software is done on Linux, while most proprietary software is done for Windows and Mac. On Windows and Mac you have only one, native look and feel, to which all apps try to conform. On Linux, every distro looks different, and a big part of users doesn't want GUIs at all, so they consider aspects like look and design secondary. On Mac and Windows most users want GUIs for everything, so it's more important to make those GUIs look and feel good.

Windows doesn't really have a uniform look and feel. It has a sort of ideal at any one time, often led by whatever Microsoft are doing with the next version of Office, but the result is a giant mishmash of things written at different times using completely different toolkits and themes.

I think the big difference is actually that commercial software entities can hire UX people to design their user interactions. Open source projects generally have nobody with that kind of skillset, and if there is any money available it gets spent on core programming because there are masses of bugs to fix and features to implement.

I wonder how we could encourage more designers and testers to contribute to FOSS projects?

The problem is, designers can't implement changes themselves and developers won't work with designers long enough to actually implement new interface. For this you need a VERY motivated developer/designer hybrid and this is very hard to come by.

I know this because I am a developer and have a very good designer friend.

How can this be addressed?

I don't know, but maybe paying a developer to implement new interface.

Why not do some inspirational sketches and videos and see if the ideas actually convinces someone.

Or maybe UX as a separate role only works in hierarchical organisations where you only have to convince a few people that maybe don't care that much, don't have to do the work themselves, and might not enjoy thinking out things on their own, just saying...

Also see what happens with Gnome.

What do you mean? I find it a pleasure to work with the Designers. Even though they are paid by RedHat, as a volunteer contributor I feel I have good discussions with them and am happy to implement proposals. They follow up and seem genuinely happy about your contributions.

I meant https://en.wikipedia.org/wiki/GNOME#GNOME_3

Do you mean the conclusion that it was in hindsight regarded as a good step forward?

You do know that we, the GNOME application developers, spend a lot of time supporting both MATE and unity to give people the best experience no matter which shell they use, right? Do you feel excluded by our work?

It'd be better to get people to read "Don't make me think". The concept of doing budget usability testing every month could help a lot of projects.

And with current technologies I'm sure you could set it up to be all remote with volunteers who'd like to help or use the help of their family members.

Find 2 or 3 random people and ask them to do some task while describing their thought process. Get your devs to watch the recording, notice what's not easy to understand in their UI and make it a priority to resolve.

Sometimes it wouldn't hurt if open source applications adopt UI defacto-standards made popular by popular proprietary applications.

Inkscape, Krita and Gimp have a good or at least good enough UI (it took some years). I don't understand why Blender has such a unique UI. It feels more like Unix Motif style app from 1994, something that was used for Jurassic Park. 3D editors and 3D CAD apps got a lot more user friendly - pretty much every 3D editor from 3DMax to UnrealED, Unity Editor and 3D CAD like Soldworks, CATIA, Creo and the open source FreeCAD have a very similar user interface and UX. You don't need a manual, if you know one, you can easily pick up an additional app and learn the details starting from there. I wish Blender would over an alternative mode, with more "traditional" mouse and keyboard mappings and re-arranged toolbar-icons.

In part I think UI is difficult because you can't do it incremently - if you update part of the app to have a better UI then the whole app suffers with lower UX because of the disparity in design and non-consistency in operation.

Meanwhile adding or updating features can be done readily, just stick another menu item on ... which can be eroding the UX gradually.

To add to that the UI that you have becomes familiar and so there's a huge inertia to overcome to make changes. I'm used to The GIMP way of things because it was my first such graphics program that I used heavily - using something like Photoshop/Krita/Corel Draw is hard because of the nuanced different approaches despite them being probably easier for a person approaching them fresh.

It's a difficult thing for a developer to distance themselves from an app to take a fresh view, also difficult to have a plan to make the app harder to use for veteran users in order to make UX gains in the long run.

My 2¢.

Is a cohesive UI basically a dictatorial effort that needs a command-and-control effort from a powerful visionary force to implement? If so, that's not a good match for decentralized open source development.

Or at the least, more effort would need to be put in on the meta layer - how to enable a cohesive UI vision in a decentralized manner.

I'd imagine this is a different challenge than backend coding styles. There is still room for differing backend coding styles as long as certain principles are followed like following APIs, writing tests, etc. A cohesive UI requirement sounds much more stringent.

I think that this is an issue shared by almost all open source projects.

They thrive to include as many feature as possible and have absolutely no UX / design guidance.

Anecdotally, each time I have interacted with open source enthusiasts while working on a our b2c closed source product, they have ended up being very user adverse with little empathy for the fact that the end user has no interest in learning to use the 10000 features they want to dump to them.

Yes, the ui is not user friendly and it alieanates designers who are used to other software. We need more designers in the inkscape, gimp and blender communities.

You could try Paint.NET (http://www.getpaint.net/index.html).

Windows only though.

Paint.NET is for raster images, not vector like Inkscape.

Was about to say there's a Linux version but: https://github.com/shana/paint-mono

It's 10 years ago. I feel old.

There's also Linux alternative if you feel like giving it a go. https://pinta-project.com/

Changing the UI so it's actually better is generally a non-trivial task.

Well said. Changing it is easy, actually making it better is rather tricky.