This period
2026-09-29 → 2026-10-29 · rolling 30 daysArticles
44 this periodBillion-query-per-second lookup tables in C++
Daniel Lemire is a software performance expert. He ranks among the top 2% of scientists globally (Stanford/Elsevier 2025) and is one of GitHub's top 1000 most followed developers. A lot of software spends its time mapping strings to…
C++/WinRT overcorrection: Using make_self and immediately converting it to the projected interface
This article discusses the two ways of creating objects in C++/WinRT, focusing on the use of make_self and its conversion to the projected interface. It explains the implications of choosing one method over the other based on access needs.
C++26 Ranges: Parallel Algorithms and Safer Filters
This article discusses the new features in C++26 related to ranges, focusing on parallel algorithms and the implementation of safer filters. It provides insights into how these features enhance performance and safety in C++ programming.
Making SIMD Code Scale to Any Vector Width
Search Get started Making SIMD Code Scale to Any Vector Width Leave a Comment / Technical / By Nemi Verploegh I will be using x86 naming throughout this post, but the concepts apply to other architectures too. Basic familiarity with SIMD…
Why don’t we run the taskbar and Task Manager at high priority, so they can remain responsive?
This article discusses the challenges of running the taskbar and Task Manager at high priority in a CPU-starved environment. It explains how priority management can lead to issues with shared resources, making it difficult to maintain responsiveness.
A faster way to compute signed 64-bit floor division by constants
What is signed integer floor division? Signed integer floor division is where you do a/b and get a result that rounds towards − ∞ , whereas standard ( “truncated” ) signed division rounds towards 0 . As stated in Hacker's Delight: “[I…
Puzzling out why a program doesn’t work when run from a batch file, but works when double-clicked from Explorer
This article discusses a common issue where a program fails to run correctly from a batch file due to the current directory not being set properly. It explains how double-clicking a program in Explorer sets the current directory, which can affect how the program locates ancillary files.
The result of the C++26 DIS ballot
Home Workshops Start here For safety-critical teams For embedded teams For low-latency teams All workshops and paths Engagements Learn Online training Upcoming Self-checks Talks Interviews Blog Newsletter Announcements About Contact Get in…
Balloting has completed for C++26. Unfortunately it was Disapproved
By clicking Continue to join or sign in, you agree to LinkedIn’s User Agreement , Privacy Policy , and Cookie Policy . Balloting has completed for C++26. Unfortunately it was Disapproved P-Members voting: 12 in favor out of 20 = 60 %…
The C++26 inplace_vector container
This article discusses the new std::inplace_vector container introduced in C++26, which combines features of std::array and std::vector. It explains how it works and when to use it.
Attention people who think UB is fine
--> Categories About Support on Patreon --> --> Livecount : connecting… This is my personal blog. The views expressed on these pages are mine alone and not those of my employer. This is not AI. All hallucinations are my own human ones.…
Game++. Part 2.2: Types of optimization
This article offers insights into C++, including the algorithms and practices used in game development, and explores the language's strengths and weaknesses, its established workflows, and hands-on techniques.
Why didn’t we use the COM static store to clean up the unmarshalable delegate?
This article discusses the limitations of using the COM static store for managing unmarshalable delegates, particularly in the context of single-threaded apartments in UWP applications.
Why didn’t we use CoRegisterInitializeSpy to clean up the unmarshalable delegate?
This article discusses the challenges and considerations of using CoRegisterInitializeSpy for cleaning up unmarshalable delegates in COM. It highlights issues related to thread management and the unpredictability of the unregistration process.
C++26 Ranges: Better Infrastructure
This article discusses the improvements and infrastructure related to ranges in C++26. It provides insights into the design and implementation aspects of the new features.
Microsoft CppCon 2026 Trip Report
This article provides a recap of Microsoft's participation at CppCon 2026, highlighting discussions with developers and sessions attended. It covers various topics including modern C++ practices and the integration of AI in development.
Why didn’t we use RoRegisterForApartmentShutdown to clean up the unmarshalable delegate?
This article discusses the challenges of using the RoRegisterForApartmentShutdown function in creating an agile wrapper for non-agile objects in COM. It highlights the complexities involved in managing object lifetimes and apartment shutdowns.
EDG is open source
Read John Spicer's note on what's next for EDG, and the transition FAQ → Docs GitHub The EDG open source transition On September 30, 2026, the source for EDG's C++ front end went public, and The C++ Alliance became its nonprofit home.…
Microspeak: Drain the slide, back-up slides
This article discusses the term 'drain the slide' in the context of presentations at Microsoft, explaining its implications and the reasons behind its usage. It highlights the tension between using slides as visual aids and as reference materials.
Why do we need ud2 when int 6 is right there?
This article discusses the architectural differences between the ud2 instruction and the int 6 instruction, highlighting how they handle faults and traps differently in the context of exception handling.
Composite objects and C++26 the std::polymorphic type
This article discusses the C++ std::polymorphic type and its application in implementing composite classes. It explores various strategies for managing class hierarchies and event logging in a smart house context.
The Problem with C++ Safety: Why “It Works” Isn’t Good Enough
Welcome back to the blog of Rainer Grimm! This is the first of hopefully many new C++-related articles in Rainer’s blog. Since you are reading this, you have potentially read many of his articles and have gotten an idea of his passion and…
C++ futures part 5: std::future and std::shared_future
This article wraps up the introduction to the C++ futures library, focusing on std::future and std::shared_future. It explains how std::future is a move-only class designed for a single consumer, while std::shared_future allows multiple consumers to access the same value.
C++ futures part 4: What if I want an immediate on-thread std::async?
This article discusses how to implement an immediate on-thread calculation using std::async in C++. It provides several methods to achieve this, including using promises and packaged tasks.
MSVC Build Tools Version 14.52 Release Candidate Now Available
The release candidate for Microsoft C++ Build Tools version 14.52 is now available, with C++23 ready for production use. This version includes updates across the compiler, linker, and standard library.
C++ futures part 3: The mental model for std::async
This article continues the exploration of C++ futures, focusing on the std::async function. It discusses the complexities of how std::async operates, including its invocation timing and threading behavior.
C++26 Ranges: Four New Views
This article discusses four new views introduced in C++26 ranges, providing insights into their functionality and usage. It serves as the first part of a series exploring the enhancements in C++26 ranges.
Generating Operator Functions
This article discusses the generation of operator functions in C++, exploring the differences between push and pull mechanisms. It provides insights into how these functions can be effectively implemented.
C++ futures part 2: The mental model for std::promise, std::packaged_task
This article explores the usage and management of the 'state' in C++ futures, specifically focusing on std::promise and std::packaged_task. It explains how these components interact and manage the lifetime of the source object.
C++ futures part 1: The mental model
This article discusses the C++ standard library's related functions and classes for futures, including std::promise, std::async, and std::future. It introduces the concept of a 'source' that produces values and handles exceptions in a thread-safe manner.
C++26 Contracts: Introduction to Preconditions and Postconditions
This article explores the concept of contracts in C++26, focusing on how to express preconditions and postconditions in code. It discusses the transition from assertions to contract-based programming, providing examples and insights into the new syntax.
The wild west of polyglot docs sites
Given a project that provides libraries in N different programming languages, the docs site for that project often needs to interact with N or N+1 different documentation generators. This is because each programming language has its own…
One way of thinking about access specifiers in C++/WinRT implementation types
This article discusses how access specifiers in C++/WinRT implementation types can be interpreted based on their visibility to the outside world and the module that produces them.
If one anti-malware software is good, does that make two better?
This article discusses the complications that arise when two different anti-malware programs are installed on the same system, leading to conflicts and potential system failures. It uses an analogy of security companies to illustrate the issues of software detours and interactions.
C++ and AI at CppCon: We have to use agents - more or less?!
This article discusses the intersection of C++ and artificial intelligence, particularly in the context of the CppCon conference. It explores the necessity of using agents in AI applications developed with C++.
How can undefined opcodes ud0 and ud1 have parameters? How undefined were they?
This article discusses the nature of undefined opcodes ud0 and ud1, explaining how they can have parameters despite being undefined. It delves into the intricacies of instruction decoding and the historical context of these opcodes.
Why does the compiler sometimes use ud2 and sometimes int 3 for code that shouldn’t execute?
This article explains the differences between the int 3 and ud2 opcodes used by x86 compilers to indicate unreachable code. It discusses their purposes and implications for debugging.
If somebody tries to hot-patch an already-hot-patched function, how do they avoid conflicts?
This article discusses the challenges of hot-patching functions in Windows, particularly when a function has already been patched. It highlights the potential issues that arise when unauthorized patching occurs and the implications for system stability.
The complement of true is true, except when it's false
Archive Search About The complement of true is true, except when it's false 1 October 2026 · Matthew Taylor | Edit Table of Contents Putting it together When it’s false Unscoped enums, promotion, and undefined behaviour Avoiding this in…
Why is there no Windows hot-patching support for other architectures like 32-bit ARM and MIPS?
This article discusses the reasons behind the lack of Windows hot-patching support for certain architectures such as 32-bit ARM and MIPS. It explains the historical context and the specific features of Windows Server that influenced this decision.
Windows on Itanium also provided for hot-patching, in an even simpler way
This article discusses the hot-patching capabilities of Windows on Itanium, highlighting the fixed-sized instruction bundles and their implications for hot-patching. It also touches on the structure of Itanium binaries and the use of padding in function definitions.
C++26: the new debugging header
This article discusses the new debugging header introduced in C++26, detailing its features and usage. It provides insights into how this addition can improve debugging practices in C++ development.
EDG C/C++ Compiler Project
Sign in Appearance settings Platform AI CODE CREATION GitHub Copilot Write better code with AI GitHub Copilot app Direct agents from issue to merge MCP Registry Integrate external tools DEVELOPER WORKFLOWS Actions Automate any workflow…
Windows on AArch64 also provides for hot-patching, but it’s much simpler than on x86
This article discusses how Windows on AArch64 implements hot-patching with simpler mechanics compared to x86 due to its fixed-length instruction set. It explains the use of patch points and the atomicity of instruction updates.