Welcome to SwedenCpp
Latest blogs, videos and releases in one stream
Wednesday, March 11, 2026
Performance and Safety in C++ Crash Course - Jason Turner - C++Online 2026 Workshop Preview🎥CppOnline
Workshop Preview: Essential GDB and Linux System Tools - Mike Shah - C++Online 2026🎥CppOnline
Seamless Static Analysis with Cppcheck: From IDE to CI and Code Review - Daniel Marjamäki🎥CppCon
Python Templates for Neural Image Classification and Spectral Audio Processing - Part 1🎥audiodevcon
How do compilers ensure that large stack allocations do not skip over the guard page?Don't take steps that are too large. The post How do compilers ensure that large stack allocations do not skip over the guard page? appeared first on The Old New Thing .📝The Old New Thing
Workshop Preview: C++ Software Design - Klaus Iglberger - C++Online 2026🎥CppOnline
From Hello World to Real World - A Hands-On C++ Journey from Beginner to Advanced - Workshop Preview🎥CppOnline
Introduction to Malware Development using C++ [Lightning Talk]🎥CoreCpp
Qt Widgets to Qt Quick, An Application Journey Part 4Completing the Software Architecture Transition📝Qt Blog
Qt World Summit 2026: Going VirtualQt World Summit 2026 is moving to a virtual format. After careful evaluation with key stakeholders, we've decided to transition the event from an in-person gathering in Germany to an online experience.📝Qt Blog
Corosio Beta: Coroutine-Native Networking for C++20Corosio Beta: Coroutine-Native Networking for C++20 The C++ Alliance is releasing the Corosio beta, a networking library designed from the ground up for C++20 coroutines. We are inviting serious C++ developers to use it, break it, and tell us what needs to change before it goes to Boost formal review. The Gap C++20 Left Open C++20 gave us coroutines. It did not give us networking to go with them. Boost.Asio has added coroutine support over the years, but its foundations were laid for a world of callbacks and completion handlers. Retrofitting coroutines onto that model produces code that works, but never quite feels like the language you are writing in. We decided to find out what networking looks like when you start over. What Corosio Is Corosio is a coroutine-only networking library for C++20. It provides TCP sockets, acceptors, TLS streams, timers, and DNS resolution. Every operation is an awaitable. You write co_await and the library handles executor affinity, cancellation, and frame allocation. No callbacks. No futures. No sender/receiver. auto [socket] = co_await acceptor.async_accept(); auto n = co_await socket.async_read_some(buffer); co_await socket.async_write(response); Corosio runs on Windows (IOCP), Linux (epoll), and macOS (kqueue). It targets GCC 12+, Clang 17+, and MSVC 14.34+, with no dependencies outside the standard library. Capy, its I/O foundation, is fetched automatically by CMake. Built on Capy Corosio is built on Capy, a coroutine I/O foundation library that ships alongside it. The core insight driving Capy’s design comes from Peter Dimov: an API designed from the ground up to use C++20 coroutines can achieve performance and ergonomics which cannot otherwise be obtained. Capy’s IoAwaitable protocol ensures coroutines resume on the correct executor after I/O completes, without thread-local globals, implicit context, or manual dispatch. Cancellation follows the same forward-propagation model: stop tokens flow from the top of a coroutine chain to the platform API boundary, giving you uniform cancellation across all operations. Frame allocation uses thread-local recycling pools to achieve zero steady-state heap allocations after warmup. What We Are Asking For We are looking for feedback on correctness, ergonomics, platform behavior, documentation, and performance under real workloads. Specifically: Does the executor affinity model hold up under production conditions? Does cancellation behave correctly across complex coroutine chains? Are there platform-specific edge cases in the IOCP, epoll, or kqueue backends? Does the zero-allocation model hold in your deployment scenarios? We are inviting serious C++ developers, especially if you have shipped networking code, to use it, break it, and tell us what your experience was. The Boost review process rewards libraries that arrive having already faced serious scrutiny. Get It git clone https://github.com/cppalliance/corosio.git cd corosio cmake -S . -B build -G Ninja cmake --build build Or with CMake FetchContent: include(FetchContent) FetchContent_Declare(corosio GIT_REPOSITORY https://github.com/cppalliance/corosio.git GIT_TAG develop GIT_SHALLOW TRUE) FetchContent_MakeAvailable(corosio) target_link_libraries(my_app Boost::corosio) Requires: CMake 3.25+, GCC 12+ / Clang 17+ / MSVC 14.34+ Resources Corosio on GitHub – https://github.com/cppalliance/corosio Corosio Docs – https://develop.corosio.cpp.al/ Capy on GitHub – https://github.com/cppalliance/capy Capy Docs – https://develop.capy.cpp.al/ File an Issue – https://github.com/cppalliance/corosio/issues📝The C++ AllianceTuesday, March 10, 2026
It’s Dangerous to Go Alone: A Game Developer Tutorial - Michael Price - CppCon 2025🎥CppCon
A snappy answer when asked about dressing casually at IBMOh, this old thing? The post A snappy answer when asked about dressing casually at IBM appeared first on The Old New Thing .📝The Old New Thing
Typing++ for C++ - Making the Compiler Do the Thinking :: Chris Gearing🎥CoreCpp
The Way of TDD@media only screen and (max-width: 600px) { .body { overflow-x: auto; } .post-content table, .post-content td { width: auto !important; white-space: nowrap; } } This article was adapted from a Google Tech on the Toilet (TotT) episode. You can download a printer-friendly version of this TotT episode and post it in your office. By Bartosz Papis Test-Driven Development (TDD) is the practice of working in a structured cycle where writing tests comes before writing production code . The process involves three steps, sometimes called the red-green-refactor cycle : Write a failing test Make the test pass by writing just enough production code Refactor the production code to meet your quality standards Research shows TDD has several benefits : it improves test coverage, reduces the number of bugs, increases confidence, and facilitates code reuse. This practice also helps reduce distractions and keep you in the flow. TDD also has its limitations and is not a silver bullet! See the Wikipedia article about TDD for a detailed explanation and references. Here is a short practical example. Assume you need to modify the following voting algorithm to support the option for voters to abstain: def outcome(ballots): if ballots.count(Vote.FOR) > len(ballots) / 2: return "Approved" return "Rejected" 1. We start by writing a failing test - as expected, the test doesn't even compile: def test_abstain_doesnt_count(self): self.assertEqual(outcome([Vote.FOR, Vote.FOR, Vote.AGAINST, Vote.ABSTAIN]), "Approved") 2. We fix the compilation error by including the missing enum option: class Vote(Enum): FOR = 1 AGAINST = 2 ABSTAIN = 3 Now that the test compiles, we fix the production code to get all tests passing: def outcome(ballots): if ballots.count(Vote.FOR) > (len(ballots) - ballots.count(Vote.ABSTAIN)) / 2: return "Approved" return "Rejected" 3. We now refactor the code to improve clarity, and complete an iteration of the TDD cycle: def outcome(ballots): counts = collections.Counter(ballots) return "Approved" if counts[Vote.FOR] > counts[Vote.AGAINST] else "Rejected" Learn more about TDD in the book Test Driven Development: By Example , by Kent Beck.📝Google Testing Blog
REST Better with the Support of OpenAPI in Qt 6Some of you are following our works to improve connectivity of Qt-based apps. For example, in this blogpost we explained enhacements in the Qt's network stack for more efficient use of RESTful APIs starting with Qt 6.7. So, it might sound we are done with REST. Why bother about OpenAPI then? Well, while around 70% of all web services run on REST, around 20-30% of them use code generated from OpenAPI specification. How could Qt leave that out without helping our users to code less and create more? The new Qt 6 OpenAPI module will become available with Qt 6.11 as a Technical Preview. The module introduces the Qt 6 OpenAPI generator, which generates Qt HTTP clients using Qt Network RESTful APIs. It is important to note here that an OpenAPI generator for Qt 5 has been originally developed by the OpenAPI community. We took it into Qt 6, refactored it, and extended it. In this blog post, you will learn about the new OpenAPI generator in Qt 6 and see how the new module can be used to implement a simple, Qt-based ChatGPT client application using specification of its API provided in the OpenAPI format.📝Qt Blog
Upgrades to Frontier LLMs – Qt AI Assistant 0.9.9 for Qt Creator Released!To make it easier to access the latest AI capabilities, we have updated pre-configured LLMs to newer variants.📝Qt Blog
ADC Japan 2026 Tickets Available Now🎥audiodevconMonday, March 9, 2026
Cache Me Maybe: The Performance Secret Every C++ Developer Needs - Michelle D'Souza - CppCon 2025🎥CppCon
C++ Weekly - Ep 523 - Why I'm Still Using std::cout (on this channel)🎥Jason Turner
The fine print giveth and the bold print taketh away: The countdown timerThink fast, no pressure. The post The fine print giveth and the bold print taketh away: The countdown timer appeared first on The Old New Thing .📝The Old New Thing
Learning to read C++ compiler errors: Ambiguous overloaded operatorLook for the conflicting definitions to see where they are coming from. The post Learning to read C++ compiler errors: Ambiguous overloaded operator appeared first on The Old New Thing .📝The Old New Thing
C++23 Tools you will actually use :: Alex Dathskovsky🎥CoreCpp
Engineering Practices Break Music Interaction - (but Can Also Fix It) - Franco Caspe - ADC 2025🎥audiodevcon
TCP Connections With DAP Debuggers, Different Formats for Numeric Values, and More in CLion 2026.1 EAPThe Early Access Program (EAP) for CLion 2026.1 is nearing its end, bringing a range of improvements to debugging capabilities, build tools, project formats, and more. This post is a brief overview of what is already available in the latest EAP build. As always, EAP builds are free to use, so you can explore all […]📝CLion : A Cross-Platform IDE for C and C++ | The JetBrains Blog
StockholmCpp 0x3C: Intro, event host presentation, C++ news and the quiz🎥SwedenCpp
Measure Twice, Optimize Once🎥Matt GodboltSunday, March 8, 2026
Prefix sums at tens of gigabytes per second with ARM NEONSuppose that you have a record of your sales per day. You might want to get a running record where, for each day, you are told how many sales you have made since the start of the year. day sales per day running sales 1 10$ 10 $ 2 15$ 25 $ 3 5$ 30 … Continue reading Prefix sums at tens of gigabytes per second with ARM NEON📝Daniel Lemire's blog
Abstraction Addiction: When Good C++ Design Goes Bad :: Adi Ben David🎥CoreCpp
Binary compatibility 100 - Marc Mutz - Meeting C++ 2025🎥MeetingCppSaturday, March 7, 2026
Lecture 16. Allocators part II: Memory Resources and PMR (MIPT, 2025-2026).🎥Konstantin Vladimirov
Try blocks on functions - C++ Safety part 10 of n | Modern Cpp Series Ep. 243🎥Mike Shah
Some fixes and improvements in GCCGCC 16 will probably release in a couple of months, and comes with a couple of my patches. There’s nothing too big this time, but a couple of bug fixes and some quality-of-life changes. You no longer need to explicitly pass -ftest-coverage for -fcondition-coverage and -fpath-coverage to be useful, it is now implied. The -ftest-coverage flag controls if GCC creates the .gcno files gcov needs to create the report. The coverage support in GCC is built on top of arc profiling which underpins profile guided optimization (PGO), and the PGO doesn’t need the .gcno, only the .gcda (counters). Coverage was a sort of side effect, and MC/DC and prime path coverage was built on that framework. Unlike arc profiling, it doesn’t make much sense to ask for MC/DC and prime path coverage without also wanting to read the reports, so this makes GCC a bit easier to use. I fixed a bug where gcov-dump printed the wrong offset for condition blocks, and taught it how to print the PATHS tag. gcov-dump is mostly useful for developing gcov itself, but it’s nice that it’s there. There’s a another bugfix in there too, which caused bad counter updates, but this bug was never included in a release. I have revised my paper on MC/DC , collected some data for it; on how the instrumentation affects compile time, runtime overhead, and object size. What I found was that compile times suffered greatly when analyzing expressions with many conditions joined by a single operator. A phase of the CFG analysis is figuring out which other conditions to mask when we take an edge, and this step evaluated all possible candidates. What I realised is that we don’t need to evaluate all of them, the search starting at the left-adjacent operand (which we must also include) will dominate and always find all the masked conditions. This had a massive impact on compile times. This is one of those problems that don’t really show up in testing that easily, because under normal circumstances this isn’t a problem. I wrote a small test program which causes the worst behaviour, a single (x && y && ... && z) . I tested two cases, 1 is (x && y && ... && z) and 4 is (x1 || ... || x8) && ... . These are the compile times before and after the fix: Those numbers are for all of GCC, including parsing, code generation, and linking. I also measured just the MC/DC analysis pass (finding the masking table and emit the instrumentation code), and get somewhere between 15–20 times speedup, not bad at all. As it turns out, algorithms matter. before: 20822.303 ms (41.645 ms per expression) after: 1288.548 ms ( 2.577 ms per expression) As you can see from the graphs, the performance hit really starts to kick in past 16 conditions, which is quite rare in practice. Still, faster is nice. I did find one case with 27 conditions in GNU ls, but that’s very much the exception.📝patch – BlogFriday, March 6, 2026
Why Hackers Struggle to Reverse Machine Code #security #programming🎥CppOnline
End-to-End Latency Metrics From Distributed Trace - Kusha Maharshi - CppCon 2025🎥CppCon
When ReadDirectoryChangesW reports that a deletion occurred, how can I learn more about the deleted thing?It's already gone. If you need more information, you should have been remembering it. The post When ReadDirectoryChangesW reports that a deletion occurred, how can I learn more about the deleted thing? appeared first on The Old New Thing .📝The Old New Thing
Persistence squared: persisting persistent data structures - Juan Pedro Bolívar Puente - Meeting C++🎥MeetingCpp
Tabla to Drumset - Translating Rhythmic Language through Machine Learning - Shreya Gupta - ADC 2025🎥audiodevcon
The Effects of C++ Evolution on Design Patterns :: Yair Friedman🎥CoreCpp
Commercial LTS Qt 6.5.12 ReleasedWe have released Qt 6.5.12 LTS for commercial license holders today. As a patch release, Qt 6.5.12 does not add any new functionality but provides bug fixes and other improvements.📝Qt Blog
The Alignment Trap: Why Doing Things Right Matters More Than Doing the “Right” ThingIn software development, we often hear that our work must be “aligned with the business”.📝The Dev Ladder
the hidden compile-time cost of C++26 reflectionthe hidden compile-time cost of C++26 reflection📝vittorio romeo's websiteThursday, March 5, 2026
Beyond Affine: Thin Plate Splines for Serial Histology AlignmentWhen Your Images Don’t Quite Line Up If you work with serial histology slides, you are familiar with the routine: Zoom into a perivascular region. Toggle to the adjacent stain. Pan. Nudge. Recenter. Repeat. Serial sections are routinely used for cross-stain interrogation and volumetric reconstruction. But consecutive sections from the same tissue block rarely align well enough for direct comparison, especially at high magnification. Sections may be skipped, and tissue deforms during cutting and mounting in ways that undermine direct spatial correspondence. Those distortions may seem small, but repeated hundreds of times a day, they compound. Misalignment undermines comparative analysis, annotation quality, and downstream machine learning workflows. At first glance, this seems like a straightforward fitting problem that a simple affine transform should be able to handle. But, once applied, this is clearly insufficient.📝Kitware Inc
Visual Studio at GDC Festival of Gaming 2026Join us at GDC Festival of Gaming 2026 for a deep dive into Visual Studio, GitHub Copilot, PowerToys, and the Windows tools that speed up your daily dev workflow. We’ll show how these tools work together to boost productivity and cut friction across your entire inner loop. Session Title: Windows Game Development with Visual Studio […] The post Visual Studio at GDC Festival of Gaming 2026 appeared first on C++ Team Blog .📝C++ Team Blog
Wait is it POSIX? Investigating Different OS and Library Implementations for Networking - CppCon🎥CppCon
The mystery of the posted message that was dispatched before reaching the main message loopPerhaps it's because you dispatched it. The post The mystery of the posted message that was dispatched before reaching the main message loop appeared first on The Old New Thing .📝The Old New Thing
Text formats are everywhere. Why?The Internet relies on text formats. Thus, we spend a lot of time producing and consuming data encoded in text. Your web pages are HTML. The code running in them is JavaScript, sent as text (JavaScript source), not as already-parsed code. Your emails, including their attachments, are sent as text (your binary files are sent … Continue reading Text formats are everywhere. Why?📝Daniel Lemire's blog
That TDD Mistake Everyone Makes #programming #tutorial🎥CppOnline
Follow up: resize + assign is often faster than reserve + emplace_back for vector📝Meeting C++ blog
From GPU Bottlenecks to Smooth Chat: Cost-Efficient Architectures for LLM Inference :: Eshcar Hillel🎥CoreCpp
Accelerated 2D Canvas BenchmarksThe previous parts of this trilogy have introduced Qt Canvas Painter and its novel new features . This post will focus on the accelerated 2D canvas performance aspect, demonstrating how our holistic approach to performance can be shown in benchmarks.📝Qt Blog
Drogon Doesn't Have Database Migrations... So I Built One🎥Kea Sigma Delta
Weighing up Zngur and CXX for Rust/C++ InteropA detailed comparison of Zngur and CXX for Rust/C++ interoperability, exploring their design philosophies, container support, trait objects, async capabilities, build systems, and real-world tradeoffs.📝KDABWednesday, March 4, 2026
C++ Performance Improvements in MSVC Build Tools v14.51MSVC Build Tools v14.51 improves performance through a wide range of new optimizations. The post C++ Performance Improvements in MSVC Build Tools v14.51 appeared first on C++ Team Blog .📝C++ Team Blog
The hidden costs of shared_ptr and when to avoid it #programming #cplusplus🎥MeetingCpp
From Pure ISO C++20 To Compute Shaders - Koen Samyn - CppCon 2025🎥CppCon
Aha, I found a counterexample to the documentation that says that QueryPerformanceCounter never failsOf course, anything can happen if you break the rules. The post Aha, I found a counterexample to the documentation that says that QueryPerformanceCounter never fails appeared first on The Old New Thing .📝The Old New Thing
Evidence-First Delivery: Stop Reviewing Diffs. Start Reviewing Evidence.Evidence-First Delivery is here. AI-assisted development makes code cheap and change volume effectively unbounded. Human attention does not scale the… The post Evidence-First Delivery: Stop Reviewing Diffs. Start Reviewing Evidence. appeared first on John Farrier .📝John Farrier
Who's Afraid of the Big Bad Template? :: Coral Kashri🎥CoreCpp
The memory zeroing trick every dev needs #programming #cpp🎥CppOnline
The Immersive Score - Creative Advantages of Beds & Objects in Film and Game Music - Simon Ratcliffe🎥audiodevcon
CMake 4.3.0-rc2 is ready for testingThe second CMake 4.3 release candidate!📝Kitware IncTuesday, March 3, 2026
Comments that outlived errorsMany static analyzers enable suppressing individual warnings directly in code via special comments. Over time, the number of such comments in projects increases. Some of them lose their relevance yet...📝from pvs-studio.com
How AI Chooses Between 3 Sorting Algorithms #ai #code🎥CppOnline
NAML 2026Kitware is proud to participate in the Tenth Annual Workshop on Naval Applications of Machine Learning (NAML), the premier annual event showcasing current machine learning research relevant to Naval applications. Anthony Hoogs, Ph.D., Keith Fieldhouse, and Jason Parham, Ph.D., are attending the unclassified and restricted days, and present two restricted lightning talks on Thursday, March 5th.📝Kitware Inc
Threads vs Coroutines — Why C++ Has Two Concurrency Models - Conor Spilsbury - CppCon 2025🎥CppCon
Just for fun: A survey of write protect notches on floppy disks and other mediaJust some useless trivia. The post Just for fun: A survey of write protect notches on floppy disks and other media appeared first on The Old New Thing .📝The Old New Thing
Set Safe Defaults for Flags@media only screen and (max-width: 600px) { .body { overflow-x: auto; } .post-content table, .post-content td { width: auto !important; white-space: nowrap; } } This article was adapted from a Google Tech on the Toilet (TotT) episode. You can download a printer-friendly version of this TotT episode and post it in your office. By Zhe Lu We all make mistakes. But big mistakes can cause big headaches! Suppose you're writing a utility to update production data for a launch. Before making changes to production data, you want to perform a dry run to validate the expected changes. In your excitement, you forget to include the --dry_run flag in your command: $ /scripts/credit_accounts --amount=USD10 # Oops, I forgot to include --dry_run You realize your mistake too late. Safe flag defaults can prevent a simple mistake from turning into a major outage: Flag has unsafe default: cliArgs.addBoolFlag(name="dry_run", default= False , help="If set, print change summary, but do NOT change data.") Flag has safe default: cliArgs.addBoolFlag(name="dry_run", default= True , help="If set, print change summary, but do NOT change data.") Safety depends on context: When defining flags, choose the default that minimizes the cost of potential mistakes . This might involve defaulting to a "dry" run, asking for user confirmation before irreversible actions, requiring a confirmation flag on the command line, or other strategies. If you’re writing documentation that contains commands, always set values to minimize the damage if run blindly: Flag in documentation has unsafe default: ## How to commit changes Use this command to commit changes. Use --dry_run to test and compute and report changes. ```shell /scripts/credit_accounts --amount=[value] --filter=[conditions] ``` Flag in documentation has safe default: ## How to commit changes Use this command to compute and report changes. Use --nodry_run to commit the changes. ```shell /scripts/credit_accounts --amount=[value] --filter=[conditions] ``` Similarly, consider requiring that environment-specific flags (e.g., backend addresses and output folders) be explicitly set . In this situation, unspecified environment flags will crash your program, instead of potentially mixing configuration across environments.📝Google Testing Blog
Code Smarter: Harnessing AI tools for C++ Development :: Inbal Levi🎥CoreCpp
The Rounding Error That Breaks Everything #cplusplus #coding #programming🎥CppOnline
C++ Community — How to modernize your C++ codebase — 25.2.2026.🎥cppserbia
Best performance of a C++ singletonIn my Januray post, I focused on implementing a singleton correctly. This time I want to add performance into the mix and show you the best way to implement your singleton... or give you guidance to pick your best way. Setting the scene I'm using a display manager as an …📝AndreasFertig.com