Microsoft ODBC Driver 17.11.1 for SQL Server released

ODBC Driver 17.11.1 is out.

Fixes:

Parameter array processing: SQL\_ATTR\_PARAMS\_PROCESSED\_PTR now reports correctly, row counting fixed when SQL\_PARAM\_IGNORE is used
Connection error with Data Classification metadata in async mode
XA recovery transaction ID computation
RPM side-by-side installs now work
Debian package license acceptance

New platforms:

macOS 14, 15, 26
Debian 13
RHEL 10
Oracle Linux 9, 10
SUSE 16
Ubuntu 24.04, 25.10
Alpine 3.21, 3.22, 3.23

Download: https://learn.microsoft.com/en-us/sql/connect/odbc/download-odbc-driver-for-sql-server

Full blog post: Microsoft ODBC Driver 17.11.1 for SQL Server Released | Microsoft Community Hub

https://redd.it/1t15ffy
@r_cpp

stackless coroutines for gamedev in ~200 lines of C++
https://vittorioromeo.com/index/blog/sfex_coroutine.html

https://redd.it/1t171z7
@r_cpp

The STL for Geometry: Thirty-Year Evolution of C++ Libraries
https://polydera.com/algorithms/the-stl-for-geometry

https://redd.it/1t19d0y
@r_cpp

Variadic Visitation
https://breese.github.io/2026/05/01/variadic-visitation.html

https://redd.it/1t1gfcd
@r_cpp

Showcase/Request for Feedback Achieving 0.31ns Pathfinding on M1 for Search & Rescue Drones – Seeking advice on further optimization.]

Hi everyone,

I’m a student and student pilot from Vietnam, currently obsessed with combining Physics and C++ to solve real-world problems. My current project, H.A.L.O. Aegis, is a 600-700KB core designed for search-and-rescue drones operating in catastrophic environments (like collapsed buildings).

My goal was to create a "zero-latency" escape route identifier that can fit into the tiny L2 cache of embedded systems.

Current Specs:

Performance: \~0.326 ns per op on Apple M1 (measured via Google Benchmark).
Throughput: 3.0679G/s.
Memory Safety: Verified with AddressSanitizer (ASan).

The "Elephant in the room": Since I wanted to move fast on the rescue logic, I used AI to help generate some of the boilerplate and the bilingual interface (about 30-40% of the code). I manually hand-tuned the core physics-based logic to hit the sub-nanosecond mark.

Why I'm here: I’m planning to share this with NGOs like the Red Cross, but before I do, I want to make sure the code is truly "bulletproof."

Is my benchmarking methodology sound?
Are there any C++20 features I missed that could make this even more efficient for ARM64?
Please be kind—I'm still learning and I'm aware some of my internal comments might be messy (working on English-izing them!).

I'm ready for the "code review of a lifetime." If there’s anything not quite right, please let me know so I can fix it before it actually goes into a drone to save lives.

Project Link: https://github.com/Nguyenidkskibidi/halo-aegis-core

Thank you for your time and expertise!

https://redd.it/1t1h0do
@r_cpp

Read-Copy Update (RCU) API in C++26
https://people.kernel.org/paulmck/stupid-rcu-tricks-rcu-api-in-cpp26

https://redd.it/1t1gqwp
@r_cpp

Mathieu Ropert: The Performance Mindset
https://youtu.be/o-C6puc7nOk

https://redd.it/1t1k7k2
@r_cpp

CppCon 2025: Can Standard C++ Replace CUDA for GPU Acceleration? - Elmar Westphal
https://www.youtube.com/watch?v=EOvukoCyW7A

https://redd.it/1t1kopc
@r_cpp

Does anyone maintain an impl of the Chandler Carruth map API?

Lightning Talk (C++Now 2019, 8min): https://youtube.com/watch?v=kye4aD-KvTU

In 2019, Chandler presented the above talk describing a C++ map API. It's not compatible with the standard map types, but for greenfield projects I think it's an excellent choice.

