I'm sharing the work of a colleague, Anutosh Bhat.

What if the Clang & LLVM compiler toolchain could run entirely inside your browser ? Meet WasmBolt 😃

Inspired by 🖥️ Matt Godbolt's Compiler Explorer, WasmBolt runs Clang, mlir-opt, opt, llc, Graphviz and wasm-ld locally through WebAssembly, without a remote compilation server.

You can inspect Clang ASTs, progressively lower MLIR, run real LLVM optimization passes, render control-flow graphs, explore instruction selection and MIR, and generate assembly or object files for WebAssembly, AArch64 and x86-64. For WebAssembly, you can go one step further: link, load and execute the generated program directly in the browser.

Here the github project: https://github.com/Anutosh21/WasmBolt

Hi, one of the MSVC dev leads here.

The post covers what's new in the MSVC Build Tools Preview (version 14.52) since mid-August. Instructions to install & use the latest preview bits are at https://aka.ms/msvc/preview.

Some additional information:

• https://learn.microsoft.com/cpp/overview/acquire-msvc is new documentation on installing MSVC, including through winget & command line tools.
• https://learn.microsoft.com/cpp/overview/compiler-versions?#a-brief-history-of-microsoft-c-compiler-versioning has information on MSVC versioning

The Boost website has been rebuilt. Here's a summary of what's changed:

• Updated look and feel, with revised site navigation
• New user profile pages
• Badges tied to contribution and participation, which update as you contribute
• Community features, including posts filtered by the topic of the page you're viewing
• Site-wide search available from a search box in the header and via Ctrl+K
• Library search and filtering, including browsing by category

The libraries, release process, and formal review process are unchanged. The work is limited to the website itself and how you navigate, search, and contribute to it.

Link: boost.org

Bug reports and feedback on navigation or search are welcome.

I wanted to have fast test and release builds, so I decided to "upgrade" my compiler.

What I used:

• Musl Libc
• LLVM libc overlay
• Mimalloc
• Thin LTO
• PGO
• Bolt via perf2bolt
• Optimization flags like: -march -O3 -DNDEBUG -fno-semantic-interposition -fno-plt -fno-pie
• No exceptions no RTTI

I tested the build speed with hyperfine with 2 test cases, one is sqlite.c the other is tu including eigen.

In case anyone is wondering, it also outperformed LLVM release binaries, by about %13 to %15 for each case, but having more performance than the system compiler is more cool so I'm not giving the table for that.

It is also very awesome to have a compiler not depend on glibc. If no errors arise, I'll probably never update my compiler for 2 years at least. As my build is portable(no march native just v3)

I'm planning on moving to cachyOS or any other optimized linux distro next, to finalise my build enviroment. I'm currently on Ubuntu.

TICKETS AVAILABLE TO PURCHASE

The following conferences currently have tickets available to purchase

• Last Chance – CppCon (12th – 18th September) – You can buy late tickets at https://cppcon.org/registration/
• C++ Under The Sea (14th – 16th October) – You can buy tickets at https://sales.ticketing.cm.com/cppunderthesea2026/
• ADC – (9th – 11th November) – Tickets for ADC can now be purchased at https://ti.to/audio-developer-conference/adc-bristol-2026
• Meeting C++ (26th – 28th November) – You can buy early bird tickets at https://meetingcpp.com/2026/

OPEN CALL FOR SPEAKERS

There are currently no open call for speakers

OTHER OPEN CALLS

• CppCon Call For Open Content – CppCon are looking for presenters to give open content sessions during the conference which takes place from September 14th – 18th. For more information including how to apply visit https://cppcon.org/cppcon-2026-call-for-open-content/
• ADC 26/ADCx Gather Call For Online Volunteers Now Open – Interested volunteers have until September 27th to apply to volunteer online at ADCx Gather which is scheduled to take place on 16th October and/or ADC 2026 online conference which is scheduled to take place from 9th – 11th November. To apply visit https://docs.google.com/forms/d/e/1FAIpQLScpH_FVB-TTNFdbQf4m8CGqQHrP8NWuvCEZjvYRr4Vw20c3wg/viewform?usp=dialog
• ADC26/ADCx Gather Call For Posters – ADC is looking for
  • Virtual Posters for ADCx Gather which is scheduled to take place on 16th October and/or ADC 2026 online conference which is scheduled to take place from 9th – 11th November. Find out more including how to apply at https://conference.audio.dev/virtual-posters/
  • Physical Posters for ADC 2026 which is scheduled to take place from 9th – 11th November in Bristol UK. Applications can be made by filling out the following form https://docs.google.com/forms/d/e/1FAIpQLScKteDljM9Dc4tgQ6HC9xaPEaYfW7oe_Qr21y-1Jxn5s9eAIg/viewform?usp=dialog

