In my experience, cross host platform ability is a minor consideration for choosing a compiler. In fact, quite the opposite. People much more frequently choose a compiler for it’s superior support for one specific target platform.

Take the Intel compiler for example. People usually buy it when they want to eke every last ounce of performance out of the latest bleeding edge Intel chip. After all, it’s hard to design a compiler better than the guys who can walk down the hall and talk to the guys who designed the chips.

It’s the same reason people buy tools from Microsoft to develop on Microsoft platforms. That’s who has the support first and foremost.

Having worked on a for-pay compiler, I believe the main reason to pay for a compiler is for the support contract. If the customer has a problem with their code and suspects a compiler bug, they can ask the compiler vendor to investigate possible solutions (on the vendor’s dime, not their’s), possibly with a deadline for a response/solution. This can be done without having to publicly release source code for projects which may contain sensitive information, and usually the contract binds the vendor into secrecy about any shared source code. Generally, larger companies are willing to pay for this level of support, while smaller shops don’t view it as worth the money or just too expensive.

In addition, vendors want to please (high paying) customers, so feature requests are prioritized by which customers want them. It is also possible for customers to suggest features more tailored to their needs, things more company specific which would not be widely used. This is not possible for users of GCC or other opensource compilers where features get implemented by those willing to do it in whichever order they feel on their own schedule.

Sometimes it’s not the compiler people pay for, it’s the runtime that works with it. Intel in particular has a tradition of providing excellent libraries for things like multithreading, media support (SSE etc) and extended-precision math.

I have worked with some people that used a paid compiler.

They were doing serious data-crunching in a cluster. Supposedly, the Intel compiler managed to produce slightly faster code for them, and paying for the compiler was cheaper than running more nodes. My understanding is that the difference was very small, but multiplied out with electricity costs factored in it was deemed worth it.

To that effect, I wouldn’t be surprised if most of the HPC super-computers run on specialized compilers provided by the chip manufacturers.

I am with Karl Bielefeldt on this.

I won’t actually trust compilers that offer cross-platform capabilities. Because, to be honest we all know native and targeted tools / compilers always have advantages like knowing the target platform better.

And I believe, when your software becomes complex and performance is needed you can start thinking about switching to paid compilers.

And on addition to that, I believe Microsoft’s compilers are pretty damn good. And like everyone else said, they are free for ever.

GNU free compiler (gcc) comes with GNU license (GPL) meaning you can use for Open source projects only. Supported by big names in software.

Clang (free) is an attempt to avoid GPL limitations creating a good compiler. Also, is supported by Apple, Google, and many others.

VC++ Express (free) is limited to Windows platform (by the way, they made it free in the last moment, because many people from Open Source community asked them about it) and lacks most of professional tools an features. Such as profiler, for example.

So, all these tools are free for us, but are supported by the industry.

Intel (commercial), as Karl mentioned, for projects that target most performance on Intel platforms.