The evil of the Office UI ribbon license

For the next major version of a certain application I'm working on (gee, what might that be ) I'm researching some UI frameworks and techniques. In the past few months I've spend most of my time working on application support library code, language designs, algorithm design etc. etc. (more on that in a later article) and I arrived at the point where I wanted to see how my vision for the major version would work in a draft application, just to see how the various elements would work together visually.

One of the first questions one would ask these days when a new desktop application is started is: WPF or Winforms? The current version is build with Winforms all the way though it's tempting to go for WPF, as it's new, has nice performance and great looks (if you're able to cook up the styles). After a day or 2 of fiddling with the various WPF docking frameworks out there, there's one firm conclusion to be drawn: WPF isn't up to par with Winforms when it comes to serious applications which use a normal windows look and feel: automatic menu, buttonbar handling based on selected docked window for example, one of the cool features of many winforms control libraries, is one of those things which is hard to do in WPF (at least, it's not directly available/build in). One other thing which made me draw the above conclusion was that it in general sucks bigtime when you have a normal windows application with normal menus: the text is in general blurry (or at least blurry in a short period of time after a move/open) and to make the menus to look like normal menus like in VS.NET is a pain (it doesn't get close).

Because we will need a custom rendering system in this major version for some areas, we do need WPF. However, one can host a WPF control just fine in a winforms application, so re-using our already written winforms skeleton was a choice I didn't expect at first but which makes sense.

To Ribbon or Not To Ribbon
The second question one will ask is: should we use a ribbon-like menu system? After all, it's well known that good-looking applications are often chosen over the uglier competition: Looks Sell. So, a nice fancy ribbon menu in an application is tempting, right? After all, at first, a ribbon-containing application looks better (although it doesn't have to be more productive/easier to use, that's another story) Almost every control package out there, WPF or winforms comes with a ribbon control. Now, there's a catch and you likely already know: Microsoft had the fancy idea that if you're going to use a ribbon UI, you have to sign a license with them.

Let's keep the usefullness of a ribbon UI (which IMHO is heavily overrated) aside for now, let's focus on this 'license'. There are two things in this license which made me decide to not sign it and write this blog entry instead to warn you not to sign it as well. Disclaimer: I'm in Europe, and we think a bit differently about imaginary property than for example in the USA (like software patents and the like).

  • It's unclear what a ribbon UI is
    This might sound weird, but let's do a thought experiment. One of the paragraphs in the license says:
    Your Licensed UI must comply with the Design Guidelines. If Microsoft notifies you that the Design Guidelines have been updated or that you are not complying with the Design Guidelines, you will make the necessary changes to comply as soon as you reasonably can, but no later than your next product release that is 6 months or more from the date you receive notice.

    Let's say I create a UI, call it MyUI. MyUI uses a ribbon control. However, as it's MyUI of MyApp, I use it as I see fit, it's my application and my work after all. The control I use is from a 3rd party vendor, not MS. If MyUI doesn't comply with the Office UI license, is it then a UI which has to be licensed? After all, a normal button bar UI also doesn't comply with the ribbon license. That's perhaps obvious, but where is the line which makes a given UI not a ribbon UI? To define that, one has to define exactly what a ribbon UI is. Though if a given UI, MyUI isn't compliant with that definition, it can't be in violation of this Office UI license, as it's not, by definition, a ribbon UI, and therefore doesn't need a license. After all, a normal windows UI isn't a ribbon UI either, although several Office 2007 applications use exactly that UI (Outlook main window for example, no ribbon in sight)

    Let's take another point of view. Let's say 5 other companies are also super proud of their UI work and also try to tie a developers hands by forcing him to sign a license for these UIs. Perhaps you're not even aware of these companies' work and you've never heard of them. Still, your UI looks remarkably similar to their work, or at least main parts of it. Are you now liable? Should you be seen as liable? I don't think so. For the people who think I'm paranoid: ever created a UI for an application which uses a 'Card' UI to display customer data for example ? Likely as the 3rd party control package used had this fancy option and it looked great. But... who cooked up that UI concept? Unknown, yet, that company or person might want to force a license on you similar to the Office UI license, simply because that person or that company is also proud of that Card UI concept. "That's stupid" you might say, and I agree, but why is this Office UI then different? Because it's owned by Microsoft? (although I would like to see what exactly they 'own' in this case, a 'button bar' is definitely not something they invented, and for example many winforms control packages have a system where you can define one set of commands which can be placed in a menu and on a button bar, equally.).

    It's similar to the Office UI and the ribbon: for WPF, there aren't any button bar / toolbar controls available, just ribbon controls. You are of course aware of Office 2007, but say you're working in a company which has still Office 2003, and your application is a normal business application, not something which competes with Office 2007 at all. Why should you sign a license agreement with some company X while you purchased the ribbon control you're using from company Y and have never used or are hardly using this 'UI' from X? And why should you sign only a license agreement for that ribbon control with company X, and not for the docking framework, the statusbar, the grid etc. ?

    Doesn't make any sense.

  • The license contains traps
    For an ISV, the 'I' in ISV is important: we're independent and want to stay that way: only an independent software vendor can create software which is really worth using, as it's not tied to the train of thought of another company. However, the Office UI license contains restrictions that you effectively sign your independency away to Microsoft: Microsoft decides if the UI of your application is 'compliant' with the license and you have to update your UI to make it compliant or you're in violation of the license, and you have at most 6 months for that, which means you can't decide when to make the changes: MS sets the deadlines for that. But that's not the biggest issue. The biggest traps are these:
    c. Microsoft is the sole owner of the Microsoft IP. All goodwill arising from your use of the Microsoft trademark and trade dress rights granted to you in Section 2 will be for Microsoft’s benefit. The quality of your Licensed Products will be consistent with your other products, meet or exceed relevant industry standards and comply with all laws, rules and regulations that apply.

    f. You will comply with all export laws that apply to the subject matter of this license.

    For a European like me, I can't comply to rule f. The point is: the USA has different export laws for software than the EU. For an ISV outside the USA, the ISV and not MS nor the USA, is going to decide to which clients to sell the software, to which countries to export the software. Example: one can't sell a software application to an Iranian firm at the moment, according to the USA. However, the firm apparently has computers which run windows and .NET. It's up to the laws of the country the ISV is in, not to the laws of the USA nor to MS.

    The rule c is a trap as well: since when is the hard work of a) the control vendor (not MS) and b) the ISV something MS can benefit from? Goodwill can come into play when the ISV is sold to another company: the total price to pay will contain 'goodwill'. MS also can't decide what the quality bar is that the ISV will bring into the application: who will judge if the ISV has met the 'relevant industry standard' ? Who even decides what that industry standard is? Microsoft?

