C++ - Reddit

Solar simulator problem

Our Project
CosmoUIT - Educational 2D Solar System Simulator
5 students | C++17 + SFML 2.6.1 | Visual Studio 2022 | University project
Goal: Create a one-click executable CosmoUIT.exe with all resources bundled - a standalone simulator with realistic physics, planetary details, space missions, and educational quizzes.
---
Main Problems
1. UTF-8 BOM Nightmare
• Problem: 4000-line UI.cpp had invisible BOM bytes at start
• Error: syntax error: '?' on line 1
• Why it was hell: File looked PERFECT in Visual Studio - no visible characters, IntelliSense OK
• Cause: Used Notepad initially, which added BOM silently (0xEF 0xBB 0xBF)
• Time wasted: 2 full days
2. C++17 Deprecation
• Problem: std::randomshuffle removed in C++17
• Error: 'randomshuffle': is not a member of 'std'
• Fix: Had to use std::shuffle with modern random engine
3. SFML DLL Deployment Hell
• Problem: Build succeeded but runtime failed
• Error: sfml-graphics-d-2.dll was not found
• Issue: Debug vs Release DLL mismatch
• Goal blocked: Couldn't create standalone CosmoUIT.exe for weeks
---
Questions
1. How do you prevent BOM in C++ projects automatically?
2. Why doesn't Visual Studio warn about BOM in source files?
3. Best tools to detect encoding issues?
4. How to create a truly portable .exe with SFML on Windows?

Final Goal: We wanted a simple double-click CosmoUIT.exe that works anywhere - took us way too long to achieve.

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

Are they ruining C++?

I use C++ since 1991 as a professional developer and maybe I am getting old, but are there other people who feel that the rapid new language standards for C++ are ruining the language?

Of course there have been many good things: the STL, smart pointers, range based loops, lambda functions, std::thread / mutex / lock_guard, ... these are all good things. But already for lambdas almost each time i have to use google to find out how to use them, because i don't use them every day (what must be placed within the square brackets?).

Bad things:

std::optional makes life not better for me, never used it. std::variant, same. The new UTF-8 string type (u8""). Did you ever try to write platform independent code using std::filesystem? It is a real pain. They just should have said file names may be UTF-8 for std::filesystem and Microsoft could have converted this internally to wchar_t strings. But no. Now you have to deal with u8 strings.

coroutines: i tried to understand how to use them, but to no avail. i have the impression there are some STL classes missing around it.

Basically, I have the feeling they keep adding stuff to C++ to keep up with other modern languages, but this poisons C++. My solution is to use the basic things and avoid all the newest bells and whistles. But then you look at job offers and they want you to be proficient in C++23. Do they even know why they are asking for it?

So, am I old and rusty, or are there people out there who share the same feelings?

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

What I Learned About [no_unique_address] and Padding Reuse in C++

https://nekrozqliphort.github.io/posts/no-unique-address/

Hey everyone! It’s been a while since my last write-up. I recently spent some time looking into [[no_unique_address]], specifically whether it reliably saves space by reusing padding bytes. In a few cases, it didn’t behave quite as I expected, so I decided to dig a bit deeper.

This post is a short investigation into when padding reuse does and doesn't happen, with some concrete layout examples and ABI-level discussion.

Any feedback or corrections would be greatly appreciated!

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

Criticism of C++ (in a two-hour video)

Are the things described in this two-hour video valid criticisms of C++?

Have experienced C++ developers found ways to simplify things and make code more elegant?

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

SFINAE alternative using Lambda functions

I don't know if it is a known hack. I found it by myself while working on a hobby project.
Below is a little example that returns a type based of a certain condition, for which usually template specialization is used.

struct Foo
{
Foo() = delete;
};

template <sizet I>
using type = decltype([]() -> auto {
if constexpr (I == 4)
{
return std::declval<int>();
}
else if constexpr (I == 6)
{
return std::declval<Foo>();
}
else
{
return std::declval<float>();
}
}());

staticassert(std::issamev<type<4>, int>);

staticassert(std::issamev<type<9>, float>);

staticassert(std::issamev<type<6>, Foo>);

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

sould i change?

so not that long ago i switched from python to c cause people told me i sould learn lower level languages so i choose c but now im thinking of changing to c++ cause from what im seeing no one uses c anymore but im afraid to change cause it seems way more complicated then c or python so sould i?

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

Using CPP to Hack Denuvo
https://youtu.be/t_jyCBu0nUA

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

I wrote a tiny header-only WebSocket library in C++20 because I apparently hate myself

Hey folks 👋

I’m fully aware the world does not need another C++ WebSocket library.. but after fighting with existing ones for way too long, I ended up writing my own instead of touching grass.

