CppCon 2026

Every Boost library that graduated to the C++ Standard became invisible. shared_ptr doesn't say "Boost" anywhere in . Boost's greatest successes carry no signature — and that invisibility is killing recruitment. This talk is not a status report. It is an answer to the question: why would I give my best work to a project that erases my name?

We begin with the people. Peter Dimov. Beman Dawes. Howard Hinnant. Marshall Clow. These engineers didn't just write libraries — they defined what production-quality C++ means. We will say their names, show their faces, and then ask the only question that matters for Boost's future: who replaces them? Every technical detail in this talk serves that question.

The answer starts with the peer review process — not as a quality gate, but as an apprenticeship. Boost review doesn't just catch bugs; it forges people. It is the mechanism by which a competent developer becomes a Dimov-class designer, and we will show how that pipeline works today.

Then the technical core. Boost.Unordered's unordered flat map — not as a benchmark, but as a character study. Joaquín López Muñoz sat down, studied SIMD probing, and built something faster than a team at Google. We won't just show a bar chart; we'll show the design decisions — the one that made it fast and the one that almost kept it from shipping. Boost.Intrusive — presented as a magic trick before an explanation. One object. Three containers. Zero allocations. We'll let the audience sit in "wait, that can't work" for ten seconds before we reveal the mechanism. Boost.Decimal — IEEE 754 decimal floating-point that feels like a native type, with portable performance rivaling GCC's non-portable _Decimal extensions. We will also cover Boost.JSON, Boost.URL, Boost.Scope, Boost.Cobalt, and the design thinking behind each.

Networking gets its own act. Beast, Corosio, Capy — presented as a list, they're alphabet soup. Presented as what they are, they become a statement of intent: Boost is building the networking layer the committee has been unable to standardize for fifteen years, and we believe we can ship it. We will show how buffer sequences, stream concepts, and type-erased I/O deliver ABI-stable networking compiled once against an abstract transport, and how this connects to active WG21 proposals for C++29.

We close not with a mailing list URL but with a name. One person — a contributor who submitted their first Boost PR this year, went through review, and is now preparing a library for formal consideration. A person is a door; a URL is a wall. The thesis of this talk is not "Boost is alive." The thesis is that Boost is where you become the engineer you want to be — and every section, from the review process to the mentorship lineage to the fact that one person can build the fastest hash map in the industry, is proof.

For almost 30 years, Visual Studio has been a core part of the C++ developer's toolkit on Windows. This year, we're building on that foundation with investments across three themes: making the IDE faster and more responsive for large codebases, advancing compiler conformance and runtime performance, and integrating AI-powered workflows that help you debug, refactor, and optimize more effectively. Beyond the IDE, we'll show you how AI-powered command-line tools can become a natural part of your development process. This session combines demos and practical guidance so you can get the most out of these tools right away. Come with curiosity, leave with new techniques you can apply immediately.

Notifiers are a critical synchronization primitive in task-parallel programming systems such as Intel TBB and Taskflow, responsible for efficiently sleeping and waking worker threads as tasks become unavailable and available over and over again, directly impacting scheduler throughput and latency. Correctness here is non-negotiable: a single missed wakeup can significantly hamper the performance of an entire program. Yet writing strong unit tests for notifiers is notoriously difficult, because the bugs they target, lost wakeups, spurious wakes, race conditions, are timing-dependent, non-deterministic, and often only surface under specific thread interleavings that are hard to force reliably.

The problem is compounded in practice. Notifier implementations evolve constantly: small algorithmic tweaks, memory ordering changes, and refactors across systems demand a fresh round of carefully constructed tests. This is tedious, expertise-heavy work that takes a lot of time and engineering effort. In this talk, we explore using Large Language Models (LLMs) to automate the generation of the unit tests for notifiers. Specifically, we will demonstrate how LLM-generated tests, guided by proper prompts can systematically stress the two-phase wait protocol across Notifiers in Taskflow. We will show this in a widely used Notifier implemented in Taskflow. We are able to find an undiscovered bug that has been existing in the project.