Title: UltrafastSecp256k1 — Zero-dependency C++20 secp256k1 with ASM backends, CUDA/ROCm, and 9 platform targets

After 3+ years of development, I'm sharing **UltrafastSecp256k1** — a complete secp256k1 implementation in modern C++20 with zero external dependencies.

**What makes it different:**

* **Zero dependencies** — SHA-256, SHA-512, Keccak-256, RIPEMD-160, Base58, Bech32 all implemented from scratch
* **Multi-backend assembly** — x64 MASM/GAS (BMI2/ADX), ARM64 (MUL/UMULH), RISC-V (RV64GC)
* **SIMD** — AVX2/AVX-512 batch operations, Montgomery batch inverse
* **GPU** — CUDA (4.63M kG/s), OpenCL (3.39M kG/s), ROCm/HIP
* **Constant-time** — Separate `secp256k1::ct` namespace, Montgomery ladder, no flag switching
* **Hot path contract** — Zero heap allocations, explicit buffers, fixed-size POD, in-place mutation
* **9 platforms** — x64, ARM64, RISC-V, ESP32, STM32, WASM, iOS, Android, CUDA/ROCm

**Protocol coverage:**
ECDSA (RFC 6979, low-S, recovery), Schnorr (BIP-340), MuSig2, FROST, Adaptor sigs, Pedersen commitments, Taproot, BIP-32/44, Silent Payments (BIP-352), ECDH, multi-scalar multiplication, batch verification, 27+ coin address generation.

**Design philosophy:**


**Algorithm > Architecture > Optimization > Hardware**

**Memory traffic > Arithmetic**

**Correctness is absolute; performance is earned**

Everything is `constexpr`\-friendly where possible. No exceptions, no RTTI, no virtual calls in compute paths.

200+ tests, fuzz harnesses, known vector verification.

Happy to answer questions about the architecture, assembly backends, or GPU implementation.

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

The story of making RocksDB ingestion 23x times faster
https://blog.serenedb.com/building-faster-ingestion

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

CppCon 2026 - Cost & Preparations

Hi Everyone, 

