C++ Conformance Roadmap

C++ has long been a mainstay of the computing industry, gaining significant adoption since it came on the scene in the early 1980s.  Yet even with its rich history, it continues to evolve in meaningful ways, now on a faster cadence than we’ve seen in the past.  In fact, this has already been a big year for C++. In April, less than two years after the ratification of C++11, the ISO C++ committee voted to adopt the feature set for the upcoming C++14 standard, which is expected to be done in the next year and which rounds out the C++11 standard with key features like generic lambdas.

We started on the path of C++11 support in Visual C++ with our Visual Studio 2010 release, in which we implemented several C++11 features, including auto and lambda functions.  In Visual Studio 2012, we implemented more of the standard, with support for features like range-based for loops, standard threads, and futures.  And this week we announced Visual Studio 2013 Preview, which as I noted in my blog post on the Preview earlier this week, provides more C++11 support, including capabilities like variadic templates and delegating constructors.  However, as several of you have pointed out in comments on that post, we still have a ways to go in providing full support for C++11.

Today at his Build 2013 conference session on “The Future of C++”, Herb Sutter (an architect on our Visual C++ team and the convener of the ISO C++ standards committee) announced a roadmap for when Visual C++ would implement the complete feature set of the current ISO C++ standard. Because C++14 “completes C++11,” and because as of two months ago we now know C++14’s feature set, we consider draft C++14 to be the current target. I think a particular statement of Herb’s clarifies our approach nicely:

“Visual C++ is targeting C++14, so we’re treating all the new features in C++11 and C++14 as a single bucket of work to do.  We’ll do all of the features, but we’ll work on them in the order that delivers the most value soonest to customers. That means we will implement all of C++11 and C++14, but some high-value C++14 features, such as generic lambdas, should come before others from C++11.”

We will share a more specific timeframe for full conformance as we work through the details, but the following slide from Herb’s talk presented what we know now, listing the features remaining to be added and the approximate order in which we expect them to appear.

There are six “buckets” of remaining language features which together will bring Visual C++ to be a full implementation of not only C++11 and C++14, but also the “C++14 wave” that includes three additional technical specifications also expected to be completed by the ISO C++ committee in the next year: a file system library based on Boost File System version 3 (the previous version 2 is already included in Visual C++ 2012), an initial networking library, and set of language extensions called “Concepts” that enable expressing template constraints and are important to improve template type-checking and deliver greatly improved diagnostics.

The first two buckets of features will be available in Visual C++ 2013 RTM later this year. Herb also announced that, in response to customer requests, the RTM version will also include a few tactical C99 language extensions when compiling C code, so that some popular community libraries (including FFmpeg) will now be able to compile with Visual C++ 2013.

Some subset of the next two buckets, which include some of the most highly anticipated C++14 features (such as generic lambdas and generalized lambda capture) are already being implemented in parallel with our work on Visual C++ 2013 and will ship in a CTP release soon after the Visual C++ 2013 RTM. This CTP will also include an implementation of the async/await feature Microsoft is proposing for the C++ standard; async/await has not only been the number one request from our C++/CX customers for WinRT programming, it is more generally wonderfully useful for any asynchronous code.

Herb also announced today the GoingNative conference, happening in a few months on September 4-6 on Microsoft’s campus in Redmond, WA.  At that event, we will be able to share another progress update with more specific details on the timing and feature set of the upcoming CTP and related work announced in today’s roadmap. The GoingNative conference will include a keynote by Bjarne Stroustrup, the creator of C++, as well as talks by a “who’s who” of the C++ community and active standards committee members: Scott Meyers, Andrei Alexandrescu of Facebook, Chandler Carruth of Google, Stephan T. Lavavej of Microsoft, Sean Parent of Adobe, Michael Wong of IBM (who also represents Canada in ISO C++ and who is the current chairman of OpenMP), and more.  Registration for the conference is now open.

We are delighted to see the continued momentum behind C++ across the industry, and we look forward to continuing to being a part of this important language and community.  For more information and to discuss these efforts, please see the Visual C++ team blog.


Follow me on Twitter at https://twitter.com/ssomasegar.