It’s called wspp, and it’s a header-only, C++20 WebSocket client/server library. No Boost, no ASIO dependency soup, no macro gymnastics. Just modern C++ and a reactor-style async loop.

I’m not claiming it’s revolutionary or better than your favorite library. It’s mostly the result of:

“this should be simpler”
“why does this need 5 dependencies?”
“surely RFC 6455 isn’t that bad” (it was)

Some highlights (if you’re still reading):

Header-only (drop it in and move on)
WS and WSS (OpenSSL optional)
Async / non-blocking
Windows + Linux
Passes Autobahn tests (this surprised me the most)
Designed around C++20 instead of pretending it’s 2008

I’ve been using it for my own projects and figured I’d share it before it rots on my SSD forever. If nothing else, maybe it’s useful as:

a lightweight alternative
a reference implementation
or something to yell at in the comments 😄

Repo + examples + docs are here:
https://github.com/pinwhell/wspp

Feedback, nitpicks, “why didn’t you just use X”, or “this is terrible and here’s why” are all genuinely welcome. I’m still learning, and I’d rather hear it now than after someone builds something important on top of it.

Thanks for reading ❤️

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

Butano 21.0.0 - Modern C++ high level engine for the GBA

Hi!

Five years ago I posted the first public release of Butano, a modern C++ high level engine for the GBA. After tons of new features, bug fixes and great games made with it, today I'm releasing a new version with support for bitmap display modes. With them, all major GBA features are supported, so the engine is now somewhat finished.

It has been great working these past few years on an engine for a retro platform using modern C++ (C++11 came 10 years after the GBA release). I hope people continue to use it to make great games for the GBA in the future.

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

Hahaha: Lightweight C++ ML Library - Easy Tensor Ops & Autograd for All Levels!

Hi everyone!

I'm Napbad (with my collaborator JiansongShen), and we're both not C++ experts, but we've been building Hahaha - a lightweight C++23 library for numerical computing and machine learning basics. It's like a mini PyTorch in C++, with tensor ops, auto-differentiation, neural layers, and a simple ML training CLI demo. We started this as a learning project, and now we want to share it with fellow beginners!

Why we think it is great for C++ newbies?