I've considered implementing it myself, but hash tables are very subtle and finicky. I'd rather rely on a robust implementation.

Abseil has some excellent hash tables, but to my knowledge they do not support the small size/small buffer optimization. Chandler's hypothetical API does. Would be great to have the SIMD probing algorithm from Abseil implemented for an SSO map type.

https://redd.it/1t21nhu
@r_cpp

Post examples of using reflections in your projects

What the title says. I just want to see what interesting things people are using reflection for now that its in gcc. Thanks.

https://redd.it/1t25byx
@r_cpp

oo-alloc: i made a comprehensive learning resource for allocators in C++

hi!
i made a memory allocation library/learning resource. i wanted to learn more about them and i couldn't find one comprehensive source of knowledge, so i decided that i'll make one of my own:\].
it currently has these basic allocator types: arena (linear), stack, pool, free list, free tree, tracking, buddy, slab.
i gave my best to describe everything clearly in the readme, also added svg diagrams (written in Typst, btw). i plan to implement a bucket/size-segregated free list allocator as well.
hoping anyone will find this resource useful!
https://github.com/nihiL7331/oo-alloc

https://redd.it/1t287xq
@r_cpp

I made C++ coding problems where you build things like a mini Redis or a tiny interpreter — looking for feedback

I’ve been building a small platform with coding problems that are more “systems-style” rather than typical algorithm exercises.

The idea is to practice by building simplified versions of real components, but still in a problem format (input/output + tests).

Some examples:

* implement a Redis-like server (TCP + protocol parsing)
* build a tiny interpreter
* create a virtual filesystem
* write an expression evaluator

The problems are:

* runnable directly in the browser (no setup)
* open-ended (you decide design/architecture)
* supporting multi-file submissions

I’m trying to keep them doable in a few hours, not huge multi-day projects.

I’m curious what people here think:

* does this kind of problem feel useful for improving practical C++ skills?
* or would you prefer something more guided / closer to full projects?

Still early, so any feedback would be really helpful.