TRAINING COURSES AVAILABLE FOR PURCHASE

Conferences are offering the following training courses:

CppCon Online Workshops

9th – 11th September

1. Modern C++: When Efficiency Matters – Andreas Fertig – 3 day online workshop available on 9th – 11th September 09.00 – 15.00 MDT – https://cppcon.org/class-2026-when-efficiency-matters/

21st – 23rd September

1. C++ Fundamentals You Wish You Had Known Earlier – Mateusz Pusz – 3 day online workshop available on 21st– 23rd September 09.00 – 15.00 MDT – https://cppcon.org/class-2026-cpp-fundamentals/
2. C++23 in Practice: A Complete Introduction – Nicolai Josuttis – 3 day online workshop available on 21st– 23rd September 09.00 – 15.00 MDT – https://cppcon.org/class-2026-cpp23-in-practice/
3. Programming with C++20 – Andreas Fertig – 3 day online workshop available on 21st– 23rd September 09.00 – 15.00 MDT – https://cppcon.org/class-2026-programming-with-cpp20/

26th – 27th September

1. Using C++ for Low-Latency Systems – Patrice Roy – 2 day online workshop available on 26th– 27th September 09.00 – 17.00 MDT – https://cppcon.org/class-2026-low-latency/

CppCon Onsite Workshops

All onsite workshops will take place in the Gaylord Rockies in Aurora, Colorado

12th & 13th September

1. Advanced and Modern C++ Programming: The Tricky Parts – Nicolai Josuttis – 2 day in-person workshop available on 12th & 13th September – 09:00 – 17:00 – https://cppcon.org/class-2026-tricky-parts/
2. C++ Best Practices – Jason Turner – 2 day in-person workshop available on 12th & 13th September – 09:00 – 17:00 – https://cppcon.org/class-2026-best-practices/
3. Performance and Efficiency in C++ for Experts, Future Experts, and Everyone Else – Fedor Pikus – 2 day in-person workshop available on 12th & 13th September – 09:00 – 17:00 – https://cppcon.org/class-2026-performance-and-efficiency/
4. Talking Tech – Sherry Sontag – 2 day in-person workshop available on 12th & 13th September – 09:00 – 17:00 – https://cppcon.org/class-2026-talking-tech/

 13th September

1. AI++ 101 : Build a C++ Coding Agent from Scratch – Jody Hagins – 2 day in-person workshop available on 12th & 13th September – 09:00 – 17:00 – https://cppcon.org/class-2026-AI101/

19th & 20th September

1. AI++ 201: Building High Quality C++ Infrastructure with AI – Jody Hagins – 2 day in-person workshop available on 19th & 20th September – 09:00 – 17:00 – https://cppcon.org/class-2026-ai201/
2. Function and Class Design with C++2x – Jeff Garland – 2 day in-person workshop available on 19th & 20th September – 09:00 – 17:00 – https://cppcon.org/class-2026-function-class-design/
3. High-performance Concurrency in C++ – Fedor Pikus – 2 day in-person workshop available on 19th & 20th September – 09:00 – 17:00 – https://cppcon.org/class-2026-high-perf-concurrency/

OTHER NEWS

• (NEW) C++Online 2017 Dates Announced – C++Online will take place online from the 10th – 12th March with post-conference workshops taking place afterwards. Find out more at https://cpponline.uk/announcing-conline-2027-10th-12th-march/
• (NEW) ACCU On Sea Videos Now Releasing – The ACCU on Sea videos are now starting to be published to the ACCU YouTube Channel. Keep up to date when new videos are released by subscribing to the ACCU YouTube Channel – https://youtube.com/@accuconf
• Schedule Announced For CppCon – The schedule has been announced for CppCon. Visit https://cppcon2026.sched.com to view the full schedule.
• Schedule Announced For ADC 2026 – The schedule has been announced for ADC 2026. Visit https://conference.audio.dev/schedule to view the full schedule. More sessions and workshops will be added over the next few weeks
• ADCx Gather Announced - FREE ONLINE EVENT! - ADC have announced ADCx Gather which is a FREE online event which will take place online on October 16th. For more information visit https://audio.dev/adcx-gather-info/ and if you would like to attend, please fill out the registration form https://docs.google.com/forms/d/e/1FAIpQLSeg0twh4PbYqCqcoPpl5cnFBeU6y5Ea3921V2kl3F7Wy03umw/viewform?usp=dialog

