-
Stay up-to-date with everything C++! Content directly fetched from the subreddit just for you. Join our group for discussions : @programminginc Powered by : @r_channels
Latest News From Upcoming C++ Conferences (2026-01-28)
**OPEN CALL FOR SPEAKERS**
* **C++Now 2026** – C++Now are looking to invite all members of the C++ community, including first time submitters, to submit session proposals for the 14th annual C++Now Conference, to be held May 4th – May 8th, 2026, in Aspen, Colorado. All submissions need to be made by February 13th! Find out more including how to submit your proposal at [https://cppnow.org/announcements/2026/01/2026-call-for-submissions/](https://cppnow.org/announcements/2026/01/2026-call-for-submissions/)
* **ADCx India 2026** – ADCx India are looking for proposals focused on educating their audience of audio software developers by 6th February. Find out more and submit your proposal at [https://docs.google.com/forms/d/e/1FAIpQLSdT\_Lyr446UU2iqmIEVsT4x47NOIarRInoQeLYWA6IEWz-jNA/viewform](https://docs.google.com/forms/d/e/1FAIpQLSdT_Lyr446UU2iqmIEVsT4x47NOIarRInoQeLYWA6IEWz-jNA/viewform)
* **(LAST CHANCE) CppCon Academy 2026** – CppCon Academy is asking for instructors to submit proposals for pre and post-conference classes and/or workshops to be taught in conjunction with next year’s CppCon 2026.
* Workshops can be online or onsite and interested instructors have until January 30th to submit their workshops. Find out more including how to submit your proposal at [https://cppcon.org/cfp-for-2026-classes/](https://cppcon.org/cfp-for-2026-classes/)
**OTHER OPEN CALLS**
* **C++Online**
* **Call For Online Volunteers** – Attend C++Online 2026 **FOR FREE** by becoming an online volunteer! Find out more including how to apply at [https://cpponline.uk/call-for-volunteers/](https://cpponline.uk/call-for-volunteers/)
* **Call For Online Posters** – Get a **FREE** ticket to C++Online 2026 by presenting an online poster in their virtual venue which can be on any C++ or C++ adjacent topic. Find out more and apply at [https://cpponline.uk/posters](https://cpponline.uk/posters)
* **Call For Open Content** – Get a **FREE** ticket to C++Online 2026 by…
* Presenting a talk, demo or workshop as open content at the start or end of each day of the event. Find out more and apply at [https://cpponline.uk/call-for-open-content/](https://cpponline.uk/call-for-open-content/)
* Running a meetup or host a social event like a pub quiz or a tetris tournament. Find out more and apply at [https://cpponline.uk/call-for-meetups/](https://cpponline.uk/call-for-meetups/)
* **ACCU on Sea Call For Reviewers Open** – ACCU on Sea are looking for people to review their talks to help shape their programme. Visit [https://speak.accuonsea.uk/](https://speak.accuonsea.uk/) and make or login to your account to participate!
**TICKETS AVAILABLE TO PURCHASE**
The following conferences currently have tickets available to purchase
* **C++Online (11th – 13th March)** – Tickets are now open at [https://cpponline.uk/registration/](https://cpponline.uk/registration/) and include a brand new £50 Indie/Individual ticket which means **most people can attend for 50% less compared to last year!** In addition, the conference will have more content than in the previous two years!
* **ADCx India (29th March)** – Early bird tickets are now available at [https://www.townscript.com/e/adcxindia26](https://www.townscript.com/e/adcxindia26) until 20th February
* **CppNorth/NDC Toronto (5th – 8th May)** – Early bird tickets are open and can be purchased at [https://ndctoronto.com/tickets](https://ndctoronto.com/tickets) until 16th February
* **ACCU on Sea (15th – 20th June)** – You can buy super early bird tickets at [https://accuconference.org/booking](https://accuconference.org/booking) with discounts available for ACCU members.
**OTHER NEWS**
* **(NEW) C++Online Sessions Announced** – C++Online have announced 19 of the 25 main conference sessions that will take place at C++Online. Find out more including how you can attend for only £45 at [https://cpponline.uk/cpponline-2026-sessions-accepted/](https://cpponline.uk/cpponline-2026-sessions-accepted/)
* **(NEW) ADC 2026 Announced** – The 11th annual
C++26 Reflection: Autocereal - Use the Cereal Serialization Library With Just A #include (No Class Instrumentation Required)
I ran this up to show and tell a couple days ago, but the proof of concept is much further along now. My goal for this project was to allow anyone to use Cereal to serialize their classes without having to write serialization functions for them. This project does that with the one exception that private members are not being returned by the reflection API (I'm pretty sure they should be,) so my private member test is currently failing. You will need to friend class cereal::access in order to serialize private members once that's working, as I do in the unit test.
Other than that, it's very non-intrusive. Just include the header and serialize stuff (See the Serialization Unit Test Nothing up my sleeve.
If you've looked at Cereal and didn't like it because you had to retype all your class member names, that will soon not be a concern. Writing libraries is going to be fun for the next few years!
https://redd.it/1qq2npd
@r_cpp
Spinning around: Please don't! - siliceum
https://www.siliceum.com/en/blog/post/spinning-around/
https://redd.it/1qqyv6s
@r_cpp
C++ Modules are here to stay
https://faresbakhit.github.io/e/cpp-modules/
https://redd.it/1qqn98t
@r_cpp
RustyPP: A C++20 library and Clang tool to enforce Rust-like safety and mutability.
Find the source here!: https://github.com/I-A-S/RustyPP
Hey folks, first of all to the mods, this post is strictly hand written, not an AI generated ounce in here 😂
I recently started learning Rust and really liked the borrow checking mechanism and more importantly the "immutable by default" aspect (among a lot more actually).
With Microsoft putting Rust in the Windows kernel and Linus approving it for use in the Linux kernel, let's admit it, Rust is becoming an avengers level threat to C++. For a good reason, in this day and age, security and safety has become exponentially more important.
My goal is promote (and enforce using rustypp-validator), the use of good aspects of Rust to C++.
Here's what RustyPP currently offers:
1) Single header include: rustypp.hpp (this gives you Mut, Const, Ref, MutRef, Result and basic optional type aliases u8, i32 etc.)
2) rustypp-validator: This a standalone C++ written executable embedding clang to enforce the "safe" coding practices.
3) rustypp-vscode: VSCode extension to give you validator checks in real time as you type
following are planned but not available yet:
1) CLion extension
2) RustyPP transpiler
RustyPP is still v0.1.0 btw so the API is not final is subject to changes (tho ofc I will only add breaking changes if the benefit outweighs the cost)
My hope is to make C++ codebases more secure (and standardized). I love cpp, instead of making Rust my daily driver, I'm trying to bring the genuinely good aspects of Rust to cpp.
Project is released under Apache v2.
Any and all feedback is welcome!
https://redd.it/1qlrx75
@r_cpp
Modern C++ use in Chromium
https://chromium.googlesource.com/chromium/src/+/main/styleguide/c++/c++-features.md#modern-c_use-in-chromium
https://redd.it/1ql6g76
@r_cpp
HPX Tutorials: Vectorization in HPX
https://www.youtube.com/watch?v=9OPFH9HbEgg
https://redd.it/1qkwp6x
@r_cpp
StockholmCpp 0x3B: Intro, Info and the Quiz
https://youtu.be/kJZ5_X7D3z8
https://redd.it/1qksmi4
@r_cpp
Time in C++: C++20 Brought Us Time Zones
https://www.sandordargo.com/blog/2026/01/21/clocks-part-8-cpp20-timezones
https://redd.it/1qkj3ru
@r_cpp
Żmij 1.0 released: a C++ double-to-string library delivering shortest correctly-rounded decimals ~2.8–4× faster than Ryū
https://github.com/vitaut/zmij/releases/tag/v1.0
https://redd.it/1qjvkpg
@r_cpp
whats with the hate for std lib and boost?
I kept hearing that some here don’t like the std lib, boost too. Why? I’m curious as a beginner who happens to learn some std stuff just to get my feet wet on leetcoding.
https://redd.it/1qjrlok
@r_cpp
XRP x Boost.Asio
https://github.com/XRPLF/rippled/blob/develop/src/xrpld/app/misc/NetworkOPs.cpp
https://redd.it/1qj1yu7
@r_cpp
C++ Performance Tips: Cutting Down on Unnecessary Objects
https://www.youtube.com/watch?v=-qj_WGf5n_I
https://redd.it/1qj78rm
@r_cpp
we can simply add N characters without first creating a string with them
// Instead of creating a string with 10 'a' characters and adding
... + text + std::string{10, 'a'} + ...
// we use a string expression that simply places 10 'a' characters into the result
... + text + expr_pad<char>{10, 'a'} + ...
The [simstr](https://github.com/orefkov/simstr) library already has many such "smart" string expressions out of the box - for example, joining strings from a container, conditional selection from two expressions, replacing substrings. There are string expressions that take a number and place their decimal or hexadecimal representation into a string (for the decimal representation, `operator+` is specially overloaded for numbers and you can simply write `text + number`).
Using [this library](https://github.com/orefkov/simstr), the code for working with strings will be easier to write, and it will work faster.
The acceleration of string operations has been confirmed by [many benchmarks](https://orefkov.github.io/simstr/results.html).
# Usage examples
# Adding strings with numbers
std::string s1 = "start ";
int i;
....
// Was
std::string str = s1 + std::to_string(i) + " end";
// Became
std::string str = +s1 + i + " end";
`+s1` \- converts `std::string` into an object - a string expression, for which there is an efficient concatenation with numbers and string literals.
According to benchmarks, [acceleration is 1.6 - 2 times](https://orefkov.github.io/simstr/results.html#bs70109915512075798510).
# Adding strings with numbers in hex format
....
// Was
std::string str = s1 + std::format("0x{:x}", i) + " end";
// Became
std::string str = +s1 + e_hex<HexFlags::Short>(i) + " end";
Acceleration in [**9 - 14 times!!!**](https://orefkov.github.io/simstr/results.html#bs146911715078927772520)
# Adding multiple literals and searching in std::string_view
// It was like this
size_t find_pos(std::string_view src, std::string_view name) {
// before C++26 we can not concatenate string and string_view...
return src.find("\n- "s + std::string{name} + " -\n");
}
// When using only "strexpr.h" it became like this
size_t find_pos(ssa src, ssa name) {
return src.find(std::string{"\n- " + name + " -\n"});
}
// And when using the full library, you can do this
size_t find_pos(ssa src, ssa name) {
// In this version, if the result of the concatenation fits into 207 characters, it is produced in a buffer on the stack,
// without allocation and deallocation of memory, acceleration is several times. And only if the result is longer than 207 characters -
// there will be only one allocation, and the concatenation will be immediately into the allocated buffer, without copying characters.
return src.find(lstringa<200>{"\n- " + name + " -\n"});
}
`ssa` \- alias for `simple_str<char>` \- analogue of `std::string_view`, allows you to accept any string object as a function parameter with minimal costs, which does not need to be modified or passed to the C-API: `std::string`, `std::string_view`, `"string literal"`, `simple_str_nt`, `sstring`, `lstring`. Also, since it is also a "string expression", it allows you to easily build concatenations with its participation.
According to measurements, [acceleration is 1.5 - 9 times](https://orefkov.github.io/simstr/results.html#bs68116594352702954700).
You can see more examples on [GitHub](https://github.com/orefkov/simstr).
https://redd.it/1qiyxis
@r_cpp
factors at play:
We approached the problem anew, and fresh eyes quickly saw several areas for improvement that had nothing to do with the implementation language per se.
Other improvements came about because we were using a different language with its own idioms, strengths, and weaknesses that forced some new thinking.
We rewrote the C++ version to incorporate those improvements and to backport some of the new ideas from using Rust.
Writing solutions to the same problem in multiple languages has significant benefits, but of course, it is expensive and hard to justify in commercial settings. Perhaps we should repeat this gf2 exercise in a third language someday!
For the most part, the two versions are feature equivalent (a few things are not possible in Rust). They also have very similar performance characteristics, with neither being significantly faster than the other in most scenarios.
https://redd.it/1qjbxwl
@r_cpp
Automatic Data Enumeration for Fast Collections
https://mcmichen.cc/posts/automatic-data-enumeration/
https://redd.it/1qqm4we
@r_cpp
Silent foe or quiet ally: Brief guide to alignment in C++
https://pvs-studio.com/en/blog/posts/cpp/1339/
https://redd.it/1qqz6ov
@r_cpp
Celebrating the 30-th anniversary of the first C++ compiler: let′s find the bugs in it (2015)
https://pvs-studio.com/en/blog/posts/cpp/0355/
https://redd.it/1qqe2sa
@r_cpp
Cache Explorer: a visual and interactive profiler that shows you exactly which lines of code cause cache misses
Built a visual cache profiler that uses LLVM instrumentation + simulation to show you exactly which lines cause L1/L2/L3 misses in your C and C++ code (Rust support in active development).
* Hardware-validated accuracy (±4.6% L1, ±9.3% L2 vs Intel perf)
* Source-level attribution (not just assembly)
* False sharing detection for multi-threaded code
* 14 hardware presets (Intel/AMD/ARM/Apple Silicon)
* MESI cache coherence simulation
It's like Compiler Explorer but for cache behavior, providing instant visual feedback on memory access patterns. MIT licensed, looking for feedback on what would make it more useful or even just things you like about it.
[**GitHub**](https://github.com/AveryClapp/Cache-Explorer)
https://redd.it/1qqgf5u
@r_cpp
Interactive C++ in the browser on notebook.link
quantstack/xeus-cpp" rel="nofollow">https://notebook.link/@quantstack/xeus-cpp
https://redd.it/1qlnvi5
@r_cpp
Reflection: C++’s Decade-Defining Rocket Engine - Herb Sutter - CppCon 2025
https://www.youtube.com/watch?v=7z9NNrRDHQU
https://redd.it/1ql4lrc
@r_cpp
"Just switch the compiler" - they said - Arne Mertz - Meeting C++ 2025
https://www.youtube.com/watch?v=JHhvBtEkeeo
https://redd.it/1qkuv8x
@r_cpp
📔 Create and share your C++ notebook with notebook.link 📔
https://notebook.link/
https://redd.it/1qkmrux
@r_cpp
Advice on Project/Process structure (Robotics, C++)
I'm working in the medical robotics industry. I'm facing major impostor syndrome and am looking to the community for help determining if our project structure is in line with industry standards and makes sense for our application. For context we are currently in the 'Research' phase of R&D and looking to update our current prototype with a more scale-able/testable code base.
Our project is divided into multiple independent processes connected to one another over a DDS middleware. This allows the processes to operate independently of each other and is nice for separation of concerns. It also allows us to place processes on one or multiple host hardware that can be designed specifically for those types of processes (for example we could group vision heavy tasks on a host machine designed for this, while placing our robotic controller on its own independent real-time host machine). I'm open to feedback on this architecture, but my main question for the post is related to the structure of any one of these processes.
I've created an example (structure\_prototype) on my GitHub to explain our process architecture in a detailed way. I tried to cover the workflow from component creation, to their usage in the broader context of the 'process', and even included how i might test the process itself. Our project is using C++ 17, Google C++ Style, and as of yet has not need to write any safety-critical or real-time code (due to the classification of our device).
I did not include testing of the individual components since this is out of context for what i'm asking about. Additionally, the physical file layout is not how we operate, I did this header only and in root just for this simple example. This is out of the context of what i'm asking about.
If you are so kind as to look at the provided code, I'd recommend the following order:
1. structure_prototype.h
2. test.cpp
3. main.cpp
I'm a fairly new developer, that 5 years ago, had never written a line of c++ in my life. I came into robotics via Mechanical Engineering and am in love with the software side of this field. Our team is fairly 'green' in experience which leads to my sense of impostor syndrome. I'm hoping to learn from the community through this post. Namely:
1. Is the structure defined in the provided GitHub link above even close to hitting the mark for a robotics project such as ours?
2. I mention circular dependencies. Is there a better way to handle this, or even design the process in such a way as to eliminate it?
3. I considered using a mediator pattern, but don't like how that pattern gives components access to functionality that they shouldn't have access to. I am maybe to strict about limiting scope to the minimum?
4. While the context of this question is outside of the safety-critical/real-time code I'm curious how this pattern would stack up in those worlds? How does the real time or safety critical engineer accomplish structures intended to do similar things as mine?
5. Are there question's I'm not asking that I should be?
Thank you so much if you've made it this far. I've been fairly impressed with the software community and its openness.
Cheers,
A humble robotics developer
https://redd.it/1qjxq0o
@r_cpp
C++ Low Level Projects
Hello, can anyone give me a list of cool ideas for low-level projects in C++, such as cheats, hooking libraries, obfuscators...
Thanks in advance.
https://redd.it/1qjtv3k
@r_cpp
Building Your Own Efficient uint128 in C++
https://solidean.com/blog/2026/building-your-own-u128/
https://redd.it/1qi0qv3
@r_cpp
C++ Podcasts & Conference Talks (week 4, 2025)
Hi r/cpp! Welcome to another post in this series. Below, you'll find all the c++ conference talks and podcasts published in the last 7 days:
# 📺 Conference talks
# CppCon 2025
1. **"C++ ♥ Python - Alex Dathskovsky - CppCon 2025"** ⸱ +6k views ⸱ 15 Jan 2026 ⸱ 01h 03m 34s
2. **"The Evolution of CMake: 25 Years of C++ Build Portability - Bill Hoffman - CppCon 2025"** ⸱ +4k views ⸱ 16 Jan 2026 ⸱ 01h 01m 21s
3. **"Agentic C++ Debugging Live! - Without a Safety Net - Daisy Hollman & Mark Williamson - CppCon 2025"** ⸱ +2k views ⸱ 14 Jan 2026 ⸱ 01h 06m 26s
4. **"LLMs in the Trenches: Boosting C++ System Programming with AI - Ion Todirel - CppCon 2025"** ⸱ +1k views ⸱ 19 Jan 2026 ⸱ 01h 01m 08s
5. **"Moving Complexity Down: The Real Path to Scaling Up C++ Code - Malin Stanescu - CppCon 2025"** ⸱ +1k views ⸱ 20 Jan 2026 ⸱ 01h 05m 33s
# Meeting C++ 2025
1. **"How to become obsolete - Roth Michaels - Meeting C++ 2025"** ⸱ +1k views ⸱ 16 Jan 2026 ⸱ 01h 06m 08s
2. **"Harnessing constexpr: a path to safer C++ - Mikhail Svetkin - Meeting C++ 2025"** ⸱ +600 views ⸱ 18 Jan 2026 ⸱ 01h 03m 59s
3. **"Monadic Operations in C++23 - Robert Schimkowitsch - Meeting C++ 2025"** ⸱ +600 views ⸱ 14 Jan 2026 ⸱ 00h 54m 35s
4. **"From acrobatics to ergonomics: a field report on how to Make libraries helpful - Joel Falcou"** ⸱ +100 views ⸱ 20 Jan 2026 ⸱ 01h 02m 53s
Sadly, there are new podcasts this week.
This post is an excerpt from the latest issue of ***Tech Talks Weekly*** which is a free weekly email with all the recently published Software Engineering podcasts and conference talks. Currently subscribed by +7,900 Software Engineers who stopped scrolling through messy YT subscriptions/RSS feeds and reduced FOMO. Consider subscribing if this sounds useful: *https://www.techtalksweekly.io/*
Let me know what you think. Thank you!
https://redd.it/1qj63jo
@r_cpp
Tensors now with neural networks
https://github.com/istmarc/Tenseur
https://redd.it/1qj5o45
@r_cpp
How to concatenate strings quickly? Expression Templates to the rescue!
In this short post, I want to briefly describe the "Expression Templates" technique I use in the [simstr](https://github.com/orefkov/simstr) library to speed up string concatenation. The main point is that when adding several string operands, temporary intermediate strings are not created, into which characters are sequentially added, which leads to repeated allocation and movement of characters from buffer to buffer. Instead, the length of the final result is calculated only once, space is allocated for it only once, and the characters of the operands are copied directly to the final buffer in their place.
This is achieved using so-called "string expressions".
A string expression is an object of any type that has the following methods:
size_t length() const; // Returns the length of its operand
K* place(K* ptr) const; // Places the characters of the result into the provided buffer, returns the position after them
To check that a type is a string expression, a concept is created
template<typename A>
concept StrExpr = requires(const A& a) {
typename A::symb_type;
{ a.length() } -> std::convertible_to<size_t>;
{ a.place(std::declval<typename A::symb_type*>()) } -> std::same_as<typename A::symb_type*>;
};
Then any string object that wants to be initialized from a string expression will first request its length, then allocate the necessary space, and ask the string expression to be placed in that space.
And then a little template magic. We create a template class `strexprjoin`:
template<StrExpr A, StrExprForType<typename A::symb_type> B>
struct strexprjoin {
using symb_type = typename A::symb_type;
const A& a;
const B& b;
constexpr strexprjoin(const A& a_, const B& b_) : a(a_), b(b_){}
constexpr size_t length() const noexcept {
return a.length() + b.length();
}
constexpr symb_type* place(symb_type* p) const noexcept {
return b.place(a.place(p));
}
};
As you can see, this class itself is a string expression. It stores references to two other string expressions. When its length is requested, it returns the sum of the lengths of the expressions stored in it. When asked to place characters, it first places the characters of the first expression, and then the second.
It remains to make a template addition operator for two string expressions:
template<StrExpr A, StrExprForType<typename A::symb_type> B>
constexpr strexprjoin<A, B> operator+(const A& a, const B& b) {
return {a, b};
}
Now any two objects that satisfy the string expression concept can be added, and the result will be a `strexprjoin` object, storing references to its terms: `e1 + e2 --> ej[e1, e2]`. And since this new object also satisfies the string expression concept, you can also apply addition with the next string expression: `e1 + e2 + e3 --> ej[e1, e2] + e3 --> ej[ej[e1, e2], e3]`. Thus, you can build chains of several operands.
When a string object, during initialization, requests the required length from the final result of addition operations, it will return the sum of the lengths of the operands included in it, and then sequentially place their characters into the resulting buffer.
This technology provides fast concatenation of several strings. But this technique is not limited to this. After all, a string expression can not only copy a string, but also create strings itself.
For example, you can create a string expression that generates N given characters:
template<typename K>
struct expr_pad {
using symb_type = K;
size_t len;
K s;
constexpr expr_pad(size_t len_, K s_) : len(len_), s(s_){}
constexpr size_t length() const noexcept {
return len;
}
constexpr symb_type* place(symb_type* p) const noexcept {
if (len)
std::char_traits<K>::assign(p, len, s);
return p + len;
}
};
And voila,
Implementing a Numerical Library in both C++ and Rustgf2 focuses on efficient numerical work in bit-space, where mathematical entities such as vectors, matrices, and polynomial coefficients are limited to zeros and ones.
It is available both as a C++ library and as a Rust crate with similar, though not identical, interfaces and features.
Even if you aren't involved in the mathematics of bit-space, you may find comparing the two implementations interesting.
Mathematicians refer to bit-space as GF(2)). It is the simplest Galois Field with just two elements, 0 and 1.
All arithmetic is modulo 2, so what starts in bit-space stays in bit-space. Addition/subtraction becomes the XOR operation, and multiplication/division becomes the AND operation. gf2 uses those equivalences to efficiently perform most operations by simultaneously operating on entire blocks of bit elements at a time. We never have to worry about overflows or carries as we would with normal integer arithmetic. Moreover, these operations are highly optimised in modern CPUs, enabling fast computation even on large bit-matrices and bit-vectors.
# Principal Classes & Types
The principal C++ classes and Rust types in the two versions of gf2 are:
|C++ Class|Rust Type|Description|
|:-|:-|:-|
|BitArray|BitArray|A fixed-size vector of bits.|
|BitVec|BitVec|A dynamically-sized vector of bits.|
|BitSpan|BitSlice|A non-owning view into contiguous ranges of bits.|
|BitPoly|BitPoly|A polynomial over GF(2).|
|BitMat|BitMat|A dynamically-sized matrix of bits.|
As you can see, there are is a name change to accommodate idioms in the languages; the C++ BitSpan class corresponds to the BitSlice type in Rust (C++ uses spans, Rust uses slices). There are other changes in the same vein elsewhere — C++ vectors have a size() method, Rust vectors have a len() method, and so on.
The BitArray, BitVec, and BitSpan/BitSlice classes and types share many methods. In C++, each satisfies the requirements of a BitStore concept. In Rust, they implement a BitStore trait. In either case, the BitStore core provides a rich common interface for manipulating collections of bits. Those functions include bit accessors, mutators, fills, queries, iterators, stringification methods, bit-wise operators on and between bit-stores, arithmetic operators, and more.
There are other classes and types in gf2 to support linear algebra operations, such as solving systems of linear equations, finding matrix inverses, and computing eigenvalues and eigenvectors. Among other things, the interface includes methods for examining the eigen-structure of large bit-matrices.
The BitPoly class provides methods to compute x^N mod p(x), where p(x) is a bit-polynomial and N is a potentially large integer.
The classes and types are efficient and pack the individual bit elements into natural unsigned word blocks. There is a rich interface for setting up and manipulating instances, and for allowing them to interact with each other.
The C++ library has a comprehensive long-form documentation site, its code is available here.
The Rust crate is available on crates.io, its source code is available here, and there is documentation on docs.rs. The Rust documentation is complete but a little less comprehensive than the C++ version, mainly because docs.rs does not support MathJax—a long-standing issue for scientific Rust.
All the code is under a permissive MIT license.
The C++ version predates the Rust crate. We ported to Rust manually, as, at least for now, LLMs cannot handle this sort of translation task and produce anything that is at all readable or verifiable.
As you might expect with a rewrite, the new version considerably improved on the original. There were two beneficial