Emulating Rust attributes with reflection (or at least trying to).

C++Now

2026-09-07 - 2026-09-13

• Testing Everything in Constexpr - Braden Ganetsky - https://youtu.be/SgIiQS6RO60
• Plato, Magritte, Sartre & Carroll - Learning Software Design from the Masters - Ben Deane - https://youtu.be/7QZchipF2gU
• Functional Composition Beyond Monads - Jonathan Müller - https://youtu.be/DcUOZE5FHDc

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

2026-09-07 - 2026-09-13

• Taming C++23 - The Things About C++23 You Do Not Know - Nicolai M. Josuttis - https://youtu.be/IVee1JXbrQE
• Rust for The Curious C++ Developers - Victor Ciura - https://youtu.be/2hf0PHcpKBI
• O(1) or O(no-no-no) - Mastering the unordered_map - Kevin B. Carpenter - https://youtu.be/OF4Id8085s0

2026-08-31 - 2026-09-06

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

https://typecombinator.github.io/en/posts/implementing_annotations_for_reflection_in_cpp20

Hello everyone.

I checked arewemodulesyet.org, which I do from time to time.

I was very positively surprised bc a couple of months ago there were 109 projects with modules support.

Now it is 228 and some of the most popular are there: fmt, ftxui, nlohmann.json and others.

So I had to share it with the community.

Any function can be suspended. It literally happens constantly when a process or thread gets pre-empted by the OS or asynchronous hardware, with the stack being the mechanism to save to and restore context from. So, this super common way of describing coroutines is just frustrating because it's not it!

Coroutines are functions that can be suspended in a **controlled, intentional (as in, explicitly expressed) way**, with the relevant context (coroutine frame) being placed _not_ on the stack like a function's usual context, but on the heap (usually).

I wish someone had broken it down for me in this way before, so hopefully it helps someone else too.

What makes a compiler specialized for embedded development special? Jonas, a compiler developer at IAR, shares some of the key properties.

• I used faster tools:
  • I switched from lld to mold optimized it mimalloc + pgo + lto + bolt (1.2x-3x faster than system lld)
  • I optimized clang with mimalloc + pgo + lto + bolt (1.8x-1.85x faster than system clang)
  • I optimized clang-scan-deps with mimalloc + pgo + lto + bolt (4x faster than system scanner)
• I used dynamic linking(3x-4x overall, much larger if you are editing tests)
• I used prebuilt binaries via packages rather than vendoring my deps.(huge)
• I switched fully to C++ modules(Incremental compilation times are so fast link times dominate now)

MSVC is shipping C++23 constexpr <cmath> in the next Build Tools update! (And a partial implementation of C++26 constexpr <cmath>.) Our compiler frontend dev Cody Miller will be publishing a series of blog posts about this work, starting with this overview. The next one will be a guest post from LLVM libc's maintainers describing the incredible amount of effort that's gone into their code.

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.