# CppCon Published articles for CppCon. This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles. ## C++ in the Age of AI: Visual Studio at CppCon 2026 DevFeed: [C++ in the Age of AI: Visual Studio at CppCon 2026]() Original publisher: [Read original article]() Author: Augustin Popa Published: 2026-09-14T19:34:43Z Content type: article Language: en Sources: [C++ Team Blog]() Topics: [C++](), [Visual Studio](), [GitHub Copilot](), [Visual Studio 2026](), [build performance](), [MSVC](), [debugging](), [Optimization](), [Refactoring](), [Artificial Intelligence]() Tags: [ai](), [build-optimization](), [build-performance](), [c-plus-plus](), [copilot](), [cppcon](), [debugging](), [github-copilot](), [msvc](), [visual-studio](), [visual-studio-2026]() ### AI overview This companion reading guide covers how Visual Studio 2026 is evolving C++ development with improved code navigation, build and runtime performance, language feature support, debugging, modernization, refactoring, and AI-assisted workflows using GitHub Copilot. ### Source excerpt At CppCon 2026, we shared how Visual Studio is evolving to help you work more effectively with large C++ codebases, improve build and runtime performance, adopt the latest language features, and incorporate AI into your existing workflows. This post is a companion reading guide for our session, C++ in the Age of AI: How Visual [...] The post C++ in the Age of AI: Visual Studio at CppCon 2026 appeared first on C++ Team Blog. ## Microsoft at CppCon 2026 DevFeed: [Microsoft at CppCon 2026]() Original publisher: [Read original article]() Author: Augustin Popa Published: 2026-09-14T00:16:42Z Content type: news Language: en Sources: [C++ Team Blog]() Topics: [C++](), [Microsoft](), [Visual Studio](), [Visual Studio 2026](), [GitHub Copilot](), [MSVC](), [Visual Studio Code](), [Artificial Intelligence](), [Optimization](), [CMake]() Tags: [ai](), [c-plus-plus](), [cmake](), [copilot](), [cppcon](), [github-copilot](), [microsoft](), [msvc](), [optimization](), [safety](), [survey](), [visual-studio](), [visual-studio-2026]() ### AI overview Microsoft's CppCon 2026 sessions cover modern C++ development, including AI-assisted workflows, MSVC, Visual Studio, Visual Studio Code, compiler optimization, C++ safety, and stricter compiler warnings. The article also provides conference logistics, speaker sessions, and a survey invitation. ### Source excerpt Microsoft will be at CppCon 2026 in Aurora, Colorado, which is taking place from September 14 through 18. Join us for talks from Microsoft speakers and colleagues across the C++ community and visit the Microsoft booth Monday through Thursday to meet the team and discuss the tools, technologies, and challenges that matter to you. If [...] The post Microsoft at CppCon 2026 appeared first on C++ Team Blog. ## JSON and C++26 compile-time reflection: a talk DevFeed: [JSON and C++26 compile-time reflection: a talk]() Original publisher: [Read original article]() Author: Daniel Lemire Published: 2026-03-26T00:29:38Z Content type: article Language: en Sources: [Daniel Lemire]() Topics: [C++](), [JSON](), [Library]() Tags: [2025](), [c-plus-plus](), [cppcon](), [json](), [speed](), [standard](), [talk](), [video](), [youtube]() ### AI overview The article announces a CppCon 2025 talk about using C++26 compile-time reflection for high-speed JSON serialization and deserialization. It says the authors extended the simdjson library to test the approach and that the talk video is available on YouTube. ### Source excerpt The next C++ standard (C++26) is getting exciting new features. One of these features is compile-time reflection. It is ideally suited to serialize and deserialize data at high speed. To test it out, we extended our fast JSON library (simdjson) and we gave a talk at CppCon 2025. The video is out on YouTube. Our ... Continue reading JSON and C++26 compile-time reflection: a talk ## Fixing GCC's Implementation of memory\_order\_consume DevFeed: [Fixing GCC's Implementation of memory\_order\_consume]() Original publisher: [Read original article]() Author: Jeff Preshing Published: 2014-11-24T11:25:00Z Content type: article Language: en Sources: [Jeff Preshing]() Topics: [gcc](), [Compiler](), [bug](), [Concurrent Programming](), [Concurrency](), [Arm]() Tags: [arm](), [bug](), [building](), [compiler](), [cppcon](), [gcc](), [process](), [processors](), [thread]() ### AI overview This article examines a bug in GCC 4.9.2's implementation of C++11 memory_order_consume. It explains the expected ordering guarantees, demonstrates the bug with a multithreaded example, and documents verifying and patching the compiler while building an AArch64 cross-compiler. ### Source excerpt As I explained previously, there are two valid ways for a C++11 compiler to implement memory_order_consume: an efficient strategy and a heavy one. In the heavy strategy, the compiler simply treats memory_order_consume as an alias for memory_order_acquire. The heavy strategy is not what the designers of memory_order_consume had in mind, but technically, it's still compliant with the C++11 standard. There's a somewhat common misconception that all current C++11 compilers use the heavy strategy. I certainly had that impression until recently, and others I spoke to at CppCon 2014 seemed to have that impression as well. This belief turns out not to be true: GCC does not always use the heavy strategy (yet). GCC 4.9.2 actually has a bug in its implementation of memory_order_consume, as described in this GCC bug report. I was rather surprised to learn that, since it contradicted my own experience with GCC 4.8.3, in which the PowerPC compiler appeared to use the heavy strategy correctly. I decided to verify the bug on my own, which is why I recently took an interest in building GCC cross-compilers. This post will explain the bug and document the process of patching the compiler. An Example That Illustrates the Compiler Bug Imagine a bunch of threads repeatedly calling the following read function: #include std::atomic Guard(0); int Payload[1] = { 0xbadf00d }; int read() { int f = Guard.load(std::memory_order_consume); // load-consume if (f != 0) return Payload[f - f]; // plain load from Payload[f - f] return 0; } At some point, another thread comes along and calls write: int write() { Payload[0] = 42; // plain store to Payload[0] Guard.store(1, std::memory_order_release); // store-release } If the compiler is fully compliant with the current C++11 standard, then there are only two possible return values from read: 0 or 42. The outcome depends on the value seen by the load-consume highlighted above. If the load-consume sees 0, then obviously, read will return 0. ## My Multicore Talk at CppCon 2014 DevFeed: [My Multicore Talk at CppCon 2014]() Original publisher: [Read original article]() Author: Jeff Preshing Published: 2014-10-24T10:40:00Z Content type: article Language: en Sources: [Jeff Preshing]() Topics: [C++](), [Game engine](), [Compiler](), [MSVC](), [x86]() Tags: [c-plus-plus](), [compiler](), [concurrent](), [cppcon](), [development](), [games](), [gcc](), [microsoft](), [talk](), [x86]() ### AI overview The article recaps a CppCon 2014 talk about how Ubisoft Montreal develops multicore game engines using threading patterns, custom concurrent objects, and atomic operations. It compares portable game-engine atomics with the low-level C++11 atomic library and discusses compiler ordering behavior on x86, including Microsoft's compiler and the risks associated with GCC or Clang. ### Source excerpt Last month, I attended CppCon 2014 in Bellevue, Washington. It was an awesome conference, filled with the who's who of C++ development, and loaded with interesting, relevant talks. It was a first-year conference, so I'm sure CppCon 2015 will be even better. I highly recommend it for any serious C++ developer. While I was there, I gave a talk entitled, "How Ubisoft Montreal Develops Games For Multicore - Before and After C++11." You can watch the whole thing here: To summarize the talk: At Ubisoft Montreal, we exploit multicore by building our game engines on top of three common threading patterns. To implement those patterns, we need to write a lot of custom concurrent objects. When a concurrent object is under heavy contention, we optimize it using atomic operations. Game engines have their own portable atomic libraries. These libraries are similar to the C++11 atomic library's "low level" functionality. Most of the talk is spent exploring that last point: Comparing game atomics to low-level C++11 atomics. There was a wide range of experience levels in the room, which was cool. Among the attendees were Michael Wong, CEO of OpenMP and C++ standard committee member, and Lawrence Crowl, who authored most of section 29, "Atomic operations library," in the C++11 standard. Both of them chime in at various points. (I certainly wasn't expecting to explain the standard to the guy who wrote it!) You can download the slides here and grab the source code for the sample application here. A couple of corrections about certain points: Compiler Ordering Around C++ Volatiles At 24:05, I said that the compiler could have reordered some instructions on x86, leading to the same kind of memory reordering bug we saw at runtime on PowerPC, and that we were just lucky it didn't. However, I should acknowledge that in the previous console generation, the only x86 compiler we used at Ubisoft was Microsoft's. Microsoft's compiler is exceptional in that it does not perform those particular ins