Link: [https://elitecode.pro/](https://elitecode.pro/)

https://redd.it/1t2941b
@r_cpp

Modern C++ Programming
https://federico-busato.github.io/Modern-CPP-Programming/

https://redd.it/1t2a4jz
@r_cpp

When to actually use a set
https://dubeykartikay.com/posts/why-never-use-std-unordered-set/

https://redd.it/1t2im2j
@r_cpp

Migrating a small C++ code base to C++26 (modules, import std and contracts)
https://jonastoth.github.io/posts/migrate_cxx26/

https://redd.it/1t2kkoh
@r_cpp

I built a C++ integer-to-string library based on a new AVX-512 paper

I built a small C++ integer-to-string conversion library based on a new paper by Jael Champagne Gareau and Daniel Lemire, "Converting an Integer to a Decimal String in Under Two Nanoseconds":

- Project: https://github.com/simditoa/simditoa
- Paper: https://arxiv.org/abs/2604.26019

The paper looks at decimal formatting for integers, which shows up in logging, JSON/CSV/XML serialization, database output, and other places where numbers eventually become text. The interesting part, and the part I wanted to experiment with, is that it uses AVX-512 IFMA instructions to extract multiple decimal digits in parallel, avoiding the usual repeated division/modulo loop and avoiding large lookup tables.

The library exposes a small to_chars-style API:

#include "simditoa.h"

char buf[simditoa::MAX_DIGITS + 1];
size_t len = simditoa::to_chars(12345, buf);
buf[len] = '\0';

Current project shape:

- C++17
- int64_t and uint64_t support
- AVX-512 IFMA + VBMI path for supported x86-64 CPUs
- portable scalar fallback
- CMake package/install support
- tests for edge cases, digit lengths, and randomized values
- a simple benchmark against std::to_chars

The README benchmark currently shows simditoa::to_chars at about 15.82 ns/int versus 36.35 ns/int for std::to_chars on the tested setup, roughly 2.3x faster in that run. The paper reports stronger results for its full algorithm and benchmark suite, including single-core performance ahead of other tested methods, but my repo should be treated as a compact implementation based on the paper rather than a full reproduction of every variant in it.

The core trick is neat: for 8-digit chunks, it uses AVX-512 IFMA with precomputed constants based on floor(2^52 / 10^k) to compute digit positions in parallel, then gathers the digit bytes with AVX-512 byte permutation. Larger values are split into chunks.


https://redd.it/1t2ny62
@r_cpp

Auxid: An Orthodox C++20 Base Library for Data-Oriented Design

NOTE: All and any colorations/PRs are welcome, **EXCEPT FOR AI GENERATED GARBAGE**.

Hey folks,

Let me introduce Auxid: a C++20 platform/library aimed at high-performance applications (specifically game engines and systems software) built around **Orthodox C++** and **Data-Oriented Design (DOD)**.

I know the C++ ecosystem isn't short on utility libraries, but I built Auxid to bridge a specific gap: getting the predictable memory layouts and fast compile times of C-style systems programming, without losing the ergonomics of standard C++20 algorithms.

Mainstream C++ often relies on heavily templated, node-based STL containers that can thrash CPU caches or introduce hidden heap allocations. Auxid strips that back. Where the STL is already the right tool for the job (like `std::filesystem`), Auxid exposes it through thin, zero-overhead wrappers. For the rest, it provides DOD-friendly replacements.

Here’s a quick architectural overview of what’s inside:

* **Cache-Friendly Containers:** Includes a sparse-dense hash map, strictly aligned vector types, and small-string-optimized (SSO) strings.
* **Plays Nice with** `<algorithm>`: Auxid’s containers use iterators that satisfy C++20 iterator concepts (like contiguous iterators), meaning you can seamlessly pass them into `std::sort`, standard ranges, and other utilities.
* **Total Allocator Control:** No surprise allocations in the hot path. Auxid integrates [rpmalloc](https://github.com/mjansson/rpmalloc) out of the box for extremely fast, thread-caching heap allocation, alongside custom arena allocators.
* **Lightweight Error Handling:** Instead of exceptions, it relies on a union-based `Result<T, E>` and `Option<T>` that compile to tight representations, paired with Rust-style `AU_TRY` macros.
* **Explicit Control Flow:** Auxid provides an opt-in CMake target (`auxid_platform_standard`) that strictly disables C++ exceptions (`-fno-exceptions` / `/EHs-c-`) to enforce predictable performance characteristics.

It's designed to be dropped directly into existing CMake projects via `FetchContent`:

FetchContent_Declare(
auxid
GIT_REPOSITORY https://github.com/I-A-S/Auxid.git
GIT_TAG main
)
FetchContent_MakeAvailable(auxid)


If you are interested in DOD, alternative standard libraries, or just want to critique the architecture, I’d really value this community's feedback.

* **Core Library:** [I-A-S/Auxid](https://github.com/I-A-S/Auxid)
* **Project Scaffold:** [I-A-S/Auxid-Project-Template](https://github.com/I-A-S/Auxid-Project-Template)

Licensed under Apache 2.0.

Eager to hear what you think not just about the project, but the principles of Orthodox C++ as a whole!

https://redd.it/1t2nyai
@r_cpp

GoodLog: a small C++17 wrapper around Boost.Log for colored output, rotation and hex dumps

Hi r/cpp,



I built GoodLog, a small C++17 wrapper around Boost.Log.



The goal is not to replace general-purpose logging libraries like spdlog. I wanted a reusable layer for C++ projects that already depend on Boost, so the common Boost.Log setup does not have to be repeated across modules.



It currently supports:



\- colored console output

\- automatic file:line source location

\- rotating log files

\- separate severity filters for console and file sinks

\- optional channel filtering

\- hex dump helpers for binary buffers

\- CMake demo and GoogleTest entry points



GitHub:

https://github.com/SoleyRan/Log



The project is still early, and I would especially appreciate feedback on the macro API, CMake integration, and whether the channel logging interface should be simplified.



https://redd.it/1t2pmyu
@r_cpp