I'm planning to attend CppCon 2026 for the first time.
I'll be flying from the other half of the world for this, which isn't cheap by any means (tickets are around$1700).
I've been saving up money for some time now, but I was wondering, can somebody help me with how much the tickets and accommodations cost in general so I can be prepared ?
I understand that tickets sell cheaper usually for students. If so, how much cheaper? (I'm a student if that makes a difference.)

Thanks in advance guys!

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

Back to Basics: Iterators in C++ - Nicolai Josuttis - CppCon 2023
https://www.youtube.com/watch?v=26aW6aBVpk0

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

Favorite optimizations ??

I'd love to hear stories about people's best feats of optimization, or something small you are able to use often!

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

New C++ Conference Videos Released This Month - February 2026 (Updated To Include Videos Released 2026-02-09 - 2026-02-15)

**CppCon**

2026-02-09 - 2026-02-15

* A Case-study in Rewriting a Legacy Gui Library for Real-time Audio Software in Modern C++ (Reprise) - Roth Michaels - CppCon 2025 - [https://youtu.be/ag\_WNEDwFLQ](https://youtu.be/ag_WNEDwFLQ)
* Back to Basics: Master the static inline, const, and constexpr C++ Keywords - Andreas Fertig - CppCon 2025 - [https://youtu.be/hLakx0KYiR0](https://youtu.be/hLakx0KYiR0)
* std::execution in Asio Codebases: Adopting Senders Without a Rewrite - Robert Leahy - CppCon 2025 - [https://youtu.be/S1FEuyD33yA](https://youtu.be/S1FEuyD33yA)
* Back to Basics: Custom Allocators Explained - From Basics to Advanced - Kevin Carpenter - CppCon 2025 - [https://youtu.be/RpD-0oqGEzE](https://youtu.be/RpD-0oqGEzE)
* Your Optimized Code Can Be Debugged - Here's How With MSVC C++ Dynamic Debugging - Eric Brumer - CppCon 2025 - [https://youtu.be/YnbO140OXuI](https://youtu.be/YnbO140OXuI)

2026-02-02 - 2026-02-08

* Connecting C++ Tools to AI Agents Using the Model Context Protocol (MCP) - Ben McMorran - [https://youtu.be/NWnbgwFU1Xg](https://youtu.be/NWnbgwFU1Xg)
* The Truth About Being a Programmer CEO - Greg Law - [https://youtu.be/e8kNoLCW\_Rs](https://youtu.be/e8kNoLCW_Rs)
* An Introduction to the new C++ 26 "Reflection" Feature - Inbal Levi - [https://youtu.be/HBkG5DpLYo0](https://youtu.be/HBkG5DpLYo0)
* CMake Doesn't Have to Be Painful | Simple Strategies That Work - Bret Brown - [https://youtu.be/NDfTwOvWIao](https://youtu.be/NDfTwOvWIao)
* Parallel Range Algorithms: The Evolution of Parallelism in C++ - Ruslan Arutyunyan - [https://youtu.be/LVDr0132vUI](https://youtu.be/LVDr0132vUI)

2026-01-26 - 2026-02-01

* Using Floating-point in C++: What Works, What Breaks, and Why - Egor Suvorov - [https://youtu.be/m83TjrB6wYw](https://youtu.be/m83TjrB6wYw)
* Cross-Platform Package Management for Modern C++ Development with Pixi - Ruben Arts - [https://youtu.be/SQk0lKv2swk](https://youtu.be/SQk0lKv2swk)
* Mastering the Code Review Process - Pete Muldoon - [https://youtu.be/6a3CNRMssQE](https://youtu.be/6a3CNRMssQE)
* Networks in C++ - What's Actually Changing? - Ignas Bagdonas - [https://youtu.be/dVSCMJlHXQM](https://youtu.be/dVSCMJlHXQM)
* Compiler Explorer: The Features You Never Knew Existed - Matt Godbolt - [https://youtu.be/3W0vE\_VKokY](https://youtu.be/3W0vE_VKokY)

**ADC**

2026-02-09 - 2026-02-15

* How To Learn Audio Plugin Development With JUCE in 2026 (for free) - Jan Wilczek & Tom Poole - ADC 2025 - [https://youtu.be/MCL1BRsEEYc](https://youtu.be/MCL1BRsEEYc)
* Learnings from a Decade of Being a Mentor in Game Audio - Jorge Garcia - ADCx Gather 2025 - [https://youtu.be/Er\_C2652Bxw](https://youtu.be/Er_C2652Bxw)
* Channel Agnosticism in MetaSounds - Simplifying Audio Formats for Reusable Graph Topologies - Aaron McLeran - ADC 2025 - [https://youtu.be/vC-jnag-w9Q](https://youtu.be/vC-jnag-w9Q)

2026-02-02 - 2026-02-08

* Real-Time, Low Latency and High Temporal Resolution Spectrograms - Alexandre R.J. Francois - [https://youtu.be/QbNPA5QJ6OU](https://youtu.be/QbNPA5QJ6OU)
* Audio Codec Switching in the Linux Kernel for Automotive Edge Devices - Rutvij Trivedi - [https://youtu.be/eo2wWQQNYbI](https://youtu.be/eo2wWQQNYbI)
* Instrument Your Code So it Can Sing - Adam Shield - [https://youtu.be/Ll8h2ASyicA](https://youtu.be/Ll8h2ASyicA)

2026-01-26 - 2026-02-01

* Minimalistic Music Composition with C++ - Xyzzy - ADCx Gather 2025 - [https://youtu.be/9x49IxlrkqI](https://youtu.be/9x49IxlrkqI)
* The Real Waveform Matters - The Samples Are Not Always What They Seem - Jamie Angus-Whiteoak - ADC 2025 - [https://youtu.be/8eEWK6Fez8c](https://youtu.be/8eEWK6Fez8c)

**C++ Under The Sea**

2026-02-02 - 2026-02-09

* INBAL LEVI - Welcome to 0.1 of the meta::\[\[verse\]\]! - [https://www.youtube.com/watch?v=PEr6XVALpVk&pp=0gcJCYcKAYcqIYzv](https://www.youtube.com/watch?v=PEr6XVALpVk&pp=0gcJCYcKAYcqIYzv)
* LIEVEN DE COCK - Space Invaders: The Spaceship Operator is upon us -

[https://www.youtube.com/watch?v=muJL-\_ymx-0](https://www.youtube.com/watch?v=muJL-_ymx-0)
* MARTIJN TERPSTRA - Low Overhead Multi-threaded Logging for Low-latency Applications - [https://www.youtube.com/watch?v=AjnQBHu0AhE](https://www.youtube.com/watch?v=AjnQBHu0AhE)
* FREDRICK OMONDI - Introduction to Writing and Profiling GPU Kernels - [https://www.youtube.com/watch?v=0PvjR\_\_R5kI](https://www.youtube.com/watch?v=0PvjR__R5kI)
* PHIL NASH - Mastering the Special Member Functions : The Rules of 0 to 5 and Beyond - [https://www.youtube.com/watch?v=PEr6XVALpVk&pp=0gcJCYcKAYcqIYzv](https://www.youtube.com/watch?v=PEr6XVALpVk&pp=0gcJCYcKAYcqIYzv)

**Meeting C++**

2026-01-26 - 2026-02-01

* Purging undefined behavior and Intel assumptions in Legacy Codebases - Roth Michaels - [https://www.youtube.com/watch?v=b7SZdhrEsic](https://www.youtube.com/watch?v=b7SZdhrEsic)
* 25+ years of pathfinding problems with C++ - Raymi Klingers - [https://www.youtube.com/watch?v=lEBQveBCtKY](https://www.youtube.com/watch?v=lEBQveBCtKY)
* Speed for Free - current state of auto vectorizing compilers - Stefan Fuhrmann - [https://www.youtube.com/watch?v=m2vVWkFsrM0](https://www.youtube.com/watch?v=m2vVWkFsrM0)

**ACCU Conference**

2026-01-26 - 2026-02-01

* The Beman Project: Testing C++ Library Proposals Before Standardization - Dietmar Kühl - ACCU 2025 Short Talks - [https://youtu.be/wXQE\_Upqbms](https://youtu.be/wXQE_Upqbms)
* A Sixth Seam in TDD? - Python Testing, Test Doubles & Legacy Code at Kosli - Jon Jagger - ACCU 2025 Short Talks - [https://youtu.be/62EltmSbqro](https://youtu.be/62EltmSbqro)
* What, What? - When We Think We Understand - Nara Morrison - ACCU 2025 Short Talks - [https://youtu.be/W0vAsaL\_svY](https://youtu.be/W0vAsaL_svY)

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

Sourcetrail (Fork) 2025.12.8 released

Hi everybody,

Sourcetrail 2025.12.8, a fork of the C++/Java source explorer, has been released with these changes:

C++: Add indexing of structured binding declarations
C++: Add indexing of auto prvalue casts
GUI: Fix error/status view not cleared between indexing
C/C++: Replace msvc mulitithreading library switches with corresponding clang switches
C/C++: Add Visual Studio 2026 support
Database: Enable simple database performance improvement

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

C++26: std::is_within_lifetime
https://www.sandordargo.com/blog/2026/02/18/cpp26-std_is_within_lifetime

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

I made a minimal SDL3 starter template with CMake and vcpkg — cross-platform, no bundled libs

Been doing C++ game dev for a while and got tired of setting up the same boilerplate every time I started a new SDL project. Put together a clean starter template with SDL3, SDL3_image, and SDL3_ttf managed via vcpkg so dependencies just work on Linux, macOS, and Windows.

Includes a basic SDLWindow class, hardware-accelerated renderer, and a game loop ready to go. Nothing fancy, just a solid starting point.

https://github.com/Tanner-Davison/sdl3-starter-template

Happy to answer questions about the setup or take feedback on the structure.

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

BitFields API: Type-Safe Bit Packing for Lock-Free Data Structures
https://rocksdb.org/blog/2025/12/31/bit-fields-api.html

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

Parallel C++ for Scientific Applications: Tasks & Concurrency (2nd Part)
https://www.youtube.com/watch?v=l-QUaAH_JJs

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

Problems with a weak tryLock operation in C and C++ standards
https://forums.swift.org/t/se-0512-document-that-mutex-withlockifavailable-cannot-spuriously-fail/84789/3

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

MSVC Build Tools 14.51 Preview released
https://devblogs.microsoft.com/cppblog/microsoft-c-msvc-build-tools-v14-51-preview-released-how-to-opt-in/

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

Learn C++ by Example • Frances Buontempo & Matt Godbolt
https://youtu.be/PXKICIiXEUM?list=PLEx5khR4g7PJbSLmADahf0LOpTLifiCra

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

Experimental adaptive sort - matches std::sort on random input, 2-8x faster on structured data

Hi all,

I’ve been developing an adaptive sorting algorithm, tentatively called **JesseSort**, which aims to exploit partial order in input data while still being competitive with standard library sorts on random input. I’m looking for feedback on design and potential adoption strategies.

# What it does

* Detects natural runs in the input (ascending, descending, or random) with a tiny lookahead.
* Maintains two sets of piles for ascending and descending runs, essentially a dual-patience sort.
* Falls back to tiny 8-value bitonic sort networks on detected random regions.
* When this random-input block is run too many times, it falls back to **std::sort**.
* Currently merges adjacent runs in a naive/bottom-up way.

# Current numbers

Median runtime ratios vs `std::sort` over 100 trials:

|Input Type|1k Values|10k|100k|1M|
|:-|:-|:-|:-|:-|
|Random|**0.984**|1.032|1.042|1.088|
|Sorted|1.022|**0.679**|**0.583**|1.448?|
|Reverse|1.636|1.076|**0.900**|2.101?|
|Sorted+Noise(5%)|1.048|1.041|1.079|1.201|
|Random+Repeats(50%)|1.037|1.032|1.031|1.089|
|Jitter|1.012|**0.674**|**0.586**|1.443?|
|Alternating|**0.829**|1.011|**0.974**|1.018|
|Sawtooth|1.121|**0.960**|**0.978**|1.072|
|BlockSorted|1.046|**0.950**|**0.928**|1.153|
|OrganPipe|**0.446**|**0.232**|**0.138**|**0.268**|
|Rotated|**0.596**|**0.522**|**0.396**|**0.716**|
|Signal|1.402|**0.828**|**0.659**|**0.582**|

**Notes:**

* Ratios are `JesseSort` / `std::sort`. **Values <1 indicate JesseSort is faster.** 0.5 means JesseSort takes half the time (2x faster). 2.0 means JesseSort takes twice as much time (2x slower).
* Large input blow-ups (`?`) appear to be outliers on my machine, but would be curious to see if others see the same pattern.

# Current issues / questions

1. **Handoff threshold:** Detecting random input too early loses semi-structured gains; too late slows random input. How should this balance be tuned?
2. **Fallback vs. std::sort:** Could JesseSort itself (dual patience games) serve as a better fallback than heap sort in standard introsort implementations?
3. **Merge optimizations:** Current merge is bottom-up adjacent. I’ve prototyped a TimSort-style merge that merges smaller runs first. Minor speedups in most cases but I haven't tested it enough.
4. **Memory layout & cache:** Some sensitivity to variable placement and data alignment is noticeable. Any advice for robust layout-sensitive optimizations?
5. **Real-world adoption:** Even if slightly slower on purely random input (\~5%), the structured input gains are often >50%. Would such an algorithm be worth promoting or considered niche? If the hit to random input is too significant, maybe this would find a better home as an alternative like `std::structured_sort`?

I’m looking for input on:

* Algorithmic improvements, especially for the random vs structured handoff
* Practical concerns for integration into standard libraries
* Benchmark methodology for mixed input distributions
* Real-world test datasets that might showcase advantages

Code and full details are available here: [https://github.com/lewj85/jessesort](https://github.com/lewj85/jessesort)

Thanks

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

Apache Fory C++: Fast Serialization with Shared/Circular Reference Tracking, Polymorphism, Schema Evolutionn and up to 12x Faster Than Protobuf

We just released Apache Fory Serialization support for c++:

https://fory.apache.org/blog/fory\_cpp\_blazing\_fast\_serialization\_framework

Highlights:

1. Automatic idiomatic cross-language serializaton: no adapter layer, serialize in C++, deserialize in Python.
2. Polymorphism via smart pointers: Fory detects std::is_polymorphic<T> automatically. Serialize through a shared_ptr<Animal>, get a Dog back.
3. Circular/shared reference tracking: Shared objects are serialized once and encoded as back-references. Cycles don't overflow the stack.
4. Schema evolution: Compatible mode matches fields by name/id, not position. Add fields on one side without coordinating deployments.
5. IDL compiler (optional): foryc ecommerce.fdl --cpp_out ./gen generates idiomatic code for every language from one schema. Generated code can be used as domain objects directly
6. 6. Row format: O(1) random field access by index, useful for analytics workloads where you only read a few fields per record.

Throughput vs. Protobuf: up to 12x depending on workload.

GitHub: https://github.com/apache/fory

C++ docs: https://fory.apache.org/docs/guide/cpp

I’d really like critical feedback on API ergonomics, and production fit.

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

Implementing your own asynchronous runtime for C++ coroutines

Hi all! Last time I wrote a blog post about writing your own C++ coroutines. Now, I wanted to highlight how to write your own C++ asynchronous runtime for your coroutines.

https://rhidian-server.com/how-to-create-your-own-asynchronous-runtime-in-c/


Thanks for reading, and let me know if you have any comments!

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

Serialization by contract and IPC
https://github.com/amarmer/SerializationByContract

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

C++26 Reflection + PyBind11 for algo trading
https://github.com/profitviews/merton-market-maker

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