C++ - Reddit

looking for a technical person to build an open-source CAD prototype.

im a final year undergrad mechanical engineer working on a small and open-source parametric CAD prototype software for the past 1 year. some stuff which I have built have attracted small MSMEs and other founders who are working on text-to-CAD and generative CAD.

the goal is not a solidworks or any other CAD software replacement, but a clean and a fundamental approach to CAD. some of the features include parametric design and gd&t etc. i need someone who has a bit of CAD knowledge and the problems faced in the CAD software industry also some other stuff mentioned below.

current focus:
- parametric solid modeling (small scope)
- clean geometry core (likely opencascade / c++ or rust)
- simple architecture

i’m looking for a technical/core contributor who enjoys:
- computational geometry
- cad kernels / brep / csg
- c++ or rust systems work
- building things from first principles

this is open-source first, no hype and no guaranteed money in the beginning.

if this sounds interesting, comment or dm me with:
what you’ve built
what part you’d like to work on
happy to share more details privately.

ps: this is not just some text-to-CAD idea or where you inject AI/LLMs wherever you get to in this. i need someone who is really interested in building from scratch and especially who focuses on their fundamentals.

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

Boost::MSM New C++17 back-end with significantly improved compilation times and new features

Hi reddit,

I'm excited to announce that a new back-end has been released for MSM in Boost version 1.90!

This new back-end requires C++17, below are the most noteworthy features:

Significantly improved compilation times and RAM usage
It compiles up to 10x faster and uses up to 10x less RAM for compilation than the old back-end by utilizing Boost's Mp11 library, which provides excellent support for metaprogramming with variadic templates.
In my benchmarks it even surpasses the compile time of SML, compiling up to 7 times faster and using up to 4 times less memory when building large hierarchical state machines.

Support for dependency injection
It allows the configuration of a context, of which an instance can be passed to the state machine at construction time. This context can be used for dependency injection, and in case of hierarchical state machines it is accessible from all sub state machines.

Access the root state machine from any sub state machine
When hierarchical state machines are used, we often have the need to access the upper-most, "root" state machine from any sub state machine. For example to trigger the processing of events further up in our state machine hierarchy.
For this need the back-end supports the configuration of the upper-most state machine as a root_sm. Similar to the context, the root state machine is accessible from all sub state machines.

New universal visitor API
The visitor functionality has been reworked, the result being a universal visitor API that supports various modes to traverse through a state machine's states:

Ability to select either only the currently active states or all states
Visit the sub state machines recursively (in DFS mode) or visit only the immediate sub states & sub machines without recursion

This API can be utilized for many advanced use cases, and the back-end uses it extensively in its own implementation. For example for the initialization of the context parameter in all sub state machines.

Benchmarks, the description of further features and instructions how to use the new MSM back-end are available in the MSM documentation.

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

How to make my C++ project portable.

So about 15 years ago when I was at ITT Tech, I made a simple project. Basically a Mega Man 2 BGM selection menu. I ran into 2 issues when I actually presented my project.

\#1 I tried to be clever and assign the file directory to my thumb drive. At the time it was my D: drive. When I went to present the project, the computer reassigned my thumb drive's letter because the presenting computer (unbeknownst to me) already had a D: drive. So the program broke because it couldn't reference the locations of the music files it was playing. Ok no problem. I grab my own laptop and continue on.

\#2 A few weeks ago, I go back and take a look at the program. My son is taking a computer science class in high school, and I want to show him what I was doing when I started getting into programming. Kinda an inspiration, idea jogging type of thing. So I go to load the program. I start researching how to fix the reference issue. Ok I got that. Cool so I can now send my program to him, and my own high school buddy who is getting into programming himself a little bit.

They get the file and try to run the exe. They get 4 errors:
\-"The code execution cannot proceed because MSVCP140D.dll was not found. Reinstalling the program may fix this problem."

\-"The code execution cannot proceed because VCRUNTIME140D.dll was not found. Reinstalling the program may fix this problem."

\-"The code execution cannot proceed because VCRUNTIME140_1D.dll was not found. Reinstalling the program may fix this problem."

\-"The code execution cannot proceed because ucertbased.dll was not found. Reinstalling the program may fix this problem."