Comments (28)

  1. MattPD says:

    Really appreciate outlining this roadmap in advance & looking forward to the coming update(s) at the GoingNative — transparency++ 🙂

  2. How many versions of Visual C++ do you expect we are willing to pay for, so that we can use C++11 with Microsoft tooling?!

  3. Jesper says:

    I didn't catch the first 15 minutes of Herb's keynote, but is it correctly understood that everything in the CTP bucket will *not* be added as regular updates to any existing compiler? (That is, we'll get the preview as an update for VC2013, but the final production-quality feature will only be available in VC2014 or later)?

  4. Stephan T. Lavavej MSFT says:

    Jesper: CTPs are alphas. VS 2012 and beyond's Updates are similar to VS 2010 and earlier's Service Packs – they are held to an RTM level of quality so people can install them without fear. We're aware it's potentially confusing to deliver a CTP/alpha as a selectable target in an RTM IDE, when the IDE also applies Updates, but as far as the toolset (compiler+libraries) is concerned, CTPs and Updates are totally different.

    In general, you should not expect new compiler features (and especially new library features) to be delivered in Updates – the potential for breaking stuff is just too high. Note that since VS 2005 (which is as far back as I'm familiar with), we've always shipped new features in new major versions, with one exception: TR1 in VS 2008 SP1 (which also contained MFC enhancements, as I recall). That was a very special exception as the library-only TR1 could be implemented without affecting the rest of the product too much, and there was a 2-year gap between 2008 and 2010.

    The FAQ at the end of my VCBlog post blogs.msdn.com/…/c-11-14-stl-features-fixes-and-breaking-changes-in-vs-2013.aspx (specifically question 4) covers this in more detail.

  5. t@speot.is says:

    @Moondevil This might provide some more information, possibly you won't be paying for an individual release much longer.


    "And what of the more distant future? Well, Microsoft probably won't have Visual Studio 2016, 2017, 2018, and so on. S. Somesegar, corporate Vice President of the Developer Division at Microsoft, said that the long-term ambition was simply to have Visual Studio, updated on a subscription basis."

  6. Jesper says:

    @STL > Note that since VS 2005 (which is as far back as I'm familiar with), we've always shipped new features in new major versions

    Yeah, but note that since VS2005, your team has also been heavily criticized for not shipping new features. 😉

    But in any case, thanks for clarifying. I just wanted to make sure I understood correctly, since last year 's message was quite different.

    I'm guessing this means nothing has changed for bug fixes as well, then? It's still an "unless it's absolutely ridiculousy critical, don't expect to see it fixed unless you wait for, and buy, and upgrade to, the next major version" policy?

  7. RIck Long says:

    @Stephan T. Lavavej – MSFT  Visual Studio 2010 is still in ALPHA. The bug list is never ending and performance is poor at best  Your greatest success has been in lowing developers acceptability standards so unproductive software is praised.

  8. Arunav says:

    This is a really a great news. The importance that C++ has gained and Microsoft commitment towards C++ is really great for all C++ developers.

  9. Weierstrass says:

    A road map is nice and fine but what else will you do to ensure quality, delivery cycles and the roadmap. There is nothing about your commitment toward c++ for customers to ensure your plans.

    – STL will stay the only one on microsofts side to ensure quality of the stl library, i mean wtf, thats gonna be a real mess soon.

    – Team will stay small ?! what to expect….customers gonna be disappointed again…

    +  going native to show commitment

    According to the published road map i think it's safe to say that the Microsoft C++ Compiler is approximately 2-3 years, which equals 2-3 Visual Studio releases, behind the c++ Standard.

    If you don't need/want the new featueres  yesterday, then you can save your money/efforts to convince your boss/finance dude to buy it. Maybe you need ppl/amp or great vectorization/performance support then the world looks differently. For educational purposes i would recommand gcc/mingw + clang.

    According to the comments on Herb's blog, they are hireing compiler devs. So they will improve slowly, i will place my bets on them for c++17 as a early adopter.

    So see you after the c++17 standard passed. And hello Mingw + Qt Creator.

    My feelings go with the people which bought vs2012, and thought they get full conformance via updates. I think this was a life time experience for everyone to check first via a test version like visual c++ express.  

  10. Arkadiy Shapkin says:

    Thank you for new features!

    Does VS2013 support N3276 for decltype?

  11. Herb Sutter says:

    @Jesper: You can find last year's message here, and I hope you'll agree it's exactly what we ended up doing — this is the video clip of the "out of band" announcement, which was about shipping more often than every 2-3 years, which I think we've done: channel9.msdn.com/…/C-11-VC-11-and-Beyond

    Also, there's a balance between agility and stability: Taking breaking changes once a year is pretty aggressive and a big deal for some customers. Even GCC, which just shipped 4.8.1 with the last couple of small C++11 language features for full language conformance, is holding back a conforming standard library until GCC 4.9 because it will cause breaking changes. We would only ship a new language feature in a VS Update if we could be sure it couldn't possibly break existing code; it would be awful if someone installed Update N+1 and found they couldn't build a project that worked fine with Update N. So by default expect no language or library extensions in VS Updates, though we do reserve the right do it anyway but if so it should be viewed as a bonus that was delivered only after very careful analysis.

    @weierstrass: Repeating from my answer to your same comment on my talk video page… Actually we have added library and compiler devs so as to be able to do more implementation work in parallel. When you extrapolate, note that features on the right hand side of the roadmap are 'generally' smaller… however I agree that one thing this roadmap is going to let you do going forward is track our velocity as we deliver against the roadmap. I hope to have more data and details known and shareable at GoingNative in September.

  12. David says:

    @Herb Microsoft not breaking existing code, really, is that a joke ?? What code does Microsoft release that is not broke and since when does Microsoft worry about bugs, performance and security ? As long as it demos well that is all that is important to Microsoft. Us "real" programmers get stuck using your garbage code and botched frameworks to build real apps (which are full of work-arounds to your bugs) to turn out apps for our clients. The BS on this blog is frustrating to read if your coding skills equaled your arrogance we would have so great dev-tools not Visual Studio! Ya'll are pathetic.

  13. Rob G says:

    As far as I can tell, this means that plenty of features won't make it in, even to a Service Pack.

    Are you aware GCC and CLang have both reached Feature Complete?

    I think MS seem to have given up on remaining competitive with their C++. Now I just need to work out how to embed CLang in the Visual Studio IDE successfully and I can start using C++ 11 right now.

    After the debacle of promised updates to C++ in VS2012, I just don't trust MS to deliver on C++ anymore.

  14. Tristan says:

    @Herb If you want to avoid problems from breaking chamges then just implement profiles like .net profiles (target framework). But of course you won't do this, because of lost profits.

    VS team is very arogant, and show his arogance every time, now and in the past (all caps, idiotic colors, lack VS express for desktop, C++ for XP, etc)

    Releasing VS 2013 is HUGE MISTAKE. Nothing is ready for REAL release. New .NET not ready, C#/Roslyn not ready, C++ not ready, Features like 64bit edit and continue or async debug are JUST FIXES. You are selling unfinished (and buggy) product and want to pay another money for finishing missing/broken features. You should cancel VS 2013 and release this as VS 2012.4 Update. By this way, sales of VS 2012 will INCREASE, and you save lot of problems with new version of VS (install, configuration, extensions lack/compatibility, tools compatibility, etc). VS is simply too big and to heavy for annual release.

  15. Me says:


    You don't plan to ship a c++11 compatible compiler any time soon.

    But you do have time to put in a propitiatory async extension to the language?

  16. Alastair says:

    It is very disappointing that Visual C++ users aren't going to get automatically generated move constructors and move assignment operators (“rvalue references v3″) in a RTM version of VS until likely near the end of 2014 (assuming the current VS release schedule is maintained)

    Having to write (and then maintain) move ctors/assignment operators (where you simply just want what should be the default versions) is time consuming and error prone from experience

    I can't help but feel that if MS were serious about the "C++ renaissance" then the next version of Visual Studio would be slated for release so that it could contain more C++11 features (or more resources put on the VC++ team)

  17. Stephan T. Lavavej MSFT says:

    Arkadiy Shapkin: Yes, 2013 Preview fully supports N3276 decltype. It's a long story: As requested by Boost, we attempted to implement N3276 in 2012 Beta. We thought we had gotten it right, but nobody from Boost tested the beta. Eventually, they discovered that one scenario didn't work, preventing result_of from being powered by decltype, and reported it after 2012 RTM was released. This has been fixed in 2013 Preview.

  18. This VC++ 2012 bug still exist in VC++ 2013 svn.boost.org/…/81027

    Without this workaround compiler return this error http://pastebin.com/HQH9AV1a

  19. That is great for all c++ developers but at the same time a bit sad as we would have to wait more for the complete feature set.

  20. Simon Dan says:

    @Herb Our project realy needs the alignment(alignof and alighas) to be implemented. The existing extension gave no replacement for it. a kind of code is like the following:

    // Pseudo code only:

    struct STD_Lay_MyTag


    char marker; // Lead-in member-variables.

    // …;  // Other lead-in member-variables.

    BYTE aObjMem[sizeof(_TplArg_Type)]; // memory to store a _TplArg_Type object with placement-new operator.

    STD_Lay_MyTag(); // Do something and then complete the initialization of the aObjMem.

    ~STD_Lay_MyTag();// Destroy the object in aObjMem.


    Assuming we can't simply use a _TplArg_Type as the member of STD_Lay_MyTag for some reason.

    The problem is we won't know about the alignment information of the _TplArg_Type for sure, For example, _TplArg_Type  can be a template parameter of a template. Moreover, Alignment of the STD_Lay_MyTag itself is also needed to suit to align the _TplArg_Type object and all other members in it.

    Now we need this:

    struct STD_Lay_MyTag


    char marker; // Lead-in member-variables.

    // …;

    alignas(_TplArg_Type) BYTE aObjMem[sizeof(_TplArg_Type)];


    with the existing extension, the only thing we can do is(If the _TplArg_Type is INT32):

    struct STD_Lay_MyTag


    char marker; // Lead-in member-variables.

    // …;

    __declspec(align(4)) BYTE aObjMem[sizeof(INT32)];


    However the following code is not supported because the __declspec(align(#)) and __alignof is only precompiling specifications which leads to the compiling error:

    struct STD_Lay_MyTag


    char marker; // Lead-in member-variables.

    // …;

    __declspec(align(__alignof(_TplArg_Type))) BYTE aObjMem[sizeof(_TplArg_Type)];// align(#) can't accept any symbols than number.


    Using the union is also impossible because the _TplArg_Type may be a non-trivial UDT.

    For now, We have no choice but to keep the codes that needs such specifications in ill-formed temporarily.

  21. blah says:

    Frustrating. It's IE all over again. By the time you catch up, will anyone care?

  22. nice to read something on c++ after long time

  23. Tim says:

    You just made my day!

    "the RTM version will also include a few tactical C99 language extensions when compiling C code, so that some popular community libraries (including FFmpeg) will now be able to compile with Visual C++ 2013."

  24. Craig says:

    Will the C99 stuff be available when building in C mode, i.e. without requiring the usual "ifdef" and "extern" noise? What about C99 support for the "inline" specifier?

  25. Herb Sutter says:

    @Craig: The four C features are available when compiling as C code, yes. We have no specific plans for additional C conformance features such as inline, but will continue to consider them on a case by case basis.

  26. Lee Daniel Crocker says:

    Maybe I'm missing something, but I just downloaded Visual Studio Express 2013 about an hour ago (December 6, 2013), tried to compile a simple C program, and it choked on a mid-block variable declaration, so it appears that either this C compiler is still 14 years out of date, or else I need to somehow enable this feature explicitly?

    Please note that I am now, always have been, and always will be a C programmer. Any reply that even briefly mentions that other language whose name I will not speak (it involves an increment operator) will not be an acceptable answer to my problem.

  27. Eric Battalio says:

    @Lee Daniel Crocker

    Hi Lee, can you give me an example of the code that failed to compile?

  28. Eric Battalio says:


    (When you compile C code, make sure the source file has a ".c" extension or use the /TP compiler switch.)

Skip to main content