Boost C++ | Open Source Libraries

Level up your C++ skills! Sharpen your code with the latest from the Boost Libraries, powerful, peer-reviewed, and production-ready New in Boost: Bloom – High-performance Bloom filters → boost.org/libs/bloom Hash2 – Modern, flexible hashing library → boost.org/libs/hash2 MQTT5 – Next-gen MQTT protocol support → boost.org/libs/mqtt5 Explore all Boost libraries → boost.org/libs

Boost.Container benchmarked segmented deque algorithms across six compiler configurations The spread: 1.71x to 5.93x geomean speedup The surprising part: adding #pragma unroll(4) boosts GCC by 60%. Clang regresses. MSVC ignores it entirely Your compiler choice matters more than you think

Same segmented algorithm. Same deque. Same data Six compilers. Wildly different results 🧵👇

@fithisux Modern compilers see through the inner loop (segment filling) and generate SIMD code for that, which results in the reported 17x speedup.

@Boost_Libraries What does it mean to vectorize? It is an iterator.

std::fill on a deque is 17x slower than it needs to be The fix has existed since the year 2000. Nobody shipped it 🧵👇

Matt Austern's segmented iterator paper proposed a simple idea: walk each contiguous block with a raw T* and let the compiler vectorize 25 years later, Boost.Container ran the benchmarks. MSVC 2026 turns that into a 17x speedup on fill. The geomean across 16 algorithms: 5.93x The code is surprisingly simple

Boost Blueprint 050: Boost.STLInterfaces. You give a CRTP base your three core ops – dereference, advance, compare – and it generates all 15+ required operators, type aliases, and const conversions for you Pick your category (random access, bidirectional, forward, input), provide the primitives, get a conformant iterator in ~19 lines instead of 123. Same pattern works for view_interface if you're building std::ranges compatible views Level up your C++ architecture. Follow @Boost_Libraries for the #BoostBlueprint series #cpp

If you've ever written a custom iterator in C++ from scratch, you know the pain: 5 type aliases, 6+ operator overloads, const/non-const pairs, SFINAE gates… That's 100+ lines of boilerplate before your iterator actually does anything. Per container. There's a better way 🧵👇

Boost 1.91 is now in both Conan and vcpkg That means Boost.Decimal (finally, real IEEE 754 decimal arithmetic), the Asio inline-namespace versioning, all of it is one install command away Conan → conan.io/center/recipes… vcpkg → vcpkg.io/en/package/boo… The wait is over. Go update

Friendly PSA: Boost 1.91 shipped with IEEE 754 decimal floating point, Asio binary versioning, and 58 fewer internal dependencies If you've been waiting for it to hit your package manager 🧵👇

Boost Blueprint 049: Boost.CRC. One template. You set the bit width, polynomial, init value, final XOR, and reflection, and it builds the lookup table at compile time CRC-32/BZIP2, CRC-16/ARC, CCITT-FALSE, CCITT-TRUE, XMODEM, custom polynomials. All covered. Bytes, ranges, or streams. No runtime init, no magic constants Level up your C++ architecture. Follow @Boost_Libraries for the #BoostBlueprint series #cpp

Every byte leaving your system needs an integrity check. Every byte arriving needs verification. You're implementing CRC-32/BZIP2 for network frames, CRC-16/ARC for sensor packets, and CRC-16/CCITT-FALSE for legacy serial What if one template handled all of them? 🧵👇

Boost Blueprint 048: Boost.PropertyTree. A generic hierarchical key-value store that reads and writes JSON, XML, INI, and its own INFO format through one unified API Query nested values with dot-delimited paths: pt.get("server.port"). If the key may not exist, use get with a default value or get_optional returning boost::none. Iterate subtrees. Modify in memory and write back to any supported format. One data structure, four formats, zero schema boilerplate Level up your C++ architecture. Follow @Boost_Libraries for the #BoostBlueprint series #cpp

How would you load an INI file, an XML config, and a JSON settings blob into the same in-memory structure, queryable with a single path syntax, in portable C++? No third party schema generator. No code-gen step. Just read, query, modify, write 🧵👇

Boost Blueprint 047: Boost.Charconv. It's what should have been everywhere: a portable, locale-independent from_chars and to_chars that actually handles floating-point across every major compiler No locale, no exceptions, no stream overhead, and effectively no allocation It's at least as fast as your vendor's , often several times faster. Integer conversions are header-only; floating-point requires linking. It fills the gaps GCC, Clang, and MSVC still haven't closed Level up your C++ architecture. Follow @Boost_Libraries for the #BoostBlueprint series #cpp

std::stod may allocate. std::strtod is locale-dependent. std::from_chars was C++17's answer, but many implementations still don't support floating-point Why does parsing a double from a string without locale quirks require a compiler lottery? 🧵👇