I'm often accused of being negative instead of being one of the cheerio-pass-me-the-marketeese-pipe crowd, but keep in mind that the world of an ISV is somewhat different than that of a developer who can leave all legal crap to some suit on the top floor: if the people in charge of the ISV don't take care of these legal issues, if they don't look into the 'what if's, it might well be the ISV simply keels over due to a heavy lawsuit which drains them from all their money, even if they're totally correct and that on paper they should win. That's why ISVs should be careful.

It might sound far fetched, but these kind of issues will in the end affect the normal developer as well. Therefore every developer should say no to software patents and no to silly, evil, licenses like the Office UI license.


  • Hi Frans,

    Two questions:

    1) Given the significant investments Microsoft has made that lead to UI advances like the Ribbon what kind of licensing or other compensation would you approve of to be able to use the Ribbon? Don't you think a lack of any kind of compensation will stifle innovation? If OpenOffice can just copy the entire Office UI why would Microsoft keep investing heavily in improvements?

    2) Since you're obviously investigating other UI frameworks for LLBLGen vNext: why not just use Visual Studio (VSIP)? I was watching an interview on Channel 9 with the C# design team where Anders Hejlsberg made the observation that any new feature starts of at -1000 points because of the overhead for developers to learn the new feature. So it has to be a really good feature if it wants to make it to the next version. I think this rule goes for UIs/applications as well. Hosting LLBLGen within Visual Studio will make the program easier to use and you won't have to invest anything into trying to make the app look like VS.NET.

  • Paul:
    ad 1:. all UI elements currently in use by any program out there are designed by someone so why is the ribbon all of a sudden something you need to sign a license for? Mind you: if I use a ribbon control from a control vendor X, I do no business with MS, yet I have to comply my application to their rules. But... if I use normal UI elements, I don't have to. Why not?

    I don't see why MS should be compensated in any way. Example: Microsoft did usage surveys with LLBLGen Pro for the entity framework. Should we now be compensated because they benefit from our work?

    ad 2) Hosting something in VS.NET isn't simple. It takes a lot of time, and it's not something you do in an afternoon, in fact I think it's easier to simply write a UI yourself than to host something in VS.NET. Though the biggest drawback is that the various parts of the application are fragmented across the VS.NET IDE: properties, main editor canvas, overview panes etc.

    we're looking at a way to host vNext in, but it's not something we're investing time in at the moment, as the main thing that counts now is to finish the app, then if there's time left, integration is an option, otherwise it will be added later.

  • Microsoft is trying to pull an Apple and keep the UI consistency and quality bar high, similar to iPhone apps. Apple can get away with this but Microsoft no longer can. They may have messed up details in the licensing as well, but the bigger issue is that they are no longer in a position to force this stuff down developers' throats.

    It's also too bad you can't firewall their legal constraints to 3rd-party ribbon controls. Instead, the ribbon's legalities are just as viral as the GPL, in the exact same way that Microsoft hates.

  • "why is the ribbon all of a sudden something you need to sign a license for?"

    Because it is a non-trivial, distinctive and innovative way to improve the UI of programs that Microsoft has poured a lot of time, effort and money into. I'm against frivolous patents just like you (Amazon's one click shopping comes to mind) but I believe the ribbon is a genuine innovation and I believe Microsoft should be rewarded for it.

    Re:LLBLGen Visual Studio integration:I'm aware it'll probably more work on your part, but to be frank:I'm a paying customer so I don't care :-)

    My point is that I think it would be a big improvement for LLBLGen because it would put the functionality where it should be: in the IDE that developers work in daily. I don't think the functionality would be more fragmented, your current UI mimics Visual Studio (and you didn't even have to agree to a license :-) so it should fit in fine.

  • @paul:
    It's not the question if MS put a lot of effort in designing the ribbon UI, the question is: is it something MS can use to force very restrictive rules onto anyone on earth who wants to use a similar UI into their apps while they're not doing any business with MS?

    About VS.NET integration: the point is: if you integrate into VS.NET, it should make sense. We are aware that people want integration, we want it too, so that's not the limiting factor. the limiting factor is time: if we have to spend a truckload of extra time to make a seamless integration (think 2 extra months or more), I'm not sure if everyone is willing to wait for that, or more importantly: if a lot of people are willing to give up features because there wasn't enough time because VS.NET integration was required.

    our designer doesn't mimic in crucial parts: we don't use a property grid and I also don't want to use it in, as it's a dumb UI element with serious problems. Integration will also give problems as communicating with VS.NET's services isn't bug free. Hence, what we want is a 100% usable designer which works stand-alone, so people can always use it. Integration will likely be at the level of the EF: so no server browser usage (as not every provider has sufficient support for that), no property grid usage. That integration will perhaps work out fine, but it's not a major goal compared to the other features we've planned.

    And that you don't care is fine ;). However I'm sure you will care if we'll drop a feature you're waiting for to be able to implement integration ;).

    The main point for integration is that the code generation process works together with the solution loaded. So integration will focus on that mainly.

  • Personally I am not a fan of Ribbon at all and the license is indeed weird, at least.
    I am not using it nor I am planning to.

  • I would put all this licensing stuff down to the amount of $'s MS spent on R&D for the ribbon.

    If the rumours I heard were true about just how much time went into that little thing at the top of the screen in Word etc then I am somewhat inclined to side with MS.

    I've never used LLBLGen, and given the great work that has gone into VSX over the years it looks like a nice platform to use to integrate your product.

  • Nice Post to aware us About this detail

  • This is definitely one of the dumber decisions to come out of Redmond. It is bad enough that Microsoft wants to license their "look and feel", but they are demanding that third parties like DevExpress and other component vendors become license police. No thank you. I think I'll stick with standard menus and toolbars in my apps.

  • If you decide to provide a ribbon, please supply a normal menu bar too.

    A good stand-alone app is better than having a a bunch of new windows in VS; If your main UI is integrated in VS, it must be brilliant.

  • For those who say why shouldn't MS get money back to the work they put into the Ribbon. MS did this to try to keep their market share for Office. They needed something to provide a reason to upgrade to Office 2007.

    I happen to like the Ribbon but would not sign this license. Fortunately my customers are not asking for this in the GUI.

  • In my opinion - the ribbon UI was create to solve a M$ problem - they had drop down menus with 25 items in them and many of those items had sub menus. It was getting harder and harder to navigate.

    So, it was much less an 'innovative better user experience' and much more what they had to do to combat the crazy complexity of their office apps.

  • Back in the age of the dinosaurs, Lotus developed a user interface for their 1-2-3 spreadsheet. It involved using the "/" key to pull down the menu, and other elements.

    In order to provide an easier experience for those switching to their products, 1-2-3 competitors adopted the same "/" menu user interface.

    Lotus sued, and lost the case. This UI was not IP that could be protected. I imagine that the same is true of the Ribbon -- unless you sign on the line and agree to be bound by it.


Comments have been disabled for this content.