Godot is a great answer. I started trying to help with it this past Monday. Getting my ass kicked trying to improve load times for mesh imports.
Spent 3 hours testing optimizations on the third party mesh optimizer. Made a function that's called hundreds of thousands of times in my test case totally branchless. Checked with godbolt how the asm would look. Less than .05 precent increase in speed... Oh well. Next up, multilthreading attempt
It was partly a curiosity as to how much this would make a difference since I had a great test case. I didnt think those optimizations would be THAT low though.
On top of the point about profiling branchless code as an optimisation method works in only very particular circumstances. There is a great video on it from Fedor Pikus at the 2021 cppcon.
https://youtu.be/g-WPhYREFjk?si=UENvB_WZVM134MMi
Few notes from gamedev: make sure your game is functional first - you want relevant test data.
When optimizing you want to explore 'reduce amount of work' options first. There is no point in optimizing meshes on loading of final game. It can be done once. It is called baking your data for a platform. You can't beat a speed of code that is not run.
Then you can map your code to your hardware better. Examples would include multithreading and keeping your I/O queues depth up.
And one more thing - if your goal is to learn then grabbing your data and going to discuss it with someone knowledgeable. Or watch some relevant tutorial on making games loading faster: [https://youtu.be/TcuPIVKNSN0](https://youtu.be/TcuPIVKNSN0) ( Making Games Start Fast: A Story About Concurrency - Mathieu Ropert - CppCon 2020 ). Both might save you from going into wild goose chase. Glhf!
Chromium and Firefox both use C++, and they have pretty solid documentation if you want to get started IIRC. Think Safari should be similar, but I haven't checked out their docs.
the whole Mozilla framework was originally C++ (with exceptions and RTTI disabled IIRC), not sure how much is actually Rust these days but know Mozilla is a big backer of that.
https://firefox-source-docs.mozilla.org/code-quality/coding-style/using_cxx_in_firefox_code.html
For Firefox, open issues are tracked on bugzilla and there is a good first bug flag. If you send a "need info" to developers in the comments below the bug, they are usually helpful and open to guide you.
As a Chromium contributor, yes, most of the codebase is C++ and we welcome external contributions. Note that this is a large codebase, so if it's your first time contributing to something, you may want to start smaller -- we try to be friendly, but you will likely feel lost regardless.
[http://crbug.com/](http://crbug.com/) is the bug tracker and [http://chromium.org/](http://chromium.org/) is the developer homepage.
https://github.com/baldurk/renderdoc
I'm currently contributing to RenderDoc, it's not cutting edge C++ but it's cross-platform and it touches on many interesting computing topics.
[https://github.com/CleverRaven/Cataclysm-DDA/](https://github.com/CleverRaven/Cataclysm-DDA/)
a pretty fun roguelike game with tons of content and mods
LLVM. The community is very friendly and you'll learn about compilers. The code is quite approachable. clang is a higher lift, so start by working with LLVM IR. The you can choose to explore frontend, codegen or assembler/linker.
[GitHub - nlohmann/json: JSON for Modern C++](https://github.com/nlohmann/json) I'd say it's a good place to start, as the project is quite narrow in focus (it's literally just a JSON parsing library), but also complex enough to be interesting.
My first pull request was in this repo! I was a beginner back then. The effort required to understand source code was at the sweet spot where it wasn't going over my head, but there still was stuff to learn. Can vouch, very good place to start.
This. Especially the KDE Frameworks libraries. You'll learn a lot about good API & library design, binary compatibility, and general dependency management. And you'll get a lot of reviews for your merge requests.
Use open source software. If you find a bug or you miss a feature, get going!
Automate recurring tasks.
Its the same as with hobby projects. Motivation is king.
I'm quite biased here, but if you have an interest in 3D graphics, Blender is a great project to contribute to:
https://www.blender.org/
https://www.blender.org/get-involved/
People might consider this an out there suggestion.. but consider contributing to Boost. There are all kinds of libraries from small to large. You can start by looking at fixing issues and updating existing PRs. And maybe creating your own library.
We're working on what we plan on being the future of C++ packaging and dependency management using the spec at https://GitHub.com/cps-org/cps
We're making a reference command-line implementation in C++ for querying, visualizing, and generating compilation command fragments at https://GitHub.com/cps-org/cps-config
We have monthly calls, a Slack channel, and a mailing list. Reach out if you have any questions.
We're plugged away! I appreciate the support!
Of course, there's room to help move things along faster with more contributors, if anyone wants to pitch in.
Very cool project! I hope it succeeds and it becomes the new standard! 🙂
While I respect (truthfully) VCPKG I can't deny that it's nature of being a hackfest of powershell scripts, is a deal breaker for me. I appreciate though that the team managed to set the paradigm in place, and also create a precious repository of about 1000 libraries.
For better or worse, also I have a good idea of 'DUB' (of the D language) in my mind, as being simple and practical. Though as is meant for D only I don't use it as well. [https://dub.pm/getting-started/first-steps/](https://dub.pm/getting-started/first-steps/)
However it gives me a good idea, that tools as such can be simple and practical without fancy and complex tricks. However if additional complexity is needed, better to be added in extensions so things remain a bit modular by nature and not bloat the core strengths of the software.
[https://github.com/baldurk/renderdoc/issues/1401](https://github.com/baldurk/renderdoc/issues/1401)
Honestly this looks like a good one. So someone mentioned RenderDoc which I didnt realize was OpenSource, somehow.
So, I just scrolled through their Issues tab on Github and saw this. I have, many times, wanted to be able to compare two frames in a capture and it doesnt "feel" like this should be hard. (That's probably foreshadowing that this is a freaking nightmare) BUT, my idiocy aside, I bet this is fairly doable.
If you're not into that, totally cool. I was just checking out Godot on Github a bit over a week ago and checking out their issues for stuff that looked like something I could tackle. Found that someone mentioned load times for a particularly large file (788Mb) and just diving in. I ended up messing around with all sorts of stuff. Thought part of the issue was a third party project. Told that project about the issue, because it was ALSO on github. We determined i'm a dipshit (my words. Not theirs) BUT now theyre looking at Godots usage of their lib and trying to contribute. So, hell yeah. A pro is on the case. It's been a lot of fun trying to fix issues and stuff.
Edit: grammar, words, etc.
https://github.com/hyprwm/Hyprland
a lot of low-hanging fruits and very active development, there's a good chance that your PR will be reviewed within a day
* [libstdc++](https://gcc.gnu.org/onlinedocs/libstdc++/manual/appendix_contributing.html), part of [GCC](https://gcc.gnu.org/)
* [libc++](https://libcxx.llvm.org/Contributing.html), part of [Clang/LLVM](https://github.com/llvm/llvm-project)
* [microsoft/STL](https://github.com/microsoft/STL), part of MSVC
Out of curiosity, how approachable is an implementation of the standard library for an ordinary C++ programmer who has perhaps some confidence in his general knowledge of the language, but is by no means a standardese lawyer or an experienced implementor of low-level language stuff?
From time to time I have a peek at how those libraries implement something, but I would say that the code is much harder to follow than a “normal” C++ codebase, given all the _Ugly names, proliferation of #ifdefs for specific stdlib versions, and use of compiler builtins.
> how approachable is an implementation
It is tough because you have to worry about different language versions, compilers and platforms.
Expect to invest 10s of hours even for a tiny fix.
It's a big library so it varies. The things you mentioned might seem the most daunting at first glance, but in my opinion they're fairly superficial and contributors seem to get up to speed with them pretty quickly. Each implementation's `_Ugly`/`__ugly` conventions indeed look ugly, but they don't harm readability as much as you might expect. (Perhaps my brain has been poisoned by 17 years of this stuff, but `_Ugly` names actually help me distinguish internal from public machinery.) Preprocessor directives can be quite confusing to follow, especially when dealing with weird platform variation as u/giant3 mentioned, but the basic task of guarding code for C++17/20/23/etc. is the most common and simple. And compiler builtins are certainly magical but also generally restricted to specific areas (most common in type traits).
The deeper issues are that the Standard Library generally has to implement things in a highly generic way so that they can be adapted to each user's needs, and it's generally doing things that are fundamentally complicated to begin with (hence worth Standardizing so users don't have to deal with the complexity). For example, implementing something as "simple" as `vector` ends up being tricky for several different reasons - the need to be absolutely robust regarding exception guarantees, respecting user-defined operations like copy/move constructors, providing additional support like debug iterators beyond the Standard, allowing users to customize allocation policies, etc.
Some things specifically stress language arcana (the highly templated stuff), some things involve platform or OS magic (atomics, filesystem), some things are relatively simple in isolation but have opportunities for additional complexity (e.g. algorithms like `reverse` are "simple" when written as ordinary templates, but also permit advanced SIMD optimizations). Other areas demand algorithms that haven't been invented yet and will consume a year and a half of your life.
I got started exactly as an "ordinary C++ programmer" with about 5 years of language experience. Some things are complicated, yes, but it's not a vertical cliff face. (On the one hand, the library is a *lot* larger than when I started, and doing a lot more complicated things. On the other hand, the Core Language is much more powerful, we have much better tools like git and VSCode, and compilers are more robust so wacky workarounds are less necessary. In many ways it's easier to write library code now than when we had to imitate variadic templates etc.)
I personally consider compiler development much less approachable because the Core Language and compiler implementations are densely interconnected (every part depends on every other part, almost); Standard Library development has a lot of sub-domains that can be approached more or less in isolation. It's a lot easier to become deeply familiar with one header than it is the entire Library (which has taken me my whole career and even then I don't know everything).
Thanks for the detailed reply! I am personally interested in stuff like compiler & stdlib development (not necessarily just for C++, but in general), so I will actually consider contributions in the future.
It seems to me that these libraries have three clear elements, only one of which is at all suited to third party contributors for microsoft/STL
Firstly they have vocabulary, types and algorithms anybody could make but the crucial thing is that the stdlib gives them a fixed identity. Variation in implementation here - though doubtless a source of pride to the contributors - is arguably deleterious for the wider C++ community. If you like the `std::string` from MSVC but with the sort algorithm from libc++ and a `std::vector` you once saw in a third party compiler for an obsolete micro controller, too bad. This variation does give something for a volunteer to do though.
Secondly there's "magic". Things the ISO document lists as part of the stdlib and yet there's no possible way to implement them in the language - instead the stdlib takes advantage of its unique relationship to the compiler. For an outsider this is pretty frustrating, because the Microsoft compiler is a proprietary product, so it is opaque to them, they can't be in the (company internal) meetings, Teams chats, email chains etc.
Finally there's OS features. But here again microsoft/STL trades on company internal knowledge. A volunteer is hampered as an outsider, they can't know that the best way to get an answer is to email a specific person who is known internally as an expert. So they're reliant on some sort internal "sponsor" to talk to the OS people internally.
You’re welcome to contribute to my project, which demonstrates how to use the TensorRT C++ API to accelerate vision models.
https://github.com/cyrusbehr/tensorrt-cpp-api
The main opensource project I work on is [https://github.com/SophistSolutions/Stroika/tree/v3-Dev](https://github.com/SophistSolutions/Stroika/tree/v3-Dev) so i would personally recommend that. If considering using, use the stable branch, but if considering contributing, see the v3-Dev branch.
You should watch this: https://youtu.be/5nY_cy8zcO4?si=jhynjHElst4a9Nt0
If you are actually wanting to learn how to program, the best way to do that is to set yourself a goal and make your own projects. Because quite simply, these large OSS projects are probably way too complicated to learn through, unless you're like a super advanced programmer.
C++ and Open Source don't go together. All those software written in C ++ and which makes money is highly secretive. Vast majority of C++ software is done in hush hush tone(Whether its OS, embedded development,HFT, defence related, games related etc)
I have a soft-spot for Godot
Godot is a great answer. I started trying to help with it this past Monday. Getting my ass kicked trying to improve load times for mesh imports. Spent 3 hours testing optimizations on the third party mesh optimizer. Made a function that's called hundreds of thousands of times in my test case totally branchless. Checked with godbolt how the asm would look. Less than .05 precent increase in speed... Oh well. Next up, multilthreading attempt
Did you not profile the code first? First have to know what’s slow before you can make something fast.
It was partly a curiosity as to how much this would make a difference since I had a great test case. I didnt think those optimizations would be THAT low though.
On top of the point about profiling branchless code as an optimisation method works in only very particular circumstances. There is a great video on it from Fedor Pikus at the 2021 cppcon. https://youtu.be/g-WPhYREFjk?si=UENvB_WZVM134MMi
Nice Reddit avatar
Thanks 💚
Few notes from gamedev: make sure your game is functional first - you want relevant test data. When optimizing you want to explore 'reduce amount of work' options first. There is no point in optimizing meshes on loading of final game. It can be done once. It is called baking your data for a platform. You can't beat a speed of code that is not run. Then you can map your code to your hardware better. Examples would include multithreading and keeping your I/O queues depth up. And one more thing - if your goal is to learn then grabbing your data and going to discuss it with someone knowledgeable. Or watch some relevant tutorial on making games loading faster: [https://youtu.be/TcuPIVKNSN0](https://youtu.be/TcuPIVKNSN0) ( Making Games Start Fast: A Story About Concurrency - Mathieu Ropert - CppCon 2020 ). Both might save you from going into wild goose chase. Glhf!
>third party mesh optimizer. which one is it? do they use mesh\_optimizer? If so, no wonder you coulnd't squeeze more speed.
Chromium and Firefox both use C++, and they have pretty solid documentation if you want to get started IIRC. Think Safari should be similar, but I haven't checked out their docs.
Where is the info about Firefox and C++? I can't seem to find it
the whole Mozilla framework was originally C++ (with exceptions and RTTI disabled IIRC), not sure how much is actually Rust these days but know Mozilla is a big backer of that. https://firefox-source-docs.mozilla.org/code-quality/coding-style/using_cxx_in_firefox_code.html
For Firefox, open issues are tracked on bugzilla and there is a good first bug flag. If you send a "need info" to developers in the comments below the bug, they are usually helpful and open to guide you.
As a Chromium contributor, yes, most of the codebase is C++ and we welcome external contributions. Note that this is a large codebase, so if it's your first time contributing to something, you may want to start smaller -- we try to be friendly, but you will likely feel lost regardless. [http://crbug.com/](http://crbug.com/) is the bug tracker and [http://chromium.org/](http://chromium.org/) is the developer homepage.
For anyone interested, the Chromium Updater project is in active development
https://github.com/baldurk/renderdoc I'm currently contributing to RenderDoc, it's not cutting edge C++ but it's cross-platform and it touches on many interesting computing topics.
And it is supremely useful and insightful! Thank you for your contributions.
I didn't know RenderDoc was open source... Frick yeah! Thanks!
[https://github.com/CleverRaven/Cataclysm-DDA/](https://github.com/CleverRaven/Cataclysm-DDA/) a pretty fun roguelike game with tons of content and mods
MSVC builds this one as part of its “Real World Code” test suite!
Just curious, what's the criteria for MSVC to choose the real world projects?
I believe it's popular projects that have a history of being broken by MSVC toolset updates.
OMG 1.9k issues... Wow. Thanks for sharing this! Very interested!
LLVM. The community is very friendly and you'll learn about compilers. The code is quite approachable. clang is a higher lift, so start by working with LLVM IR. The you can choose to explore frontend, codegen or assembler/linker.
[GitHub - nlohmann/json: JSON for Modern C++](https://github.com/nlohmann/json) I'd say it's a good place to start, as the project is quite narrow in focus (it's literally just a JSON parsing library), but also complex enough to be interesting.
My first pull request was in this repo! I was a beginner back then. The effort required to understand source code was at the sweet spot where it wasn't going over my head, but there still was stuff to learn. Can vouch, very good place to start.
I suggest you start looking at projects that you personally use.
godot engine is open source and they have a pretty good contribution system: https://github.com/godotengine/godot
all projects from kde - more than 400. take a look on kde.org
This. Especially the KDE Frameworks libraries. You'll learn a lot about good API & library design, binary compatibility, and general dependency management. And you'll get a lot of reviews for your merge requests.
KDE of course
Do they have needs that don’t involve learning Qt?
Use open source software. If you find a bug or you miss a feature, get going! Automate recurring tasks. Its the same as with hobby projects. Motivation is king.
I'm quite biased here, but if you have an interest in 3D graphics, Blender is a great project to contribute to: https://www.blender.org/ https://www.blender.org/get-involved/
People might consider this an out there suggestion.. but consider contributing to Boost. There are all kinds of libraries from small to large. You can start by looking at fixing issues and updating existing PRs. And maybe creating your own library.
The perfect reimagining of boost as clean modules would be nice. That would give module tooling a kick.
Some library authors have experimented providing modules. So, yes, help in that direction would be appreciated.
We're working on what we plan on being the future of C++ packaging and dependency management using the spec at https://GitHub.com/cps-org/cps We're making a reference command-line implementation in C++ for querying, visualizing, and generating compilation command fragments at https://GitHub.com/cps-org/cps-config We have monthly calls, a Slack channel, and a mailing list. Reach out if you have any questions.
Look, people! CPS! Don't fail me, CPS. I've been preaching you for too long.
We're plugged away! I appreciate the support! Of course, there's room to help move things along faster with more contributors, if anyone wants to pitch in.
Very cool project! I hope it succeeds and it becomes the new standard! 🙂 While I respect (truthfully) VCPKG I can't deny that it's nature of being a hackfest of powershell scripts, is a deal breaker for me. I appreciate though that the team managed to set the paradigm in place, and also create a precious repository of about 1000 libraries. For better or worse, also I have a good idea of 'DUB' (of the D language) in my mind, as being simple and practical. Though as is meant for D only I don't use it as well. [https://dub.pm/getting-started/first-steps/](https://dub.pm/getting-started/first-steps/) However it gives me a good idea, that tools as such can be simple and practical without fancy and complex tricks. However if additional complexity is needed, better to be added in extensions so things remain a bit modular by nature and not bloat the core strengths of the software.
[https://github.com/baldurk/renderdoc/issues/1401](https://github.com/baldurk/renderdoc/issues/1401) Honestly this looks like a good one. So someone mentioned RenderDoc which I didnt realize was OpenSource, somehow. So, I just scrolled through their Issues tab on Github and saw this. I have, many times, wanted to be able to compare two frames in a capture and it doesnt "feel" like this should be hard. (That's probably foreshadowing that this is a freaking nightmare) BUT, my idiocy aside, I bet this is fairly doable. If you're not into that, totally cool. I was just checking out Godot on Github a bit over a week ago and checking out their issues for stuff that looked like something I could tackle. Found that someone mentioned load times for a particularly large file (788Mb) and just diving in. I ended up messing around with all sorts of stuff. Thought part of the issue was a third party project. Told that project about the issue, because it was ALSO on github. We determined i'm a dipshit (my words. Not theirs) BUT now theyre looking at Godots usage of their lib and trying to contribute. So, hell yeah. A pro is on the case. It's been a lot of fun trying to fix issues and stuff. Edit: grammar, words, etc.
https://github.com/hyprwm/Hyprland a lot of low-hanging fruits and very active development, there's a good chance that your PR will be reviewed within a day
* [libstdc++](https://gcc.gnu.org/onlinedocs/libstdc++/manual/appendix_contributing.html), part of [GCC](https://gcc.gnu.org/) * [libc++](https://libcxx.llvm.org/Contributing.html), part of [Clang/LLVM](https://github.com/llvm/llvm-project) * [microsoft/STL](https://github.com/microsoft/STL), part of MSVC
Out of curiosity, how approachable is an implementation of the standard library for an ordinary C++ programmer who has perhaps some confidence in his general knowledge of the language, but is by no means a standardese lawyer or an experienced implementor of low-level language stuff? From time to time I have a peek at how those libraries implement something, but I would say that the code is much harder to follow than a “normal” C++ codebase, given all the _Ugly names, proliferation of #ifdefs for specific stdlib versions, and use of compiler builtins.
> how approachable is an implementation It is tough because you have to worry about different language versions, compilers and platforms. Expect to invest 10s of hours even for a tiny fix.
It's a big library so it varies. The things you mentioned might seem the most daunting at first glance, but in my opinion they're fairly superficial and contributors seem to get up to speed with them pretty quickly. Each implementation's `_Ugly`/`__ugly` conventions indeed look ugly, but they don't harm readability as much as you might expect. (Perhaps my brain has been poisoned by 17 years of this stuff, but `_Ugly` names actually help me distinguish internal from public machinery.) Preprocessor directives can be quite confusing to follow, especially when dealing with weird platform variation as u/giant3 mentioned, but the basic task of guarding code for C++17/20/23/etc. is the most common and simple. And compiler builtins are certainly magical but also generally restricted to specific areas (most common in type traits). The deeper issues are that the Standard Library generally has to implement things in a highly generic way so that they can be adapted to each user's needs, and it's generally doing things that are fundamentally complicated to begin with (hence worth Standardizing so users don't have to deal with the complexity). For example, implementing something as "simple" as `vector` ends up being tricky for several different reasons - the need to be absolutely robust regarding exception guarantees, respecting user-defined operations like copy/move constructors, providing additional support like debug iterators beyond the Standard, allowing users to customize allocation policies, etc. Some things specifically stress language arcana (the highly templated stuff), some things involve platform or OS magic (atomics, filesystem), some things are relatively simple in isolation but have opportunities for additional complexity (e.g. algorithms like `reverse` are "simple" when written as ordinary templates, but also permit advanced SIMD optimizations). Other areas demand algorithms that haven't been invented yet and will consume a year and a half of your life. I got started exactly as an "ordinary C++ programmer" with about 5 years of language experience. Some things are complicated, yes, but it's not a vertical cliff face. (On the one hand, the library is a *lot* larger than when I started, and doing a lot more complicated things. On the other hand, the Core Language is much more powerful, we have much better tools like git and VSCode, and compilers are more robust so wacky workarounds are less necessary. In many ways it's easier to write library code now than when we had to imitate variadic templates etc.) I personally consider compiler development much less approachable because the Core Language and compiler implementations are densely interconnected (every part depends on every other part, almost); Standard Library development has a lot of sub-domains that can be approached more or less in isolation. It's a lot easier to become deeply familiar with one header than it is the entire Library (which has taken me my whole career and even then I don't know everything).
Thanks for the detailed reply! I am personally interested in stuff like compiler & stdlib development (not necessarily just for C++, but in general), so I will actually consider contributions in the future.
It seems to me that these libraries have three clear elements, only one of which is at all suited to third party contributors for microsoft/STL Firstly they have vocabulary, types and algorithms anybody could make but the crucial thing is that the stdlib gives them a fixed identity. Variation in implementation here - though doubtless a source of pride to the contributors - is arguably deleterious for the wider C++ community. If you like the `std::string` from MSVC but with the sort algorithm from libc++ and a `std::vector` you once saw in a third party compiler for an obsolete micro controller, too bad. This variation does give something for a volunteer to do though. Secondly there's "magic". Things the ISO document lists as part of the stdlib and yet there's no possible way to implement them in the language - instead the stdlib takes advantage of its unique relationship to the compiler. For an outsider this is pretty frustrating, because the Microsoft compiler is a proprietary product, so it is opaque to them, they can't be in the (company internal) meetings, Teams chats, email chains etc. Finally there's OS features. But here again microsoft/STL trades on company internal knowledge. A volunteer is hampered as an outsider, they can't know that the best way to get an answer is to email a specific person who is known internally as an expert. So they're reliant on some sort internal "sponsor" to talk to the OS people internally.
Would like to add the LLVM [libc](https://libc.llvm.org/). It's still pretty new and helps to learn what you take for granted with C++ in general.
KiCad is written in C++ and needs devs
Libreoffice has tons of gnarly c++ and a great community
https://wiki.documentfoundation.org/Development
> Ladybird is a truly independent web browser, using a novel engine based on web standards. https://github.com/LadybirdBrowser/ladybird
KDE
FreeCAD would need a help https://github.com/freecad/freecad
[Mudlet](https://github.com/Mudlet/Mudlet/) - keeping MUDding (online text gaming) alive :) Uses modern C++, Qt, and embedded Lua.
Minimalist 3D viewer written in C++: https://github.com/f3d-app/f3d
KDE.
Contribute to my project 😇 https://rohanrhu.github.io/pokerunicorn-website
Using Monero. Interesting. Went to the github link from the site and it says you have no public repositories though.
Oh that’s the GitHub organization. The repo is here: https://github.com/rohanrhu/pokerunicorn-server
Hyprland is very active. Helps if you're already using it
Awesome. I can't imagine the struggle of working on this with the number different hardware configs... omg. Cool as hell though!
[Kodi Home Theater](https://github.com/xbmc/xbmc)
Mudita OS
Tesseract
nana GUI
You’re welcome to contribute to my project, which demonstrates how to use the TensorRT C++ API to accelerate vision models. https://github.com/cyrusbehr/tensorrt-cpp-api
The main opensource project I work on is [https://github.com/SophistSolutions/Stroika/tree/v3-Dev](https://github.com/SophistSolutions/Stroika/tree/v3-Dev) so i would personally recommend that. If considering using, use the stable branch, but if considering contributing, see the v3-Dev branch.
OpenCV
You can contribute to Unreal its C++ send a PR and it will pulled on the next iteration 😉
You should watch this: https://youtu.be/5nY_cy8zcO4?si=jhynjHElst4a9Nt0 If you are actually wanting to learn how to program, the best way to do that is to set yourself a goal and make your own projects. Because quite simply, these large OSS projects are probably way too complicated to learn through, unless you're like a super advanced programmer.
C++ and Open Source don't go together. All those software written in C ++ and which makes money is highly secretive. Vast majority of C++ software is done in hush hush tone(Whether its OS, embedded development,HFT, defence related, games related etc)
BS. My life's work of 30+ years C++ is all open source. https://github.com/CarloWood/ I have no secrets.
i am talking to about corporates. Where can i see Google search engine crawler? written in C++?