Hands-On Learning: Core features like broadcasting, sum/reduce, and backward propagation are implemented cleanly. You can dive into the code to see how ML works under the hood - no black boxes!
Documented Decisions: Check our dev docs (https://jiansongshen.github.io/HahahaDevDocument/) - we logged every architecture choice, from adding CI/CD to choosing Meson/CMake. It's like a "how-to-build-a-project" guide.
Engineering Best Practices: We gradually added pro features: GitHub Actions CI with 80%+ line coverage (forced!), clang-tidy/format, Doxygen API docs (live at [https://napbad.github.io/Hahaha/](https://napbad.github.io/Hahaha/?referrer=grok.com)), and Docker for easy setup. Perfect for learning modern workflows without overwhelm.
Newbie-Friendly: Simple API (e.g., tensor creation with init lists), and we're open to PRs - even small ones like fixing typos or adding tests. No gatekeeping!

For more experienced devs (veteran in C++ or ML): We've got a solid foundation with C++23 features, templates for generics, and recent additions like CMake support and optimized error handling. We're aiming to expand with more optimizers (e.g., Adam) and GPU acceleration. Could you please provide some suggestions (if it doesn't take up your time)? Your input on performance tweaks or advanced features would be awesome!

Repo: https://github.com/Napbad/Hahaha (Apache 2.0 license - help us grow!)

We've got a task roadmap in docs (e.g., adding more optimizers like Adam), and we're committed to long-term maintenance. If you're learning C++ and interested in ML, fork it, run the autograd demo or visualizer, or suggest features. Questions? DM me or open an issue - we're super friendly!

What do you think? Any tips for us beginners? 😊

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

My C++ compiler just wrote its own fan-fiction (inference at compile-time)

Not really, but at least it generated its own main characters.

I've been obsessed with pushing language models into places they don't belong. Last summer it was a 1KB bigram model for the NES written in 6502 assembly. This week, I decided that even 1983 hardware was too much runtime for me.

So I built a bigram language model that runs entirely during the C++ compilation phase.

Technically it's a Markov chain implemented via constexpr and template metaprogramming. The model's weights are hardcoded in an array. A fun part was implementing the random number generator: since compilers are (mostly) deterministic (rightfully so), I hashed __TIME__ and __DATE__ using an FNV-1a algorithm to seed a constexpr Xorshift32 RNG.

When you run the binary, the CPU does zero math. It just prints a string that was hallucinated by the compiler, different at each compile.

    // this line does all the work while you're getting coffee
    static constexpr NameGenerator<15> result(seed, T); 

    int main() {
        // just printing a constant baked into the data segment
        std::cout << [result.name](http://result.name) << std::endl; 
    }

Aside from the fun of it, I hope it proves a point that the bottleneck isn't always our hardware. We have wiggle room to redefine when execution should happen, and bake deterministic inference directly into the binary.

Code is here: https://github.com/erodola/bigram-metacpp

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

C++26 - What's In It For You?

Talk from Marc Gregoire at CppCon 2025

https://www.youtube.com/watch?v=PcidhLUYp-4

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

Am I weird for using "and", "or" and "not"?

I've been working as an engineer primarily in C++ for the last 7-8 years.
I've only worked at small companies, so nobody really reviews my code.
I recently realized that using "and", "or" and "not" instead of "&&", "||" and "!" is not very common and is not considered best practice.
Would this be discouraged at a bigger company?

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

No compiler implements std linalg

Tested in visual 2026 with std latest and several other compilers in godbolt with the appropriate c++2026 or latest options, no one accepts #include <linalg>. Did I miss something or no compiler does implement std linalg yet ? (Out of curiosity, as it's really not urgent, it's not like blas/lapack etc are not around since decades.)

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

I got paid minimum wage to solve an impossible problem using C++ (and accidentally learned why most algorithms make life worse)
https://tiespetersen.substack.com/p/i-got-paid-minimum-wage-to-solve

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

C++23: An Overview of Almost All New and Updated Features

Talk from Marc Gregoire at CppCon 2023

https://www.youtube.com/watch?v=Cttb8vMuq-Y

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

Clang Hardening Cheat Sheet - Ten Years Later
https://blog.quarkslab.com/clang-hardening-cheat-sheet-ten-years-later.html

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

Template Deduction: The Hidden Copies Killing Your Performance (Part 2 of my Deep Dives)
https://0xghost.dev/blog/template-parameter-deduction/

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

New C++ Conference Videos Released This Month - January 2026

**CppCon**

2025-12-29 - 2026-01-04

* Cache-Friendly C++ - Jonathan Müller - [https://youtu.be/g\_X5g3xw43Q](https://youtu.be/g_X5g3xw43Q)
* 15 Years Doing C++ Standardization Work: A Personal Retrospective - Nevin Liber - [https://youtu.be/SGiwC\_-c6xo](https://youtu.be/SGiwC_-c6xo)
* API Structure and Technique: Learnings from C++ Code Review - Ben Deane - [https://youtu.be/dLsZ3t\_kG1U](https://youtu.be/dLsZ3t_kG1U)
* How to Tame Packs, std::tuple, and the Wily std::integer\_sequence - Andrei Alexandrescu - [https://youtu.be/X\_w\_pcPs2Fk](https://youtu.be/X_w_pcPs2Fk)
* Zero-Overhead Abstractions: Building Flexible Vector Math Libraries with C++20 Concepts and Customization Points - Greg von Winckel - [https://youtu.be/w4Vx3yFofWM](https://youtu.be/w4Vx3yFofWM)

**C++Now**

2025-12-29 - 2026-01-04

* Lightning Talk: Ship Comms - How do They Work? - Matt Kulukundis - [https://youtu.be/RFvnXCHS57M](https://youtu.be/RFvnXCHS57M)
* Lightning Talk: Immovable C++ Objects? In My Vector? - It's More Likely Than You Think - Robert Leahy - [https://youtu.be/Si2OGDvI4aI](https://youtu.be/Si2OGDvI4aI)
* Lightning Talk: Hilbert's Hotel - Counting to Infinity and Beyond - Tobias Loew - [https://youtu.be/XUJ65o8N0hs](https://youtu.be/XUJ65o8N0hs)

**ACCU Conference**

2025-12-29 - 2026-01-04

* (Re-)Learn C++ by Example - Frances Buontempo - [https://youtu.be/-iMqnEj0vX0](https://youtu.be/-iMqnEj0vX0)
* Card Magic and True Randomness - Ed Brims - [https://youtu.be/POMZxVoGA9g](https://youtu.be/POMZxVoGA9g)
* Unpopular Opinion? - Python Typing Is Not Worth It - Diego Rodriguez-Losada - [https://youtu.be/AUQDHZMLZAU](https://youtu.be/AUQDHZMLZAU)

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

Looking for worthy software architecture courses

I am a C++ developer with 5 years experience now and I want to shift my focus to software architecture with the backing of my employer.
So I am looking for a good course/training. It doesn't need to be C++ focused but since I always worked in C++ this is the place to ask for me.
When looking around I find a lot of stuff I am not sure if its valid, e.g. AI experts giving architecture courses or "iSAWB - International Software Architecture Qualification Board". From my point of view the most valid experience I would gain from an experienced architect itself, but I don't know how to find that.

Did anyone take courses/training that were valuable its price or do you have any other tips for the path to an software architect?



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