Today, we are announcing C++. It is here: en.cppreference.com

interviewer: your C++ class has a copy constructor but no move constructor. what happens here? me: std::move gives a compiler error? interviewer: no, it copies me: fine. i'll check is_move_constructible first interviewer: that returns true me: because it can copy? interviewer: yes me: so the class claims it can move, demonstrates that it can't, and i'm the one failing the interview

Why Great C++ Libraries Fail (And How to Fix That) - Mateusz Pusz - CppCon 2026

Find bugs in our fast URL parser and get rewarded! This URL parser is used everywhere in critical code. C++

std::transform(s.begin(), s.end(), s.begin(), ::tolower); Many C++ codebases have this innocent looking line. But tolower needs input representable as unsigned char. Where char is signed (x86, Apple Silicon), every non-ASCII UTF-8 byte goes negative. Undefined behavior 🧵👇

I built MrDocs, an open-source C++ reference doc generator on the Clang/LLVM AST. Looking for feedback. I'm Alan de Freitas, the lead developer of MrDocs. It's an open-source documentation generator from the C++ Alliance, built on Clang/LLVM. It reads your code from the compiler's AST, so the reference matches what the code actually compiles to. We also presented [a session](https://cppcon2026.sched.com/event/2RT70/mrdocs-reliable-reference-documentation-for-c++-using-the-clang-ast) about it at cppcon this year. I implemented the tool this way because we couldn’t come up with a workflow that understood modern C++ in our Boost libraries. Tools that parse partially tend to misrender or not render concepts, niebloids, SFINAE, overload sets, and deduction guides. MrDocs treats those as first-class: * concept constraints and requires clauses preserved verbatim * niebloids and function objects can be documented as callables * SFINAE and concept overload sets kept together * explicit, noexcept, and consteval specifiers captured * types in detail or private namespaces rendered as implementation-defined The presentation layer is completely encapsulated. Generators support HTML, AsciiDoc, XML, JSON, or any custom format like Markdown and LaTeX, without forking the tool or creating another post-processing workflow. You can also write extensions to apply project conventions to the corpus or define new generators for any use case. The documentation has lots of examples. If you maintain reference docs for a library, I'd appreciate it if you gave it a run (or tell your favorite agent to) and reported back on whether it saves you time, both while writing docs and while reviewing them. First-hand numbers would be especially useful to me. Issues are also always welcome. Site:[ https://www.mrdocs.com](https://www.mrdocs.com/)Repo:[ https://github.com/cppalliance/mrdocs](https://github.com/cppalliance/mrdocs) Happy to answer questions in the comments.

in C++, a condition variable waking you up does not necessarily mean the condition happened. so the correct response to a notification is to open the app and check yourself. finally, concurrency modeled after real life. https://t.co/YoTtI5son4

No, -Wall -Werror Does Not Guarantee Detection of Conditionally Uninitialized Local Variables There seems to be a misconception or lack of clarity about the usage of the compilation flags -Wall and -Werror and their ability to detect uninitialized stack variables. It depends. In this post, I will try to explore this further and explain when and how it is detected, and where it may not detect an uninitialized local variable and hence requires more caution while dealing with it. Consider the following code: int main() { int value; return value; } Compile this code as follows: ~/cpp_26_uninitialised$ g++ -std=c++23 -Wall -Werror test.cpp -o test test.cpp: In function ‘int main()’: test.cpp:4:12: error: ‘value’ is used uninitialized [-Werror=uninitialized] 4 | return value; | ^~~~~ test.cpp:3:9: note: ‘value’ was declared here 3 | int value; | ^~~~~ cc1plus: all warnings being treated as errors So, with the use of the two compilation flags, `-Wall` and `-Werror`, the compilation fails, and you can then take corrective measures to address the uninitialized variable in the code. Strictly speaking, -Wall enables the -Wuninitialized warning, and -Werror turns that warning into an error. However, *this is true only when the variable is uninitialized on every path to its use*, as `value` is here. It doesn't reliably work for a variable that is initialized on some paths and left uninitialized on others. Have a look at the following code: // config_timeout_warning_test.cpp #include #include #include constexpr int default_timeout_ms = 1000; // Reads "timeout_ms= " from a device configuration line. // The bug: when the key is missing, timeout_ms is never assigned. [[gnu::noinline]] int read_timeout_ms(std::string_view config) { int timeout_ms; constexpr std::string_view key = "timeout_ms="; if (const auto pos = config.find(key); pos != std::string_view::npos) { const char* first = config.data() + pos + key.size(); const char* last = config.data() + config.size(); std::from_chars(first, last, timeout_ms); } return timeout_ms; } void open_device(const char* name, std::string_view config) { const int timeout_ms = read_timeout_ms(config); if (timeout_ms >) (config_timeout_warning_test.cpp:31) ==2896379== by 0x4012D3: main (config_timeout_warning_test.cpp:45) ==2896379== Uninitialised value was created by a stack allocation ==2896379== at 0x401166: read_timeout_ms(std::basic_string_view >) (config_timeout_warning_test.cpp:10) ==2896379== logger no timeout configured, using default 1000 ms ==2896379== ==2896379== HEAP SUMMARY: ==2896379== in use at exit: 0 bytes in 0 blocks ==2896379== total heap usage: 2 allocs, 2 frees, 74,752 bytes allocated ==2896379== ==2896379== All heap blocks were freed -- no leaks are possible ==2896379== ==2896379== For lists of detected and suppressed errors, rerun with: -s ==2896379== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) You can see Valgrind is complaining about an uninitialized variable created on the stack: Uninitialised value was created by a stack allocation The reason is that GCC handles the two cases with two different warnings. In the first example, `value` is uninitialized on every path, and `-Wuninitialized` reports it even at `default` \-O0. In the second example, `timeout_ms` is assigned only inside the if block in `read_timeout_ms()`, so it is uninitialized on only one path. That case belongs to `-Wmaybe-uninitialized`, which relies on the data-flow analysis done by the optimizer, so it does not run at `-O0`. If you build the same file at -O2, GCC does catch it: ~/cpp_26_uninitialised$ g++ -std=c++23 -O2 -Wall -Werror config_timeout_warning_test.cpp -o timeout_warning_test config_timeout_warning_test.cpp: In function ‘int read_timeout_ms(std::string_view)’: config_timeout_warning_test.cpp:24:12: error: ‘timeout_ms’ may be used uninitialized [-Werror=maybe-uninitialized] 24 | return timeout_ms; | ^~~~~~~~~~ config_timeout_warning_test.cpp:11:9: note: ‘timeout_ms’ was declared here 11 | int timeout_ms; | ^~~~~~~~~~ cc1plus: all warnings being treated as errors This is still not a guarantee. The result of `-Wmaybe-uninitialized` depends on the optimization level and on how much the optimizer can see, so it can change between GCC versions and between builds. Debug builds are usually at -O0, which is exactly where the warning is missing. If there is anything that I have missed, please comment; I'm happy to be corrected.

RT @straceX: in C++, a condition variable waking you up does not necessarily mean the condition happened. so the correct response to a noti…

The version 5.0 of simdjson is on godbolt so you can check the assembly output of this C++26 code. Link: godbolt.org/z/zf6Mzn4Kx https://t.co/uD8I5dZGx1

University of Waterloo user study on understanding CMake changes Hi everyone, I’m Mattie Nejati, a Ph.D. candidate at the University of Waterloo. I’m conducting a user study on **understanding the impact of changes to CMake build specifications**, and I’d love to invite members of this community to participate. We are evaluating a new approach that aims to help developers identify how a change to a CMake build specification affects the resulting build configuration. The study: * is conducted entirely online; * takes about **one hour**; * involves inspecting changes to CMake build specifications and identifying their impact; and * is open to adults aged **18–64 with any level of experience in CMake, programming, or code review**. You do **not** need to be a CMake expert. We are specifically interested in comparing participants with different levels of experience. You will need a computer with internet access and about **4 GB of free space** to download the files required for the tasks. We will not collect your name. Your email address will only be used for study follow-up and will be stored separately from your study data. Your name or email will not appear in any dataset or publication. The study has received clearance from the **University of Waterloo Research Ethics Board (REB #46621)**. If you’re interested, you can find the consent form, screening questionnaire, and study here: [https://buiscout.cs.uwaterloo.ca/](https://buiscout.cs.uwaterloo.ca/) Thank you very much! And if you know someone else who works with CMake who might be interested, I’d really appreciate you sharing the study with them.

Measuring the Performance of Deterministic Exceptions

Safety and Interoperability with C++ and Rust with Jon Bauman - CppCast 412 / C++ Weekly 553 youtu.be/-gNQiygfpoE https://t.co/XQ7SLZdtL8

Can C++ Become a Memory Safe Language? - C++Now 2026

C++ future at Adobe So if anyone was still curious what happened to Hylo, or where Adobe stands in regards to the whole safety discussion, David Sankel has done a talk at RustConf on the matter, [Zngur: Simplified Rust/C++ Integration](https://youtu.be/Lcl5GMsw86s?is=BGpF1ojxfk_LDUwB). The way Adobe now sees C++ is described on slide 2, at 50 seconds mark.

The complement of true is true, except when it's false

C++ has survived worse than undefined behavior: Linus Torvalds

How do you feel about AI? A common sentiment is that of a loss. This must be especially common among adults. If you are 50 and you have been programming in Python for the last 25 years... it is a shock to find out that an AI agent can code faster than you can. In a sense, it is like having lived on a continent all your life, where you hunted with bows and arrows... and then strange men come in with guns. There is a divergence in society. Some of us have been frustrated by the lack of progress. We don't like what has been happening to our civilization since 1970. We expected lunar bases, rejuvenation cures, cancer cures, space trips... and all we got was Twitter. When the Spanish arrived in America, they immediately found many allies. Cortés landed on the Gulf coast with roughly 500 men, mostly young men (Cortés was 34). They had a handful of horses, crossbows and arquebuses. He had no army to speak of. Yet this small band laid siege to Mexico, helped by 50x or 100x indigenous warriors from various tribes. This all happened within 2 years. It is hard to know exactly what happened, but it seems quite clear that many people were frustrated with the current state of affairs. I feel the same regarding AI. Finally, there is an opening. Don't get me wrong. I don't mindlessly jump on new technologies. I buy paper books, a paper newspaper and I carry paper notebooks. I only got a smartphone in 2018. I still code every day in C++ even though I am constantly told that it is obsolete. But what I care about is progress taken broadly. And I feel that this has been stolen from me. Far from getting cancer cures, the medical system in Quebec is still based on faxes. I feel that the people who love stagnation got enough of what they wanted and I hope that we are at an inflexion point where we finally break free from the oppressive rule of stagnation. Contrary to what you will hear, stagnation does not keep you safe. It puts you at risk. Both individually and collectively. Individually, the lack of progress means that you will die earlier than you could have. Collectively... stagnation makes you vulnerable as the Aztec found out. There is a political angle to the story. In Quebec, a major politician was recently 'caught'. He launched a book just prior to the campaign. And it was revealed that the book had been written by AI. Far from apologizing, the politician came clean and even said that we should use AI more. Much of the political sphere in the West is occupied by people who hold power based on a zero-sum strategy. There is no growth and there is possibly even a decline. It is all a matter of deciding how we share the fixed pie. There is another way, one where everyone gets more, much more. But it requires a different type of politics... one that is less adversarial and more permissive... with the downside that you have less control about who gets what. I think, I hope, that we are at a crossroads where the West will seek abundance, and we will renew with the pre-1970 approach that served us so well. Of course, they are monsters lurking. But I am up for the adventure.

I just spent two hours doing old-school coding in C++ 1. Reading --help for gcc 2. Writing code in NeoVim 3. Reading cppreference for relevant API 4. Copying code snippets from StackOverflow 5. Reading compiler error messages and trying to understand them After 2 hours, I had 10 lines of perfectly working C++

RT @straceX: there’s a point in writing a C++ parser where you start hating whoever designed the file format. in my case that’s also me. i’…

Show HN: Our space game has a built-in RISC-V emulator that runs Linux

there’s a point in writing a C++ parser where you start hating whoever designed the file format. in my case that’s also me. i’d simplify it, but then i read the notes and unfortunately the idiot makes some good points.

you start making a game in C++ and somehow end up writing an allocator, a scripting language and your own file format. there’s still no game. you’re currently too angry about how everyone else handles memory to draw a rectangle.

C++ Insights – See your source code with the eyes of a Compiler

int64_t stops at 9,223,372,036,854,775,807. Factorial overflows it at 21. A 256 bit hash is four of them. An RSA modulus is thirty two Standard C++ has no integer type that grows, so everyone ends up linking a C library 🧵👇

interviewer: what does std::move do? me: moves the object interviewer: no, it’s a cast. it doesn’t actually move anything me: right interviewer: and std::remove? me: removes elements? interviewer: it doesn’t erase them from the container me: okay interviewer: your cv says you know c++ me: yeah well apparently we’re naming things whatever we want

"is this copy really necessary?" asks the C++ engineer in a meeting with 11 people, 8 of whom don’t need to be there and 3 of whom have already had this meeting. the string is 12 bytes.

RT @straceX: "is this copy really necessary?" asks the C++ engineer in a meeting with 11 people, 8 of whom don’t need to be there and 3 o…

EDG C++ front-end goes public

EDG C++ fronted now released as open source

RT @straceX: running ThreadSanitizer on a legacy C++ service is how you become responsible for bugs older than your employment. nothing wa…

running ThreadSanitizer on a legacy C++ service is how you become responsible for bugs older than your employment. nothing was assigned to anyone while we were calling it stable. now you’ve brought evidence into the workplace and ruined everything.

Transcoding UTF-8 to UTF-16 with replacement at gigabytes per second

Boost.Graph 1.95 will be C++17 Dear Boost.Graph community, In two release cycles (Boost release 1.95 in summer 2027) Boost.Graph will be bumped to C++17 😄 This decision follows two polls that did not surface any C++14 user base or demand while identifiying users stuck in C++17: * [Bumping BGL's minimum C++ standard: input wanted on target version #490](https://github.com/boostorg/graph/discussions/490) * [Reddit poll](https://www.reddit.com/r/cpp/comments/1tc1v6x/whats_the_highest_c_standard_you_can_use_with/) This standard version bump will bring benefits for maintenance, API and dependencies reduction: * `if constexpr`, * `constexpr` lambdas, * `[[nodiscard]]`, `[[maybe_unused]]` ... * `std::any` instead of `boost::any` * `std::invoke_result` instead of `boost::result_of` * `...` **We will not be able to guarantee backward compatibility with C++14. Please contact us if you are stuck in C++14.** The GIthub Discussion lives here: [https://github.com/boostorg/graph/discussions/613](https://github.com/boostorg/graph/discussions/613)

Using any C++ library in Godot

love using auto in C++ because the compiler knows the type and i don’t. finally, a healthy working relationship. everyone has a role. it handles the technical details and i tell people i’m a C++ developer.

My CppCon Keynote, “The Address is Not The Place” is now up on YouTube! It’s not often that we get new tiers added to the memory hierarchy of computing, but it sure is fun! You can certainly get ahead of the curve by thinking about the programmatic challenges this will cause (and possibilities it will open up!) in the (very) near future. Hope this talk gets more people thinking about the concept of object “wherency”, and especially what that mental model could look like in various languages. I wrote my demonstrator as a C++26 native implementation; curious to see what others will come up with. Not just limited to C++ either; this concept is easily extended to many other (including runtime!) languages.

the worst part of lock-free C++ is realising a mutex would’ve solved this three days ago. but now there’s an ABA problem, a reclamation scheme and a design doc with my name on it. at this point the main thing we’re protecting is my reputation.

Two processes on one machine need to share a lookup table that changes every second Standard C++ only gives you files. Sockets and shared memory are heavily OS dependent. A database is overkill. There's a portable way 🧵👇

C++ map when you ask for a key that doesn't exist: fine. it does now. https://t.co/2xUtDF7q5X

I just released the next major version of simdjson, the fast C++ JSON parser library. Our last major release was a year ago. What is new? Quite a bit. C++26 static reflection is officially supported. We have key selectors based on compile-time perfect hashing for faster and nicer deserialization. You can now construct a DOM tree (parse) with an unpadded input. We improved the performance of number serialization: files full of numbers parse 8% to 25% faster than version 4.0. We have C++26 annotations, better document streams, and so forth. Read the full article for details and more changes.

RT @straceX: C++ map when you ask for a key that doesn't exist: fine. it does now. https://t.co/2xUtDF7q5X

Show HN: PaperMono, e-ink fridge magnet shopping list with mobile web page

AI abundance unlocks a new generation of programming language that will improve upon their predecessors. I can’t wait for: Java++ TypeScript++ Rust++ Zig++ C++++ Python++ C#++ Go++ OCaml++ Haskell++ Lisp++ Fortran++ COBOL++ Pascal++

You should think about recompiling your C++ programs with GCC 16 and C++26, because it zero-fills your locals Stack variables are not automatically initialised, and that is the root cause of many C++ bugs. That is well known. Hence, it is advised that local or stack variables are always initialised with known values, 0 if not something more meaningful than that. Now, with GCC 16 compiling in C++26 mode (-std=c++26), even uninitialised local variables will be zero-filled. In the post, I have explained how.

Day in the life of a Senior C++ Engineer. 4am: Wake up 4-4:30am: Doomscroll X and charge myself with anxiety to power through the rest of the day 4:30-5am: Exercising 5-5:10am: Meditation 5:10-5:30am: Shower 5:30-6am: Using AI to improve my life 6-6:30am: Playing the guitar (just don't ask my neighbours what they think about me playing guitar at 6 am) 6:30-7:30am: Commute to work. I watch C++ lectures while on the train. 7:30-8am: Breakfast at work 8am-1pm: Work 1-1:30pm: Lunch 1:30-6:30pm: Work 6:30-7:30pm: Commute home. If I still have energy, watch more lectures. Otherwise, some brainrot on YouTube. 7:30-8pm: Home chores and errands 8-8:30pm: Shower 8:30-9pm: Read a book 9pm-4am: Sleep

Double plus in C++ means that you have to repeat every keyword twice https://t.co/otcwLtISQY

I published a game, it is called @valigo. It is coded in C++ with raylib (thanks @raysan5). You can play in your browser at lemire.me/games/valigo/ Link to the source code on the page. https://t.co/MFrdLiMBY0

I've tried "Token Sequence Injection & Modern Macros" and here are my thoughts We had this [poll](https://www.reddit.com/r/cpp/comments/1wlggmv/comment/pb3tkrr/) recently here on r/cpp about community expectations and most desired features in C++29 and in future C++ revisions in general. My answer was: * abbreviated lambdas * algebraic types But I do understand that those features won't hit C++ probably ever. But then we had this [post](https://www.reddit.com/r/cpp/comments/1wq2jld/token_sequence_injection_modern_macros_the_most/) about Token Injection and *Modern Macros*. Wait a minute, modern macros? Never heard about this proposal... And you know that? We probably won't need to wait for neither abbreviated lambdas, nor algebraic types in core C++. We can just add them ourselves using those macros with very little boilerplate. Abbreviated lambdas: [https://godbolt.org/z/a8d9a6f19](https://godbolt.org/z/a8d9a6f19) namespace stdv = std::views; namespace stdr = std::ranges; std::vector points = {{2, 67}, {2, 42}, {3, 666}}; std::vector ys = points | stdv::filter(fun!(p => p.x % 2)) | stdv::transform(fun!(p => p.y)) | stdr::to (); stdr::sort(points, fun!(|l, r| => l.y p.x)); *fun,* isn't? Sum Type: [https://godbolt.org/z/Ecs7TdPYf](https://godbolt.org/z/Ecs7TdPYf) sumtype!(option { some(T), none, }); option opt = some(10); opt = some(22); opt = none; Pattern matching isn't there, but you could imagine something like: // match!( ); auto x = match!(opt, some(x) => { x.call_method() }, none => { 55 } ); Basically you can come up with any syntax you like. When I was exploring the possibilities of this proposal I couldn't shake the feeling that I'm reimplementing parts of the compiler which aren't there for some reason. Like you literally can look at "sumtype" implementation and see that this is basically a parser of arbitrary syntax that you came up with and translating it into C++... Superpowerful and a bit scary... We used to reimplementing some core library features which were missing from the Standard Library for quite some time. `optional, variant, algorithms, smart pointers` and now `async task`. All of that should have been in the Strandard Library from day 1, so that other libraries can use this lingua franca and interoperate with each other. And now we are repeating same thing but on a very different level. Now we are going to allow adding not only library features, but *language* features. I 100% guarantee, that each team will have their own, slightly different syntax for abbreviated lambdas, because it is so much more expressive and terser and more readable. Don't know about you but I always find myself in the situation where I better use plan old for loop instead of structural views/algorithms, because the latter is so much more verbose and unreadable because of lambdas, **especially after you apply clang-format on it**... And now you have: fun!(lhs, rhs => lhs.x lhs.x lhs.x < rhs.x); All of this is perfectly implementable using this Modern Macros proposal in less that 100 lines of code. Committee may have perfectly reasonable arguments of why it is impossible to add abbreviated lambdas into C++, but the community clearly is asking for that feature for ages, and it will be in every future codebase, but with slightly different implementation... On the other hand Rust language do have these macros for ages now, people do abuse them in some very clever ways (select operator from golang, inline HTML, etc.) and the world ain't collapsed. We'll see!

How quickly can you create small strings, per programming language? Python, C++, Rust, Go? Is Bun slower or faster than Node.js? Read my article to find out. https://t.co/EZ6dN4FCkC

in 2025 i stopped writing OCaml and started writing C++ and that was such a good call honestly

There are two main open-source C/C++ compilers. GCC and LLVM. They differ markedly on their policies regarding AI. For GCC, it is a big NO. For LLVM, it is my favourite policy. You can use AI but you get no free pass. You still must understand. https://t.co/l1ZTrztPuP

Token Sequence Injection & Modern Macros: The Most Game-Changing Compile-Time Feature in C++29 (Try it on Compiler Explorer with Barry's Clang Compiler!) Note: This feature is targeted at the C++29 standard and is not actually included in the standard in the original language prepared for the publication. I didn't mention that it was a feature within the standard, and that was that. However, when I asked the AI to translate and organize the text, it made this incorrect edit to the title, thinking it was a good hoke. I apologize for this. introduces Token Sequence Injection (std::meta::token_sequence) and Hygienic Language Macros (__macro) for C++29. It allows building, manipulating, and injecting C++ tokens at compile time with full type-awareness, context inspection, and zero preprocessor bugs! . Token Sequence Injection (std::meta::token_sequence) Instead of string manipulation or macro hacks, code is treated as a sequence of tokens stored in std::meta::token_sequence. Acts as a random-access range (std::meta::size(seq), indexing seq[i] like array, concatenation +, += , == , =) Features Token Interpolation \(...) to splice expressions, variables, or types inside token literals ^^{ ... }. Provides standard utilities like std::meta::id("arg", i) to generate unique identifiers, std::meta::tokenize to turns the string or array of chars to array of tokens with type std::meta::token_sequence, std::meta::stringize to turn array of tokens with type std::meta::token_sequence to string, and std::meta::queue_injection For indirect injection, such as injecting tokens into the current domain or a specific namespace. Quick code example: ``` constexpr auto make_getter(std::meta::info member) -> std::meta::token_sequence { auto name = std::meta::id("get_", name_of(member)); return ^^{ auto \(name)() const -> decltype(\(member)) { return \(member); } }; } ``` 2. Modern Hygienic Macros (__macro) Replacing #define, the new __macro feature runs at consteval time and returns a std::meta::token_sequence injected directly at the call-site: Invoked with !: Called as macro!(...) , check!(a == b). Receives Expression Reflections: Arguments are passed as expression handles (std::meta::info), preserving expression identity, source text, and value categories. Prevents Double Evaluation: Injecting the same un-stored expression twice is a compile-time safety violation, eliminating bugs like MIN(x++, y). Context-Aware (macro_expansion_context()): Can inspect the caller's scope (enclosing function, class, or return type) to validate syntactic and logical rules before injecting. Module & Namespace Friendly: Fully scoped, exportable in modules, and can be class/namespace members. Quick code example : ``` template __macro check(T&&expr) { return ^^{ if (!(\(expr))) { std::println("Check failed: {}", source_text_of(^^expr)); } }; } ``` You can test the full implementation on Compiler Explorer today using Barry Revzin's Clang prototype fork! Paper link: https://open-std.org/JTC1/SC22/WG21/docs/papers/2026/p4380r0.html

Why C++ is so hated!!! I love C++. High level + low level at the same time. But Linus Torvalds don't want C++ in the Kernel, industries hate it, people hate it but why? Why be so angry? Memory management? I mean ok maybe it has problems that I don't even see but why so much hate. For me it's really sad! 😞 Why something so powerful it's so hated. Now I feel "strange" doing projects in C++ because… sometimes I question myself "Why do I write C++ code if people hate it". Can someone explain what is happening and… can I use C++ for fun in peace?

Writing Efficient C++ Code (2013)

C++ is load-bearing to my content here. And my Haskell posting is just a red herring.

myStringStream.str("") Considered Harmful Under C++20 I was recently looking at some (rather old) code that was relying on `std::ostringstream` in a large, performance senstive loop. (Yes, I know using `iostreams` in performance sensitive code is a bad idea, but legacy code exists.) The code was using a common pattern to reset a `ostringstream` instance each time through the loop to avoid having to construct a new instance every time. std::ostringstream oss; for(const MyType & value : values) { oss << value; doSomethingWithString(oss.str()); // Assign an empty string to the internal buffer. This should reset // the size to zero, but keep the allocated buffer. In older code, // you often see this written as oss.str(""). oss.str({}); oss.clear(); // Reset the stream } When migrating the code to C++20, I was excited to use the new `std::ostringstream::view()` getter to skip an unnecessary copy of the `std::string` out of the stream's internal buffer. std::ostringstream oss; for(const MyType & value : values) { oss << value; doSomethingWithStringView(oss.view()); oss.str({}); oss.clear(); } Then I noticed that the `std::ostringstream::str` setter gained an r-value reference overload in C++20. That would let us pre-allocate our string buffer just once. Nice! std::ostringstream oss; { std::string buffer; buffer.reserve(1024); oss.str(std::move(buffer)); } for(const MyType & value : values) { oss << value; doSomethingWithStringView(oss.view()); oss.str({}); oss.clear(); } But wait. That means that the `oss.str({})` call inside the loop is doing the exact same thing. So it's wiping out our allocation every time through the loop! Uh oh. It seems that to clear the internal buffer while keeping its allocation, one must now explicitly call the `const` reference overload of `str()`. const std::string empty; std::ostringstream oss; { std::string buffer; buffer.reserve(1024); oss.str(std::move(buffer)); } for(const MyType & value : values) { oss << value; doSomethingWithStringView(oss.view()); oss.str(empty); oss.clear(); } So if your codebase uses `std::ostringstream`, you might want to do a quick grep for `str("")` and `str({})` to see if the upgrade to C++20 silently caused you to start throwing away your stream buffers over and over again.

This summer, I published the constmap data structure. It is available in Python, C, Rust, Go. (And it is interoperable too!) If you have large unchanging maps from strings to integers, then you should give it a try. It is a common problem in machine learning. In the simplest version, we just expect that all queries are in the set. In the verified version, we check that the key is in the set (at a small extra cost). In the last versions, I have introduced variant that I call 'paired verified' which is about 20% faster than the prior verified variant. And I have also added 'get_many' variants for when you want to query several keys at once (for better performance). In Python, it will use much less memory than a dict, be much faster... and you can store it to disk and share it with your friends who use Go, Rust, C, C++... NOTE: Port to other programming languages are invited. github.com/lemire/fastcon… github.com/lemire/rsconst… github.com/lemire/constmap

HR: do you have experience with C++? ME: yes i am very familiar with the 'goes to' operator https://t.co/pZ8soucXaC

The WG21 2026-09 mailing is now available The WG21 2026-09 mailing is now available The 2026-09 WG21 mailing has been published. You can browse and search the full set of papers, organized by working group, at wg21.org: https://wg21.org/mailing/2026-09/ Source mailing: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/#mailing2026-09

Him: Types just slow me down. I cast everything to void pointers and let the runtime sort it out. Move fast, break things. long pause... Her: Cool. Him: What do you write? Her: C++ static analyzers.

Żmij 1.2 "the proof is in the printf" released with full to_chars implementation, formal verification, improved performance and more [Żmij](https://github.com/vitaut/zmij) 1.2 is out. It started as a shortest round-trip `double`\-to-string converter; this release makes it a full formatter. * Scientific, fixed, general and hex notation with a caller-specified precision, matching `printf`'s `%e`, `%f`, `%g` and `%a`. * `long double`, covering both x87 80-bit extended and IEEE binary128. * Full FP `std::to_chars` implementation that works in C++14 and is [several times faster and smaller](https://vitaut.net/posts/2026/complete-to-chars/) than typical standard library implementations. * The main algorithms are now proved correct in Lean 4. * `float` conversion is about 23% faster than 1.1, `double` is 1-4% faster. * Initial `constexpr` support. Release notes: [https://github.com/vitaut/zmij/releases/tag/v1.2](https://github.com/vitaut/zmij/releases/tag/v1.2)

std::async gives you a future you cannot cancel. jthread gives you a stop_token that a blocked recv() ignores Standard C++ has no networking at all, let alone a way to cancel it 🧵👇

At cppcon WG21 had a whiteboard asking attendees what they would like to have in C++29 some of the ones I remember was: \- contracts \- profiles \- delete moar stuff I'm curious what folks here expect. Also if someone remembers rest of the list, that'd be great.

It's my 2nd week at my new job. But I had 9 days of rest between jobs. Here's how I spent them: 1. Installed Omarchy 2. Took a river walk 3. Read "The Brothers Karamazov" by Fyodor Dostoevsky 4. Cooked a new meal every day 5. Played No Man's Sky 6. Cleaned my apartment 7. Watched several C++ lectures 8. Had a BBQ with my friend 9. Posted on x dot com

Magic statics vs. std::call_once

Met @leostera in London and had a couple of pints with chips at a British pub. This was basically London-style SF. We talked about rent prices, agentic AI, the future of programming, C++, OCaml, and more. Meet your moots irl. https://t.co/218bnHgEwk

Printing UTF-8 strings since C++23 C++23 provides significant better support to print UTF-8 strings. For example: std::string s = "K\u00F6ln: 100\u20AC"; // string ö and € std::println("{}", s); // prints "Köln 100€" // print hexadecimal code units (bytes of the UTF-8 string): std::vector v{std::from_range, s}; std::println("{:n:X}", v); // prints 4B, C3, B6, 6C, 6E, 3A, 20, 31, 30, 30, E2, 82, AC // new format specifier to interpret array of char as string: std::println("{:?s}", v); // prints "Köln 100€" This even works fine on Windows platforms (using I/O streams or std::format() might print garbage with a native Windows compiler on a native Windows platform). See sections 3.2.3 and 4.3.3 of [www.cppstd23.com](http://www.cppstd23.com) .

Resident Evil 4 (GameCube) – complete byte-identical decompilation to C/C++

std::call_once vs. std::async

A clever branch free optimization I'm the developer of memlz which is an extremely fast compression library. We have `char* src, char* dst` for the source and destination buffers and `uint16_t flags` that we prepend bits to one at a time. The inner core looks something like this (pseudo code): flags <<= 1; uint64_t payload = ((uint64_t*)src)[i]; uint16_t hash_index = hash_function(payload); if (hash_table[hash_index] == payload) { flags |= 1; *(uint16_t*)dst = (uint16_t)hash_index; dst += sizeof(uint16_t); } else { *(uint64_t*)dst = payload; hash_table[hash_index] = payload; dst += sizeof(uint64_t); } Depending on a hash comparison we need to output either 2 or 8 bytes, advance `dst` accordingly and prepend either a 1 or a 0 to `flags`. Furthermore, at the end it's required that `hash_table[hash_index] == payload`, so we update `hash_table` in the false-case. Let's benchmark it with 211 MB input so it's uncached: memlz: 2744 MB/s Now let's look at an amazing idea. The output to `*dst` can be rewritten with the ternary operator: `*(uint64_t*)dst = hit ? hash_index : payload;` That turns into a compare instruction (`cmp`) and a conditional move instruction (`cmove`) with no branching: 00007FF742A5A55B mov rax,r10 00007FF742A5A55E cmp rcx,r10 ... 00007FF742A5A56D cmove rax,rdx 00007FF742A5A571 mov qword ptr [rdi],rax The advancement of `dst` is also simple to make branchless, noting that `hit` will turn either 0 or 1: uint64_t hit = (hash_table[hash_index] == payload); dst += 8 - (hit * 6); Now look at updating the `hash_table` where we update it to `payload` only if it differed from `payload`. What we can do is update it unconditionally at the end, and hope that the extra number of unnecessary writes to memory (where it just overwrites the same value) are not too expensive. Final branch-free version: uint64_t payload = ((uint64_t*)src)[i]; uint16_t hash_index = hash_function(payload); flags <<= 1; uint64_t hit = (hash_table[hash_index] == payload); flags |= hit; *(uint64_t*)dst = hit ? hash_index : payload; hash_table[hash_index] = payload; dst += 8 - (hit * 6); Let's benchmark it: memlz: 4269 MB/s I had never believed such gains were possible because I had been micro-optimizing on this for weeks. I later achieved 5070 MB/s. To put it in perspective, uncached memcpy runs at 14000 MB/s here and LZ4 - another popular fast compression library - at 718 MB/s.

libstdc++ has an emergency memory pool because throwing "out of memory" also needs memory. if it can't allocate from that either, it calls std::terminate(). there's out of memory and then there's shut the fuck up out of memory.

-std=c++27

Embedded C++ Just curious how useful the ability to embed C++ as a scripting language into your C++ programs would be? I mean like runtime JIT execution of C++ code in much the same way you might embed Lua, including the ability to restrict/sandbox it as necessary.

I’m actually more excited about the recent release of Endless Legend 2 than WoW: Forever. I’m not 13 anymore. I can afford spending days on grind. I have a job and C++ I need a game I can play for 20 minutes, pause any time, save and continue from exactly where I left. https://t.co/SHslV2dik0

URL parsing is trickier than it seems. Your browser uses the WHATWG URL standard, but your programming language might fail to support it. What about C#? Ada.Url is a WHATWG-compliant .NET binding over Ada, the C++ URL parser used in Node.js, Cloudflare Workers, Datadog and others. On Linux x64 it is about 1.9x faster than System.Uri. And, unlike System.Uri, it is WHATWG URL compliant. github.com/sanamhub/ada-c…

C++26: Trivial infinite loops are no longer undefined behaviour

If you see this post, it’s your sign to write some C++ today

The new C++ std::flat_map can often be several times faster than the good old std::map. I also like how you can relatively easily store and load many std::flat_map instances from disk/network.

Bringing Correctly Rounded Math to Production with LLVM-libc The first part of this series, "MSVC C++23: constexpr cmath with LLVM Libc", was discussed 6 days ago: https://www.reddit.com/r/cpp/comments/1wcx97o/msvc_c23_constexpr_cmath_with_llvm_libc/ This is the promised guest post written by LLVM-libc maintainers Michael Jones and Tue Ly at Google. I had no idea about the recent algorithmic advancements here! (Before anyone asks: Yes, I am self-posting this series as it's published. That's a bit more self-posting than we generally like to see, but `constexpr ` is of wide community interest, and I hope I've built up enough goodwill by moderating this subreddit for years.)

C++ has a vector<bool> surprise. flags[0] is now true. named it copy. it still has access to the original. https://t.co/5oq5K5jY60

CppCon # [Opening 2026 Keynote: Bjarne Stroustrup, prerelease](https://cppcon.org/opening-2026-keynote-bjarne-stroustrup-prerelease/)

In C++, starting with C++23, you can move more of the work at compile time. It makes your code safer and faster. Hashing, strings and so forth can be done at compile time. But the language does not make it as easy as it should be. So we released a C++23 called 'useful_abstractions'. Our goal is to make compile-time programming in C++ more elegant and easier. Even if your AI does the coding, you still want nice code, don't you? One header. No dependencies beyond the standard library. constexprcore.github.io/useful_abstrac… 1/3

Inja is a template engine for modern C++

RT @straceX: C++ has a vector<bool> surprise. flags[0] is now true. named it copy. it still has access to the original. t.co/5oq5K…

A new fast_float release... fast_float is a super fast number parser in C++ (used by GCC, MySQL, your browser...). The latest release adds support for parsing numbers following the JavaScript standard, so things like 05.1 can be accepted (!!!). fastfloat.github.io/fast_float/ https://t.co/SpXZGzLgor

At CppCon today, C++ Alliance CEO Harry Bott made the case that Boost is a guild for our time Not just a code library. A place where engineers learn the craft from the people who built it 🧵👇 https://t.co/LRhSBCW34U

C/C++ devs were winning until the last 4 words

free COMP4300 course - Intro to Game Programming in C++ (Sept 2026)

I'm 32. Solo C++ dev from the UK, based in London. Looking to connect with more C++ devs! https://t.co/12prL7gv9R

RT @straceX: C/C++ devs were winning until the last 4 words

Bjarne Stroustrup opened CppCon 2026 this morning: "Profiles for simplicity and guarantees." Real safety guarantees in C++ with no new dialect, no borrow checker, and for some profiles, no run-time cost. Here's the idea 🧵👇 https://t.co/DuML81NRzB

C++26, with reflection and annotations, gives us some great tools to solve problems. But we're not... quite done yet. This post goes through an interesting problem I ran into recently and what a solution to it might look like. brevzin.github.io/c++/2026/09/14…

High-performance garbage collection for C++

I picked the worst time ever to deep dive into a C++ component called engine

Never bet against C/C++

operator<>: A Dream of Higher-order Metaprogramming Parity

RT @BarryRevzin: C++26, with reflection and annotations, gives us some great tools to solve problems. But we're not... quite done yet. Th…

RT @straceX: A C++ map with string keys doesn’t need a temporary std::string for every lookup. A transparent comparator lets you search us…

What’s New for C++ Developers in Visual Studio 2026 (18.7 – 18.10)

C++20 modules support: 228 projects already available to be consumed 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.

People were surprised that I switched to C++ after 10 years of Haskell and OCaml. But the explanation is simple. I was just doing side quests before I started the main quest.

A C++ map with string keys doesn’t need a temporary std::string for every lookup. A transparent comparator lets you search using string_view directly. useful when your parser already has a view into the input. https://t.co/GJtU3prSO4

Three real tasks where I used AI and it sucked: 1. A client complained about wrong data. I asked an AI agent to fix it, and it thought it was just a special case the service couldn't handle, so my agent wrote some C++ code to fix this. But the real issue was that the downstream service simply sent the wrong data. So the agent's fix was completely useless. 2. I copied logs into an AI agent and asked it to fix the issue. I tried every single suggestion it produced. Nothing worked. Turned out the service output half of its logs in some other location, and I only had half of the picture. 3. Spent hours debugging a nasty SSH issue with VSCode setup. The agent was relentless and constantly offering ideas to fix it, but nothing worked. Wasted hours of my time. I switched to NeoVim and got a working dev setup in 15 minutes. All these issues have a common pattern. AI is a terrible troubleshooter without the full context. Our software systems are not integrated smoothly enough for the agent to just acquire all the needed context. The unknown unknowns are true for AI the same way they're true for humans. All there is is what it is. If you don't provide enough context, you're going to have a miserable time. The problem when you yourself don't have the full context. It's hilarious that the state of the art for AI troubleshooting is running an agent with access to a webcam in front of a mirror.

Why do people on Windows mostly choose Visual Studio?

I joined @nvidia nine years ago today, against the advice of a colleague who said their comp was below market. But I really believed in the mission and the people, so I went. I met @__simt__, Michael Garland, and Jared Hoberock on the C++ committee. I thought they were the smartest people there. I worked at @BerkeleyLab on concurrent and parallel programming paradigms, mostly for SIMD. @__simt__ convinced me that SIMT was a superior model for parallelism. He sold me on a revolutionary new GPU architecture where threads would independently scheduled: Volta, the basis of all modern GPUs. I asked him three times to find me a place at @nvidia. The first two times, he wasn't sure where to place me or if I'd like it. The third time, he had me come in to talk to Chris Lamb (now VP of CUDA). We chatted for two hours and he outlined the role he believed modern C++ would play in CUDA. I came back for an 8 round interview panel. All of the questions were answered with std::atomic. No one was sure what I would be working on. I, a modern C++ person, was placed in the CUDA driver org, which was written almost entirely in C. On my first day, my manager told me I'd be responsible for Thrust and CUB, @nvidia's first two open source libraries. No one had worked on them for a while and there was no product manager. I'd have to do it all. I put together a roadmap and got the libraries back on GitHub. I started sending status updates from CCCL, the CUDA Core Compute Libraries team, which did not exist. Eventually, they let me hire three people to fill out the team. We built libcu++ and abstractions for all the quirky new features being added to our chips to support these AI workloads that seemed to be growing in importance rapidly. After a few years I was asked switch orgs and guide the roadmap for our HPC C++ compiler. Programming languages and models quickly became my role, from stdpar to CUDA-Q to CUDA Python to CUDA Tile to autoresearch. What a ride it's been!

RT @straceX: You can keep a C library and still use C++ to manage its resources. A small wrapper around FILE* removes manual closing from…

MSVC C++23: constexpr cmath with LLVM Libc MSVC is shipping C++23 `constexpr ` in the next Build Tools update! (And a partial implementation of C++26 `constexpr `.) 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.

"Sort descending by the second member" is five words In C++ it's a lambda with two const auto& parameters, an opening brace, a return, a semicolon and a closing brace, every time. Python says it in one expression 🧵👇

WasmBolt — The LLVM Project in your browser 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**](https://www.linkedin.com/in/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](https://github.com/Anutosh21/WasmBolt)