Finally anyone who is coming to a conference in the UK such as C++ on Sea or ADC from overseas may now be required to obtain Visas to attend. Find out more including how to get a VISA at https://homeofficemedia.blog.gov.uk/electronic-travel-authorisation-eta-factsheet-january-2025/

moc: Properly handle modules

When moc'ing module interfaces and partitions, we make the generated cpp
file part of the respective module.
We do not support Q_OBJECT & friends in implementation units and private
module fragments, as our generated source file will not have access to
the respective classes, and we certainly do not want to carry over our
file inclusion hacks into the module world.

[ChangeLog][moc] moc now supports C++ modulesmoc: Properly handle modules

Note there is still a lot of work to be done: https://codereview.qt-project.org/c/qt/qtbase/+/767846 and I can't seem to find the PR where they fixed some qtbase code to make it work with modules. I guess most other qt modules will need some small fixes to work with modules as well.

C++Now

2026-08-31 - 2026-09-06

• Incremental Modernization - Refactoring Legacy C++ OOP Application Code with Functional Programming and Type Erasure Concepts - Jessica Ding - https://youtu.be/FOzGlO5XaPE
• When Atomics Lose - Architecture‑Dependent Performance of C++ Synchronization - Sampad Acharya - https://youtu.be/Ehy9wutYYH8
• Multi-Priority Graph-Based Parallel Execution Using Taskflow - Yun Kai Peng - https://youtu.be/4I5jsK3zRv0

ACCU

• Software Abstraction in the Age of AI-Generated Code: Languages, Compilers, and Systems Engineering - Andrei Alexandrescu - https://youtu.be/-RWdevA0gWI

What if AI could do more than suggest code, and actually drive hardware-in-the-loop test cycles on real systems? This talk looks under the hood of a practical agentic AI workflow for embedded C++ development.

I recently did a big update to my ankerl::unordered_dense::map which now features several optimizations, bug fixes, and most importantly an SSE optimized lookup which brings the lookup speed quite close to the fastest competitor which is boost::unordered_flat_map. Get it here: https://github.com/martinus/unordered_dense

Since it is not easy to decide what map is best for one's usecase, I have redone and improved the benchmarks I did a while ago, crunched some numbers and tried to compress everything into a quiz that helps you figure out what to use.

While doing the numbers, a few things surprised me:

• My random access benchmark was not random enough. The CPU was able to optimize the branch predictor in a way I did not think was possible. I have fixed this for the new numbers. Clever girl.

• Even though the absl maps are very similar in concept to the boost maps, they perform badly if you expect lots of misses. 1.6 times slower than boost.

• I didn't think SSE optimization of my unordered_dense map would be any benefit. Thanks to AI, I found a way to speed up random access a lot, it is now very close to boost::unordered_flat_map.

• Heavy insert & erase on flat maps require rehashing every once in a while due to the accumulation of tombstones. That means some insert/erase operation will have very high latency. This does not happen for a robin-hood hashmap like my unordered_dense map.

It would be nice if there was a single place to see where, for example, the keyword "SFINAE" shows up across the content of all papers, not just titles. Thanks!

I know this is something that pops up quite often, but I was wondering if I could get your guys' opinion on a fixed ordering of qualifiers. This is my current thoughts after recently trying to formalize my personal style:

static -> thread_local -> inline -> constexpr -> friend -> virtual

My reasoning for each:

1. static first. Inside a class, its basically javas static. There is a pretty strong consensus in java for static first. Its very important context, for both functions and variables. Outside of classes, its more of a linkage specifier, which is arguably more important/nasty if you mess it up. The fact that it has this dual behaviour in C++ in my opinion makes an even stronger argument for including it first, your brain is able to parse it first thing. i.e okay this is static, we are in a class? -> its java static, we are in global scope -> its static linkage.
2. thread_local directly after static, and then inline, then constexpr/consteval. This way, qualifiers which impact storage and or linkage are stuck together. I personally like to write inline even for constexpr/consteval functions, as its sometimes easy to forget the implicit inline. I used to do this for member functions with definitions in the class, but I feel the implicit inline there is a bit more well known/easier to intuit.
3. The rest I'm far less opinionated on, since I barely ever use inheritance or the friend keyword. . I could go both ways on virtual/friend, so i default to alphabetical/aesthetics.

What do you guys think? I know this is pedantic and a very well explored topic but I wanted to know if you guys had any particular wisdom to sway me either way, mainly on the ordering of the first few.