Using cmany with Visual Studio¶

TL;DR¶

The general form for choosing the Visual Studio compiler version with cmany is:

<vs_version>[_<architecture>][_<vs_toolset>]

where:

<vs_version> is one of vs2019, vs2017, vs2015, vs2013, vs2012, vs2010, vs2008 or vs2005
<architecture> is one of 32, 64, arm, ia64. Defaults to the native architecture when omitted.
as for <vs_toolset>:
- when omitted, uses the default toolset of the chosen VS version
- when either clang or xp is given, uses the default toolset of the chosen VS version for either clang or xp
- otherwise, one of:
  
  from vs2019: v142, v142_clang, v142_clang_c2, v142_xp
  
  from vs2017: v141, v141_clang, v141_clang_c2, v141_xp
  
  from vs2015: v140, v140_clang, v140_clang_c2, v140_xp
  
  from vs2013: v120, v120_xp
  
  from vs2012: v110, v110_xp
  
  from vs2010: v100, v100_xp
  
  from vs2008: v90, v90_xp
  
  from vs2008: v80

Note that not every combination is valid:

you cannot use toolsets newer than your chosen VS version
arm is not available in VS versions older than VS2012
ia64 is not available in VS versions later than VS2012
clang is not available in versions older than VS2015.

Note

cmany defaults to using the native architecture when no target architecture is specified. For example, the command cmany b -c vs2015 will produce a 64 bit build when it is run in a 64 bit system; but when it is run in a 32 bit system it will produce a 32 bit build.

This contrasts with cmake: cmake -G "Visual Studio 15 2017" ../.. will produce a 32 bit build in any system.

VS alias examples¶

vs2015: depending on the native architecture, same as cmake -G "Visual Studio 14 2015" OR cmake -G "Visual Studio 14 2015 Win64"
vs2015_clang: ditto, but use the v140_clang_c2 toolset
vs2015_arm: same as cmake -G "Visual Studio 14 2015 ARM"
vs2015_32_clang: same as cmake -G "Visual Studio 14 2015" -T v140_clang_c2
vs2015_64_clang: same as cmake -G "Visual Studio 14 2015 Win64" -T v140_clang_c2
vs2017_64_v140: same as cmake -G "Visual Studio 15 2017 Win64" -T v140. This will generate a VS2017 solution for x86_64 which is compiled with the v140 toolset which is from VS2015.

Complete explanation¶

Visual Studio (VS) has an awkward numbering system: the year and the version number (it also has a different version number for the cl.exe compiler, but fortunately we have no need to deal with that here). Sadly, and confusingly, these have similar values, and cmake forces you to deal with this by having to explicitly state the full Visual Studio version and year.

cmany tries to help in this situation by making it easier to specify which Visual Studio IDE version and toolset version to use via a simple naming scheme. For example, this will create two VS projects in the native architecture (eg, x86_64), but with different versions:

$ cmany b -c vs2015,vs2017,vs2019

As usual, this would be the result the command:

$ ls -1 build/*
build/windows-x86_64-vs2015-Release/
build/windows-x86_64-vs2017-Release/
build/windows-x86_64-vs2019-Release/

For comparison, to achieve this with direct use of CMake, the equivalent (bash) commands would have to be:

$ mkdir build/windows-x86_64-vs2015-Release
$ mkdir build/windows-x86_64-vs2017-Release
$ mkdir build/windows-x86_64-vs2019-Release
$ cd build/windows-x86_64-vs2015-Release
$ cmake -G "Visual Studio 14 2015 Win64" ../..
$ cd -
$ cd build/windows-x86_64-vs2017-Release
$ cmake -G "Visual Studio 15 2017 Win64" ../..
$ cd -
$ cd build/windows-x86_64-vs2019-Release
$ cmake -G "Visual Studio 15 2019 Win64" ../..
$ cd -

A further point of confusion with Visual Studio is that a given VS solution version actually consists of two separate items: a) the compiler version (the toolset) and b) the IDE version. When you run eg cmake -G "Visual Studio 14 2015" you get a solution for editing your code with the 2015 IDE, and your code will be compiled with Visual Studio 2015’s default toolset which is v140. But you do not have to use this toolset when using the VS 2015 IDE. For example, you can generate a 2015 solution which uses the 2013 toolset, v120. To do that in CMake, the command would be cmake -G "Visual Studio 14 2015" -T v120.

The issue of the Visual Studio toolsets was made less of a corner case with the recent addition (since VS 2015) of a clang frontend, which is convenient for multi-compiler validation of a project’s code. So making it easier to specify non-standard VS toolsets was also from the outset a requirement for cmany.

Aliasing scheme¶

cmany allows you to create any valid combination of the Visual Studio project versions (from vs2017 to vs2005), target architectures (32, 64, arm, ia64) and toolsets (from v141 to v80, with clang_c2 and xp variants). The general form for the cmany VS alias is:

<vs_version>[_<vs_platform>][_<vs_toolset>]

Note that the platform or the toolset can be omitted, in which case a sensible default will be used:

if the platform is omitted, then the current platform will be used

if the toolset is omitted, then the toolset of the given project version will be used.

Note also that the order must be exactly as given: first the VS version, then the platform, then the toolset. For example, when the platform is omitted, then the alias should have the following form:

<vs_version>[_<vs_toolset>]

When the toolset is omitted, then the alias should have the form:

<vs_version>[_<vs_platform>]

If both the architecture and platform are omitted, then the alias becomes simply:

<vs_version>

Check the VS alias examples for seeing this scheme at work. The next subsections give a complete enumeration of the possible values for each item in the triplet.

Visual Studio versions¶

Here’s a correspondence between the basic cmany names and the cmake specification. CMake simultaneously specifies the VS version and the target architecture.

cmany	cmake	target architecture
`vs2019`	`Visual Studio 16 2019 ???`	native, ie 32 or 64 bits
`vs2019_32`	`Visual Studio 16 2019`	x86
`vs2019_64`	`Visual Studio 16 2019 Win64`	x86_64
`vs2019_arm`	`Visual Studio 16 2019 ARM`	arm
`vs2017`	`Visual Studio 15 2017 ???`	native, ie 32 or 64 bits
`vs2017_32`	`Visual Studio 15 2017`	x86
`vs2017_64`	`Visual Studio 15 2017 Win64`	x86_64
`vs2017_arm`	`Visual Studio 15 2017 ARM`	arm
`vs2015`	`Visual Studio 14 2015 ???`	native, ie 32 or 64 bits
`vs2015_32`	`Visual Studio 14 2015`	x86
`vs2015_64`	`Visual Studio 14 2015 Win64`	x86_64
`vs2015_arm`	`Visual Studio 14 2015 ARM`	arm
`vs2013`	`Visual Studio 12 2013 ???`	native, ie 32 or 64 bits
`vs2013_32`	`Visual Studio 12 2013`	x86
`vs2013_64`	`Visual Studio 12 2013 Win64`	x86_64
`vs2013_arm`	`Visual Studio 12 2013 ARM`	arm
`vs2012`	`Visual Studio 11 2012 ???`	native, ie 32 or 64 bits
`vs2012_32`	`Visual Studio 11 2012`	x86
`vs2012_64`	`Visual Studio 11 2012 Win64`	x86_64
`vs2012_arm`	`Visual Studio 11 2012 ARM`	arm
`vs2010`	`Visual Studio 10 2010 ???`	native, ie 32 or 64 bits
`vs2010_32`	`Visual Studio 10 2010`	x86
`vs2010_64`	`Visual Studio 10 2010 Win64`	x86_64
`vs2010_ia64`	`Visual Studio 10 2010 IA64`	ia64
`vs2008`	`Visual Studio 9 2008 ???`	native, ie 32 or 64 bits
`vs2008_32`	`Visual Studio 9 2008`	x86
`vs2008_64`	`Visual Studio 9 2008 Win64`	x86_64
`vs2008_ia64`	`Visual Studio 9 2008 IA64`	ia64
`vs2005`	`Visual Studio 8 2005 ???`	native, ie 32 or 64 bits
`vs2005_32`	`Visual Studio 8 2005`	x86
`vs2005_64`	`Visual Studio 8 2005 Win64`	x86_64

Target architecture¶

From the list above, it is easy to gather the list of valid architecture names in cmany’s VS aliasing scheme:

32

64

arm

ia64

Visual Studio toolset¶

Here’s the list of valid Visual Studio toolsets:

vs2019 compiler toolsets: v142, v142_clang_c2, v142_xp
vs2017 compiler toolsets: v141, v141_clang_c2, v141_xp
vs2015 compiler toolsets: v140, v140_clang_c2, v140_xp
vs2013 compiler toolsets: v120, v120_xp
vs2012 compiler toolsets: v110, v110_xp
vs2010 compiler toolsets: v100, v100_xp
vs2008 compiler toolsets: v90, v90_xp
vs2005 compiler toolsets: v80,

cmany allows several shorter forms for specifying some of these toolsets:

the default toolset can be omitted. For example, vs2017 is exactly the same as vs2017_v141, and vs2013 is exactly the same as vs2013_v120
the clang toolset can be shortened to clang instead of clang_c2. Also, omitting the version from a clang toolset will default to the current VS version’s toolset. So for example, vs2015_clang or vs2015_clang_c2 are the same as vs2015_v140_clang_c2.
the xp toolset has the same ommission behaviour as clang. For example, vs2015_xp is the same as vs2015_v140_xp.

Alias list¶

It is easy to see that combining the VS solution version, target architecture and toolsets above creates hundreds of different possibilities. This section shows what each of them mean. (If you find any errors, please submit a bug or PR).

VS2019¶

cmany compiler alias	project VS version	Target arch.	VS Toolset
`vs2019`	`16 2019`	`(native)`	`v142`
`vs2019_clang`	`16 2019`	`(native)`	`v142_clang_c2`
`vs2019_xp`	`16 2019`	`(native)`	`v142_xp`
`vs2019_v142`	`16 2019`	`(native)`	`v142`
`vs2019_v142_xp`	`16 2019`	`(native)`	`v142_xp`
`vs2019_v142_clang`	`16 2019`	`(native)`	`v142_clang_c2`
`vs2019_v141`	`16 2019`	`(native)`	`v141`
`vs2019_v141_xp`	`16 2019`	`(native)`	`v141_xp`
`vs2019_v141_clang`	`16 2019`	`(native)`	`v141_clang_c2`
`vs2019_v140`	`16 2019`	`(native)`	`v140`
`vs2019_v140_xp`	`16 2019`	`(native)`	`v140_xp`
`vs2019_v140_clang`	`16 2019`	`(native)`	`v140_clang_c2`
`vs2019_v120`	`16 2019`	`(native)`	`v120`
`vs2019_v120_xp`	`16 2019`	`(native)`	`v120_xp`
`vs2019_v110`	`16 2019`	`(native)`	`v110`
`vs2019_v110_xp`	`16 2019`	`(native)`	`v110_xp`
`vs2019_v100`	`16 2019`	`(native)`	`v100`
`vs2019_v100_xp`	`16 2019`	`(native)`	`v100_xp`
`vs2019_v90`	`16 2019`	`(native)`	`v90`
`vs2019_v90_xp`	`16 2019`	`(native)`	`v90_xp`
`vs2019_v80`	`16 2019`	`(native)`	`v80`
`vs2019_32`	`16 2019`	`x86`	`v142`
`vs2019_32_clang`	`16 2019`	`x86`	`v142_clang_c2`
`vs2019_32_xp`	`16 2019`	`x86`	`v142_xp`
`vs2019_32_v142`	`16 2019`	`x86`	`v142`
`vs2019_32_v142_xp`	`16 2019`	`x86`	`v142_xp`
`vs2019_32_v142_clang`	`16 2019`	`x86`	`v142_clang_c2`
`vs2019_32_v141`	`16 2019`	`x86`	`v141`
`vs2019_32_v141_xp`	`16 2019`	`x86`	`v141_xp`
`vs2019_32_v141_clang`	`16 2019`	`x86`	`v141_clang_c2`
`vs2019_32_v140`	`16 2019`	`x86`	`v140`
`vs2019_32_v140_xp`	`16 2019`	`x86`	`v140_xp`
`vs2019_32_v140_clang`	`16 2019`	`x86`	`v140_clang_c2`
`vs2019_32_v120`	`16 2019`	`x86`	`v120`
`vs2019_32_v120_xp`	`16 2019`	`x86`	`v120_xp`
`vs2019_32_v110`	`16 2019`	`x86`	`v110`
`vs2019_32_v110_xp`	`16 2019`	`x86`	`v110_xp`
`vs2019_32_v100`	`16 2019`	`x86`	`v100`
`vs2019_32_v100_xp`	`16 2019`	`x86`	`v100_xp`
`vs2019_32_v90`	`16 2019`	`x86`	`v90`
`vs2019_32_v90_xp`	`16 2019`	`x86`	`v90_xp`
`vs2019_32_v80`	`16 2019`	`x86`	`v80`
`vs2019_64`	`16 2019`	`x86_64`	`v142`
`vs2019_64_clang`	`16 2019`	`x86_64`	`v142_clang_c2`
`vs2019_64_xp`	`16 2019`	`x86_64`	`v142_xp`
`vs2019_64_v142`	`16 2019`	`x86_64`	`v142`
`vs2019_64_v142_xp`	`16 2019`	`x86_64`	`v142_xp`
`vs2019_64_v142_clang`	`16 2019`	`x86_64`	`v142_clang_c2`
`vs2019_64_v141`	`16 2019`	`x86_64`	`v141`
`vs2019_64_v141_xp`	`16 2019`	`x86_64`	`v141_xp`
`vs2019_64_v141_clang`	`16 2019`	`x86_64`	`v141_clang_c2`
`vs2019_64_v140`	`16 2019`	`x86_64`	`v140`
`vs2019_64_v140_xp`	`16 2019`	`x86_64`	`v140_xp`
`vs2019_64_v140_clang`	`16 2019`	`x86_64`	`v140_clang_c2`
`vs2019_64_v120`	`16 2019`	`x86_64`	`v120`
`vs2019_64_v120_xp`	`16 2019`	`x86_64`	`v120_xp`
`vs2019_64_v110`	`16 2019`	`x86_64`	`v110`
`vs2019_64_v110_xp`	`16 2019`	`x86_64`	`v110_xp`
`vs2019_64_v100`	`16 2019`	`x86_64`	`v100`
`vs2019_64_v100_xp`	`16 2019`	`x86_64`	`v100_xp`
`vs2019_64_v90`	`16 2019`	`x86_64`	`v90`
`vs2019_64_v90_xp`	`16 2019`	`x86_64`	`v90_xp`
`vs2019_64_v80`	`16 2019`	`x86_64`	`v80`
`vs2019_arm`	`16 2019`	`arm`	`v142`
`vs2019_arm_clang`	`16 2019`	`arm`	`v142_clang_c2`
`vs2019_arm_v142`	`16 2019`	`arm`	`v142`
`vs2019_arm_v142_clang`	`16 2019`	`arm`	`v142_clang_c2`
`vs2019_arm_v141`	`16 2019`	`arm`	`v141`
`vs2019_arm_v141_clang`	`16 2019`	`arm`	`v141_clang_c2`
`vs2019_arm_v140`	`16 2019`	`arm`	`v140`
`vs2019_arm_v140_clang`	`16 2019`	`arm`	`v140_clang_c2`
`vs2019_arm_v120`	`16 2019`	`arm`	`v120`
`vs2019_arm_v110`	`16 2019`	`arm`	`v110`
`vs2019_arm_v100`	`16 2019`	`arm`	`v100`

VS2017¶

cmany compiler alias	project VS version	Target arch.	VS Toolset
`vs2017`	`15 2017`	`(native)`	`v141`
`vs2017_clang`	`15 2017`	`(native)`	`v141_clang_c2`
`vs2017_xp`	`15 2017`	`(native)`	`v141_xp`
`vs2017_v141`	`15 2017`	`(native)`	`v141`
`vs2017_v141_xp`	`15 2017`	`(native)`	`v141_xp`
`vs2017_v141_clang`	`15 2017`	`(native)`	`v141_clang_c2`
`vs2017_v140`	`15 2017`	`(native)`	`v140`
`vs2017_v140_xp`	`15 2017`	`(native)`	`v140_xp`
`vs2017_v140_clang`	`15 2017`	`(native)`	`v140_clang_c2`
`vs2017_v120`	`15 2017`	`(native)`	`v120`
`vs2017_v120_xp`	`15 2017`	`(native)`	`v120_xp`
`vs2017_v110`	`15 2017`	`(native)`	`v110`
`vs2017_v110_xp`	`15 2017`	`(native)`	`v110_xp`
`vs2017_v100`	`15 2017`	`(native)`	`v100`
`vs2017_v100_xp`	`15 2017`	`(native)`	`v100_xp`
`vs2017_v90`	`15 2017`	`(native)`	`v90`
`vs2017_v90_xp`	`15 2017`	`(native)`	`v90_xp`
`vs2017_v80`	`15 2017`	`(native)`	`v80`
`vs2017_32`	`15 2017`	`x86`	`v141`
`vs2017_32_clang`	`15 2017`	`x86`	`v141_clang_c2`
`vs2017_32_xp`	`15 2017`	`x86`	`v141_xp`
`vs2017_32_v141`	`15 2017`	`x86`	`v141`
`vs2017_32_v141_xp`	`15 2017`	`x86`	`v141_xp`
`vs2017_32_v141_clang`	`15 2017`	`x86`	`v141_clang_c2`
`vs2017_32_v140`	`15 2017`	`x86`	`v140`
`vs2017_32_v140_xp`	`15 2017`	`x86`	`v140_xp`
`vs2017_32_v140_clang`	`15 2017`	`x86`	`v140_clang_c2`
`vs2017_32_v120`	`15 2017`	`x86`	`v120`
`vs2017_32_v120_xp`	`15 2017`	`x86`	`v120_xp`
`vs2017_32_v110`	`15 2017`	`x86`	`v110`
`vs2017_32_v110_xp`	`15 2017`	`x86`	`v110_xp`
`vs2017_32_v100`	`15 2017`	`x86`	`v100`
`vs2017_32_v100_xp`	`15 2017`	`x86`	`v100_xp`
`vs2017_32_v90`	`15 2017`	`x86`	`v90`
`vs2017_32_v90_xp`	`15 2017`	`x86`	`v90_xp`
`vs2017_32_v80`	`15 2017`	`x86`	`v80`
`vs2017_64`	`15 2017`	`x86_64`	`v141`
`vs2017_64_clang`	`15 2017`	`x86_64`	`v141_clang_c2`
`vs2017_64_xp`	`15 2017`	`x86_64`	`v141_xp`
`vs2017_64_v141`	`15 2017`	`x86_64`	`v141`
`vs2017_64_v141_xp`	`15 2017`	`x86_64`	`v141_xp`
`vs2017_64_v141_clang`	`15 2017`	`x86_64`	`v141_clang_c2`
`vs2017_64_v140`	`15 2017`	`x86_64`	`v140`
`vs2017_64_v140_xp`	`15 2017`	`x86_64`	`v140_xp`
`vs2017_64_v140_clang`	`15 2017`	`x86_64`	`v140_clang_c2`
`vs2017_64_v120`	`15 2017`	`x86_64`	`v120`
`vs2017_64_v120_xp`	`15 2017`	`x86_64`	`v120_xp`
`vs2017_64_v110`	`15 2017`	`x86_64`	`v110`
`vs2017_64_v110_xp`	`15 2017`	`x86_64`	`v110_xp`
`vs2017_64_v100`	`15 2017`	`x86_64`	`v100`
`vs2017_64_v100_xp`	`15 2017`	`x86_64`	`v100_xp`
`vs2017_64_v90`	`15 2017`	`x86_64`	`v90`
`vs2017_64_v90_xp`	`15 2017`	`x86_64`	`v90_xp`
`vs2017_64_v80`	`15 2017`	`x86_64`	`v80`
`vs2017_arm`	`15 2017`	`arm`	`v141`
`vs2017_arm_clang`	`15 2017`	`arm`	`v141_clang_c2`
`vs2017_arm_v141`	`15 2017`	`arm`	`v141`
`vs2017_arm_v141_clang`	`15 2017`	`arm`	`v141_clang_c2`
`vs2017_arm_v140`	`15 2017`	`arm`	`v140`
`vs2017_arm_v140_clang`	`15 2017`	`arm`	`v140_clang_c2`
`vs2017_arm_v120`	`15 2017`	`arm`	`v120`
`vs2017_arm_v110`	`15 2017`	`arm`	`v110`
`vs2017_arm_v100`	`15 2017`	`arm`	`v100`

VS2015¶

cmany compiler alias	project VS version	Target arch.	VS Toolset
`vs2015`	`14 2015`	`(native)`	`v140`
`vs2015_clang`	`14 2015`	`(native)`	`v140_clang_c2`
`vs2015_xp`	`14 2015`	`(native)`	`v140_xp`
`vs2015_v140`	`14 2015`	`(native)`	`v140`
`vs2015_v140_xp`	`14 2015`	`(native)`	`v140_xp`
`vs2015_v140_clang`	`14 2015`	`(native)`	`v120`
`vs2015_v120`	`14 2015`	`(native)`	`v120_clang_c2`
`vs2015_v120_xp`	`14 2015`	`(native)`	`v120_xp`
`vs2015_v110`	`14 2015`	`(native)`	`v110`
`vs2015_v110_xp`	`14 2015`	`(native)`	`v110_xp`
`vs2015_v100`	`14 2015`	`(native)`	`v100`
`vs2015_v100_xp`	`14 2015`	`(native)`	`v100_xp`
`vs2015_v90`	`14 2015`	`(native)`	`v90`
`vs2015_v90_xp`	`14 2015`	`(native)`	`v90_xp`
`vs2015_v80`	`14 2015`	`(native)`	`v80`
`vs2015_32`	`14 2015`	`x86`	`v140`
`vs2015_32_clang`	`14 2015`	`x86`	`v140_clang_c2`
`vs2015_32_xp`	`14 2015`	`x86`	`v140_xp`
`vs2015_32_v140`	`14 2015`	`x86`	`v140`
`vs2015_32_v140_xp`	`14 2015`	`x86`	`v140_xp`
`vs2015_32_v140_clang`	`14 2015`	`x86`	`v140_clang_c2`
`vs2015_32_v120`	`14 2015`	`x86`	`v120`
`vs2015_32_v120_xp`	`14 2015`	`x86`	`v120_xp`
`vs2015_32_v110`	`14 2015`	`x86`	`v110`
`vs2015_32_v110_xp`	`14 2015`	`x86`	`v110_xp`
`vs2015_32_v100`	`14 2015`	`x86`	`v100`
`vs2015_32_v100_xp`	`14 2015`	`x86`	`v100_xp`
`vs2017_32_v90`	`14 2015`	`x86`	`v90`
`vs2017_32_v90_xp`	`14 2015`	`x86`	`v90_xp`
`vs2017_32_v80`	`14 2015`	`x86`	`v80`
`vs2015_64`	`14 2015`	`x86_64`	`v140`
`vs2015_64_clang`	`14 2015`	`x86_64`	`v140_clang_c2`
`vs2015_64_xp`	`14 2015`	`x86_64`	`v140_xp`
`vs2015_64_v140`	`14 2015`	`x86_64`	`v140`
`vs2015_64_v140_xp`	`14 2015`	`x86_64`	`v140_xp`
`vs2015_64_v140_clang`	`14 2015`	`x86_64`	`v140_clang_c2`
`vs2015_64_v120`	`14 2015`	`x86_64`	`v120`
`vs2015_64_v120_xp`	`14 2015`	`x86_64`	`v120_xp`
`vs2015_64_v110`	`14 2015`	`x86_64`	`v110`
`vs2015_64_v110_xp`	`14 2015`	`x86_64`	`v110_xp`
`vs2015_64_v100`	`14 2015`	`x86_64`	`v100`
`vs2015_64_v100_xp`	`14 2015`	`x86_64`	`v100_xp`
`vs2015_64_v90`	`14 2015`	`x86_64`	`v90`
`vs2015_64_v90_xp`	`14 2015`	`x86_64`	`v90_xp`
`vs2015_64_v80`	`14 2015`	`x86_64`	`v80`
`vs2015_arm`	`14 2015`	`arm`	`v140`
`vs2015_arm_clang`	`14 2015`	`arm`	`v140_clang_c2`

VS2013¶

cmany compiler alias	project VS version	Target arch.	VS Toolset
`vs2013`	`12 2013`	`(native)`	`v120`
`vs2013_xp`	`12 2013`	`(native)`	`v120_xp`
`vs2013_32`	`12 2013`	`x86`	`v120`
`vs2013_32_xp`	`12 2013`	`x86`	`v120_xp`
`vs2013_64`	`12 2013`	`x86_64`	`v120`
`vs2013_64_xp`	`12 2013`	`x86_64`	`v120_xp`
`vs2013_v110`	`12 2013`	`(native)`	`v110`
`vs2013_v110_xp`	`12 2013`	`(native)`	`v110_xp`
`vs2013_32_v110`	`12 2013`	`x86`	`v110`
`vs2013_32_v110_xp`	`12 2013`	`x86`	`v110_xp`
`vs2013_64_v110`	`12 2013`	`x86_64`	`v110`
`vs2013_64_v110_xp`	`12 2013`	`x86_64`	`v110_xp`
`vs2013_v100`	`12 2013`	`(native)`	`v100`
`vs2013_v100_xp`	`12 2013`	`(native)`	`v100_xp`
`vs2013_32_v100`	`12 2013`	`x86`	`v100`
`vs2013_32_v100_xp`	`12 2013`	`x86`	`v100_xp`
`vs2013_64_v100`	`12 2013`	`x86_64`	`v100`
`vs2013_64_v100_xp`	`12 2013`	`x86_64`	`v100_xp`
`vs2013_v90`	`12 2013`	`(native)`	`v90`
`vs2013_v90_xp`	`12 2013`	`(native)`	`v90_xp`
`vs2013_32_v90`	`12 2013`	`x86`	`v90`
`vs2013_32_v90_xp`	`12 2013`	`x86`	`v90_xp`
`vs2013_64_v90`	`12 2013`	`x86_64`	`v90`
`vs2013_64_v90_xp`	`12 2013`	`x86_64`	`v90_xp`
`vs2013_v80`	`12 2013`	`(native)`	`v80`
`vs2013_32_v80`	`12 2013`	`x86`	`v80`
`vs2013_64_v80`	`12 2013`	`x86_64`	`v80`

VS2012¶

cmany compiler alias	project VS version	Target arch.	VS Toolset
`vs2012`	`11 2012`	`(native)`	`v110`
`vs2012_xp`	`11 2012`	`(native)`	`v110_xp`
`vs2012_32`	`11 2012`	`x86`	`v110`
`vs2012_32_xp`	`11 2012`	`x86`	`v110_xp`
`vs2012_64`	`11 2012`	`x86_64`	`v110`
`vs2012_64_xp`	`11 2012`	`x86_64`	`v110_xp`
`vs2012_arm`	`11 2012`	`arm`	`v110`
`vs2012_arm_xp`	`11 2012`	`arm`	`v110_xp`
`vs2012_v110`	`11 2012`	`(native)`	`v110`
`vs2012_v110_xp`	`11 2012`	`(native)`	`v110_xp`
`vs2012_32_v110`	`11 2012`	`x86`	`v110`
`vs2012_32_v110_xp`	`11 2012`	`x86`	`v110_xp`
`vs2012_64_v110`	`11 2012`	`x86_64`	`v110`
`vs2012_64_v110_xp`	`11 2012`	`x86_64`	`v110_xp`
`vs2012_arm_v110`	`11 2012`	`arm`	`v110`
`vs2012_arm_v110_xp`	`11 2012`	`arm`	`v110_xp`
`vs2012_v100`	`11 2012`	`(native)`	`v100`
`vs2012_v100_xp`	`11 2012`	`(native)`	`v100_xp`
`vs2012_32_v100`	`11 2012`	`x86`	`v100`
`vs2012_32_v100_xp`	`11 2012`	`x86`	`v100_xp`
`vs2012_64_v100`	`11 2012`	`x86_64`	`v100`
`vs2012_64_v100_xp`	`11 2012`	`x86_64`	`v100_xp`
`vs2012_arm_v100`	`11 2012`	`arm`	`v100`
`vs2012_arm_v100_xp`	`11 2012`	`arm`	`v100_xp`
`vs2012_v90`	`11 2012`	`(native)`	`v90`
`vs2012_v90_xp`	`11 2012`	`(native)`	`v90_xp`
`vs2012_32_v90`	`11 2012`	`x86`	`v90`
`vs2012_32_v90_xp`	`11 2012`	`x86`	`v90_xp`
`vs2012_64_v90`	`11 2012`	`x86_64`	`v90`
`vs2012_64_v90_xp`	`11 2012`	`x86_64`	`v90_xp`
`vs2012_arm_v90`	`11 2012`	`arm`	`v90`
`vs2012_arm_v90_xp`	`11 2012`	`arm`	`v90_xp`
`vs2012_v80`	`11 2012`	`(native)`	`v80`
`vs2012_32_v80`	`11 2012`	`x86`	`v80`
`vs2012_64_v80`	`11 2012`	`x86_64`	`v80`
`vs2012_arm_v80`	`11 2012`	`arm`	`v80`

VS2010¶

cmany compiler alias	project VS version	Target arch.	VS Toolset
`vs2010`	`10 2010`	`(native)`	`v100`
`vs2010_xp`	`10 2010`	`(native)`	`v100_xp`
`vs2010_32`	`10 2010`	`x86`	`v100`
`vs2010_32_xp`	`10 2010`	`x86`	`v100_xp`
`vs2010_64`	`10 2010`	`x86_64`	`v100`
`vs2010_64_xp`	`10 2010`	`x86_64`	`v100_xp`
`vs2010_ia64`	`10 2010`	`ia64`	`v100`
`vs2010_ia64_xp`	`10 2010`	`ia64`	`v100_xp`
`vs2010_v100`	`10 2010`	`(native)`	`v100`
`vs2010_v100_xp`	`10 2010`	`(native)`	`v100_xp`
`vs2010_32_v100`	`10 2010`	`x86`	`v100`
`vs2010_32_v100_xp`	`10 2010`	`x86`	`v100_xp`
`vs2010_64_v100`	`10 2010`	`x86_64`	`v100`
`vs2010_64_v100_xp`	`10 2010`	`x86_64`	`v100_xp`
`vs2010_ia64_v100`	`10 2010`	`ia64`	`v100`
`vs2010_ia64_v100_xp`	`10 2010`	`ia64`	`v100_xp`
`vs2010_v90`	`10 2010`	`(native)`	`v90`
`vs2010_v90_xp`	`10 2010`	`(native)`	`v90_xp`
`vs2010_32_v90`	`10 2010`	`x86`	`v90`
`vs2010_32_v90_xp`	`10 2010`	`x86`	`v90_xp`
`vs2010_64_v90`	`10 2010`	`x86_64`	`v90`
`vs2010_64_v90_xp`	`10 2010`	`x86_64`	`v90_xp`
`vs2010_ia64_v90`	`10 2010`	`ia64`	`v90`
`vs2010_ia64_v90_xp`	`10 2010`	`ia64`	`v90_xp`
`vs2010_v80`	`10 2010`	`(native)`	`v80`
`vs2010_32_v80`	`10 2010`	`x86`	`v80`
`vs2010_64_v80`	`10 2010`	`x86_64`	`v80`

VS2008¶

cmany compiler alias	project VS version	Target arch.	VS Toolset
`vs2008`	`9 2008`	`(native)`	`v90`
`vs2008_xp`	`9 2008`	`(native)`	`v90_xp`
`vs2008_32`	`9 2008`	`x86`	`v90`
`vs2008_32_xp`	`9 2008`	`x86`	`v90_xp`
`vs2008_64`	`9 2008`	`x86_64`	`v90`
`vs2008_64_xp`	`9 2008`	`x86_64`	`v90_xp`
`vs2008_ia64`	`9 2008`	`ia64`	`v90`
`vs2008_ia64_xp`	`9 2008`	`ia64`	`v90_xp`
`vs2008_v90`	`9 2008`	`(native)`	`v90`
`vs2008_v90_xp`	`9 2008`	`(native)`	`v90_xp`
`vs2008_32_v90`	`9 2008`	`x86`	`v90`
`vs2008_32_v90_xp`	`9 2008`	`x86`	`v90_xp`
`vs2008_64_v90`	`9 2008`	`x86_64`	`v90`
`vs2008_64_v90_xp`	`9 2008`	`x86_64`	`v90_xp`
`vs2008_ia64_v90`	`9 2008`	`ia64`	`v90`
`vs2008_ia64_v90_xp`	`9 2008`	`ia64`	`v90_xp`
`vs2008_v80`	`9 2008`	`(native)`	`v80`
`vs2008_32_v80`	`9 2008`	`x86`	`v80`
`vs2008_64_v80`	`9 2008`	`x86_64`	`v80`
`vs2008_ia64_v80`	`9 2008`	`ia64`	`v80`

VS2005¶

cmany compiler alias	project VS version	Target arch.	VS Toolset
`vs2005`	`8 2005`	`(native)`	`v80`
`vs2005_32`	`8 2005`	`x86`	`v80`
`vs2005_64`	`8 2005`	`x86_64`	`v80`
`vs2005_v80`	`8 2005`	`(native)`	`v80`
`vs2005_32_v80`	`8 2005`	`x86`	`v80`
`vs2005_64_v80`	`8 2005`	`x86_64`	`v80`