There's nothing to install. It's just an executable compiled by Visual Basic compiler. Maybe that's the problem. How do I get these 4 files, and how can I send them in such a way that my program can be run (or installed to run) on another computer. I'm guessing I have the files on my laptop because they came with Visual Basic? I'm not sure, but it seems like a big ask to have end users download Visual Basic just to run an exe.

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

C++26 Reflection appreciation post

I have been tinkering with reflection on some concrete side project for some times, (using the Clang experimental implementation : https://github.com/bloomberg/clang-p2996 ) and I am quite stunned by how well everything clicks together.
The whole this is a bliss to work with. It feels like every corner case has been accounted for. Every hurdle I come across, I take a look at one of the paper and find out a solution already exists.

It takes a bit of getting used to this new way of mixing constant and runtime context, but even outside of papers strictly about reflection, new papers have been integrated to smooth things a lot !

I want to give my sincere thanks and congratulations to everyone involved with each and every paper related to reflection, directly or indirectly.

I am really stunned and hyped by the work done.

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

Parallel C++ for Scientific Applications: Introduction to Parallelism
https://www.youtube.com/watch?v=kA7A5sWFstw

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

What makes a game tick? Part 8 - Data Driven Multi-Threading Implementation · Mathieu Ropert
https://mropert.github.io/2025/12/11/making_games_tick_part8/

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

The State of C++ 2025 (JetBrains survey)
https://lp.jetbrains.com/the-state-of-cpp-2025/

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

Show and Tell I optimized my Order Matching Engine by 560% (129k → 733k ops/sec) thanks to your feedback

Hey everyone,

A while back I shared my C++ Order Matching Engine here and got some "honest" feedback about my use of std::list and global mutexes.

I took that feedback to heart and spent the last week refactoring the core. Here are the results and the specific optimizations that worked:

The Results:

Baseline: \~129,000 orders/sec (MacBook Air)
Optimized: \~733,000 orders/sec
Speedup: 5.6x

The Optimizations:

1. Data Structure: `std::list` -> `std::deque` + Tombstones
Problem: My original implementation used std::list to strictly preserve iterator validity. This killed cache locality.
Fix: Switched to `std::deque`. It offers decent cache locality (chunked allocations) and pointer stability.
Trick: Instead of erase() (which is O(N) for vector/deque), I implemented "Tombstone" deletion. Orders are marked active = false. The matching engine lazily cleans up dead orders from the front using pop_front() (O(1)).
2. Concurrency: Global Mutex -> Sharding
Problem: A single `std::mutex` protected the entire Exchange.
Fix: Implemented fine-grained locking. The Exchange now only holds a Shared (Read) lock to find the correct OrderBook. The OrderBook itself has a unique mutex. This allows massively parallel trading across different symbols.
3. The Hidden Bottleneck (Global Index)
I realized my cancelOrder(id) API required a global lookup map (`OrderId` \-> `Symbol`) to find which book an order belonged to. This map required a global lock, re-serializing my fancy sharded engine.
Fix: Changed API to cancelOrder(symbol, id). Removing that global index unlocked the final 40% performance boost.

The code is much cleaner now

I'd love to hear what you think of the new architecture. What would you optimize next? Custom Allocators? Lock-free ring buffers?

PS - I tried posting in the showcase section, but I got error "unable to create document" (maybe because I posted once recently, sorry a little new to reddit also). If anything is wrong with post, like wrong section etc. Please let me know how to fix it.

Github Link - https://github.com/PIYUSH-KUMAR1809/order-matching-engine

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

How Modern C++ Parses a Word Document in a Clean Functional Pipeline

Working with old document formats often turns into archaeology — XML digging, platform-specific hacks, or very verbose parsing chains.

But modern C++20 allows a surprisingly clean, composable approach.

Here’s what a full MS Word (.doc or .docx) parsing pipeline looks like today using an operator-pipe style:

std::filesystem::path("data_processing_definition.doc")
| content_type::detector{}
| office_formats_parser{}
| PlainTextExporter()
| out_stream;

ensure(out_stream.str()) ==
"Data processing refers to the activities performed on raw data...";



No COM.
No platform-specific APIs.
No manual XML manipulation.
Just a functional, readable pipeline.

I'm honestly curious how other languages express a similar parsing chain.
If you work with Python, Rust, Go, Java, C#, or JS — how would you model this?

Would love to see your idiomatic equivalents.

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

I've built a text adventure game engine on top of the C++ Standard...

Why? I have no idea.

But it's a learning tool with quests and time travel and artifacts and NPC's and XP and ... well, you just have to check it out:

https://cppevo.dev/adventure

It's probably my favorite why to browse and search the standard now, but there's probably a few errors lurking in the conversion and maybe in the quests.

It's built on top of my C++ Standard -> markdown tool https://github.com/lefticus/cppstdmd and my C++ Evolution viewing tool https://cppevo.dev

Everything is cross linked where possible with other sites, and of course code samples NPCs give are linked back to Compiler Explorer.

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

Should I store a helper object as a class member or create it locally inside a method in C++?

I have a base Layer class that I expose from a DLL. My application loads this DLL and then defines its own layer types that inherit from this base class. Here is the simplified definition:

class Layer
{
public:
virtual ~Layer() {};
virtual void OnUpdate() {};
virtual void OnEvent() {};
virtual void OnRender() {};
Rescaler rescaler;
};

All other layer types in my application inherit from this class.


The Rescaler object is responsible for scaling all drawing coordinates.
The user can set a custom window resolution for the application, and Rescaler converts the logical coordinates used by the layer into the final resolution used for rendering.

This scaling is only needed during the OnRender() step and it is not needed outside rendering.

Given that:

1. the base Layer class is part of a DLL,
2. application-specific layers inherit from it,
3. Rescaler is only used to scale rendering coordinates based on user-selected resolution,

my question is:

Should Rescaler remain a member of the base Layer class, be moved only into derived classes that actually need coordinate scaling, or simply be created locally inside OnRender()?

What is the recommended design in this scenario?

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

I optimized my Order Matching Engine by 560% (129k → 733k ops/sec) thanks to your feedback

Hey everyone,

A while back I shared my C++ Order Matching Engine here and got some "honest" feedback about my use of std::list and global mutexes.

I took that feedback to heart and spent the last week refactoring the core. Here are the results and the specific optimizations that worked:

The Results:

Baseline: \~129,000 orders/sec (MacBook Air)
Optimized: \~733,000 orders/sec
Speedup: 5.6x

The Optimizations:

1. Data Structure: `std::list` -> `std::deque` + Tombstones
Problem: My original implementation used std::list to strictly preserve iterator validity. This killed cache locality.
Fix: Switched to `std::deque`. It offers decent cache locality (chunked allocations) and pointer stability.
Trick: Instead of erase() (which is O(N) for vector/deque), I implemented "Tombstone" deletion. Orders are marked active = false. The matching engine lazily cleans up dead orders from the front using pop_front() (O(1)).
2. Concurrency: Global Mutex -> Sharding
Problem: A single `std::mutex` protected the entire Exchange.
Fix: Implemented fine-grained locking. The Exchange now only holds a Shared (Read) lock to find the correct OrderBook. The OrderBook itself has a unique mutex. This allows massively parallel trading across different symbols.
3. The Hidden Bottleneck (Global Index)
I realized my cancelOrder(id) API required a global lookup map (`OrderId` \-> `Symbol`) to find which book an order belonged to. This map required a global lock, re-serializing my fancy sharded engine.
Fix: Changed API to cancelOrder(symbol, id). Removing that global index unlocked the final 40% performance boost.

The code is much cleaner now

I'd love to hear what you think of the new architecture. What would you optimize next? Custom Allocators? Lock-free ring buffers?

PS - I tried posting in the showcase section, but I got error "unable to create document" (maybe because I posted once recently, sorry a little new to reddit also)

Github Link - https://github.com/PIYUSH-KUMAR1809/order-matching-engine

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

C++ Podcasts & Conference Talks (week 50, 2025)

Hi r/cpp! Welcome to another post in this series brought to you by Tech Talks Weekly. Below, you'll find all the C++ conference talks and podcasts published in the last 7 days:

# 📺 Conference talks

# CppCon 2025

1. **"Implementing Your Own C++ Atomics - Ben Saks - CppCon 2025"** ⸱ +4k views ⸱ 04 Dec 2025 ⸱ 01h 01m 38s
2. **"The Dangers of C++: How to Mitigate Them and Write Safe C++ - Assaf Tzur-El"** ⸱ +3k views ⸱ 03 Dec 2025 ⸱ 00h 50m 09s
3. **"Building Secure C++ Applications: A Practical End-to-End Approach - CppCon 2025"** ⸱ +2k views ⸱ 05 Dec 2025 ⸱ 01h 02m 01s
4. **"Back to Basics: How to Refactor C++ Code - Amir Kirsh"** ⸱ +2k views ⸱ 08 Dec 2025 ⸱ 01h 04m 13s
5. **"Is The Future of C++ Refactoring Declarative? - Andy Soffer - CppCon 2025"** ⸱ +1k views ⸱ 09 Dec 2025 ⸱ 01h 00m 49s

# ACCU York

1. **"Agentic Debugging Using Time Travel - Greg Law - ACCU York"** ⸱ +100 views ⸱ 09 Dec 2025 ⸱ 01h 06m 26s

# LMPL 2025

1. **"\[LMPL'25\ Challenges in C++ to Rust Translation with Large Language Models: A Preliminary(…)"](https://youtube.com/watch?v=HQDxhlxE1o&utmsource=techtalksweekly&utmmedium=email) ⸱ **<100 views** ⸱ 05 Dec 2025 ⸱ 00h 18m 10s

# OOPSLA 2025

1. [**"\[OOPSLA'25\] Fuzzing C++ Compilers via Type-Driven Mutation"**](https://youtube.com/watch?v=je8uYrTNfys&utmsource=techtalksweekly&utmmedium=email) ⸱ **<100 views** ⸱ 05 Dec 2025 ⸱ 00h 14m 13s
2. [**"\[OOPSLA'25\] Fast Constraint Synthesis for C++ Function Templates"**](https://youtube.com/watch?v=6pxVhEi-bc&utmsource=techtalksweekly&utmmedium=email) ⸱ <100 views ⸱ 05 Dec 2025 ⸱ 00h 13m 28s

# 🎧 Podcasts

1. **"C++ Memory Management • Patrice Roy & Kevin Carpenter"** ⸱ GOTO ⸱ 09 Dec 2025 ⸱ 00h 32m 20s

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,500 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/1pjqqob
@r_cpp

ACCU Overload Journal 190 - December 2025
https://accu.org/journals/overload/overload190

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

A faster is-leap-year function for full-range signed 32-bit integers
https://www.benjoffe.com/fast-leap-year

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

Boost 1.90 – what to actually look at as a working C++ dev
https://www.boost.org/releases/1.90.0/

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

How do compilers execute constexpr/consteval functions when you are cross-compiling?

I assume that you can not just compile and run for the host platform, since e.g. long can have a different size on the target platform.

Can the compiler just use the type sizes of the target platform, and then execute natively?

Can this problem be solved in different ways?

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

What's better for robotics Cmake or Autotools ?

The title pretty much explains it. I recently watched CodingJesus video on the "C++ Wretch Build" (Like from Elden Ring) aka the build that will give you the least assitance to start out with but open up a lot of possibilities. I am very new to C++ and Robotics (just started with Arduino, Breadboard etc) In his video he detailed autotools was the best for getting "cracked" as a C++ developer. I want to be a robotics electrical engineer and I am aware that maybe some of his suggestions for this wretch build were maybe specific to developers.I asked chatgpt and google and the AI given answer was CMake was overwhelmingly better but I saw a lot of debate on reddit.


Context: This is his suggested "build"🌑

Wretch Starter Kit

Build System: Autotools
Debugger: GDB
IDE: Vim + tmux
Compiler: GCC
Linter: clang-tidy
Formatter: clang-format
Profiler: perf
git






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

Visual Studio option /RTCc - what is its purpose?

Why does it exist?
Documentation says that it “Reports when a value is assigned to a smaller data type and results in a data loss.”
Except it is not what it actually does.
This runtime check reports a failure if discarded by a cast top bits are not the same (all 0 or all 1).
It is not a useful range check for either signed or unsigned types, almost as if someone did it to offend both equally...
I just can't understand why such an utterly useless option has been kept in a compiler for decades.
Am I missing something here?

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

The Real Problem with C++: Mindset, Modern Practices and Safer Code – Interview with Klaus Iglberger
https://youtu.be/cjO76ygwGdA?si=5BVhhGMtDmLNB3gl

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