-
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 (2025-04-22)
This Reddit post will now be a roundup of any new news from upcoming conferences with then the full list being available at https://programmingarchive.com/upcoming-conference-news/
If you have looked at the list before and are just looking for any new updates, then you can find them below:
C++Now - 28th April - 2nd May
Last Chance To Buy Tickets For C++Now 2025 Which Starts Next Week
Full Schedule - [https://schedule.cppnow.org](https://schedule.cppnow.org)
Information About The Conference - https://cppnow.org
Registration - [https://cppnow.org/registration](https://cppnow.org/registration)
Pure Virtual C++ - 30th April
Full Schedule Announced \- The schedule includes talks from Inbal Levi, Hana Dusikova & Sinem Akinci - [https://developer.microsoft.com/en-us/reactor/events/25184/](https://developer.microsoft.com/en-us/reactor/events/25184/)
CppNorth - 20th - 23rd July
Early Bird Pricing Has Finished \- Regular tickets are still available to purchase at [https://store.cppnorth.ca/products/cppnorth-2025](https://store.cppnorth.ca/products/cppnorth-2025)!
CppCon - 13th - 19th September
Call For Speakers Now Open! \- Interested speakers have until May 11th to submit their talks with decisions expected to be sent out on June 22nd. Find out more including how to submit your proposal at [https://cppcon.org/cfs2025/](https://cppcon.org/cfs2025/)
C++ Under The Sea - 8th - 10th October
Call For Speakers Now Open! \- Interested speakers have until June 15th to submit their talks. Find out more including how to submit your proposal at [https://cppunderthesea.nl/call-for-speakers/](https://cppunderthesea.nl/call-for-speakers/)
Meeting C++ - 6th - 8th November
Call For Speakers Now Open! \- Interested speakers have until June 4th to submit their talks. Find out more including how to submit your proposal at [https://meetingcpp.com/meetingcpp/news/items/Submit-your-talks-to-Meeting-Cpp-2025-.html](https://meetingcpp.com/meetingcpp/news/items/Submit-your-talks-to-Meeting-Cpp-2025-.html)
C++Online
C++Online On Demand & Early Access Pass Now Available \- Purchase an early access pass for £25 which will give you early access to 25 talks and 7 lightning talks. Visit [https://cpponline.uk/registration](https://cpponline.uk/registration) to purchase
ACCU
Get Early Access To ACCU 2025 Conference Videos By Joining ACCU \- All ACCU members will be eligible to get Early Access to the YouTube videos from the 2025 Conference. Find out more about the membership including how to join at [https://www.accu.org/menu-overviews/membership/](https://www.accu.org/menu-overviews/membership/)
Anyone who attended the ACCU 2025 Conference who is NOT already a member will be able to claim free digital membership.
https://redd.it/1k59xjh
@r_cpp
Will C++26 really be that great?
From the article:
C++26, which is due to be launched next year, is going to change the C++ "game".
Citadel Securities' new coding guru suggests you need to get with C++26
https://redd.it/1k59uu8
@r_cpp
which cpp game framework would be best for making games for all platform?
Hi reddit community which framework would you guys suggest if the game had to be cross compiled to ios , android, web , mac , linux, windows
https://redd.it/1k4wov8
@r_cpp
Top 100 C++ Game Engines
https://terminalroot.com/top-100-cpp-game-engines/
https://redd.it/1k4gy1x
@r_cpp
A patchwork of Clang patches
https://cor3ntin.github.io/posts/clang21/
https://redd.it/1k4gtkz
@r_cpp
Announcing Traeger: A portable Actor System for C++ and Python
I have been working for several months on a personal project that I just published:
https://github.com/tigrux/traeger
It is an Actor System for C++ with bindings for Python, Go, and C.
It is written in C++ 17 for portability, with minimal use of templates to facilitate interoperability with other languages.
It is still in an early stage, but I think it provides the basics of the Actor Model:
1. Value semantics based on Immer.
2. Serialization (json, yaml, and messagepack).
3. Scheduler, Threadpool, Promises, Actors with mailboxes and messages (sequential for writers, concurrent for readers).
4. Network transparency based on ZMQ.
It has been tested on Ubuntu >= 20.04, MacOS >= 15.3 (for both x86_64 and arm64) and Windows 11.
Please take a look, experiment, and if you like it or find it interesting, give it a star.
Thank you in advance!
https://redd.it/1k3zbkn
@r_cpp
Candidate Boost Bloom library scheduled for review May 13-22
https://github.com/joaquintides/bloom
https://redd.it/1k3jzjy
@r_cpp
Pure Virtual C++ 2025: MSVC C++23 Conformance
https://www.youtube.com/watch?v=MfYZQu9zG80
https://redd.it/1k3ib0j
@r_cpp
Reasons to use the system allocator instead of a library (jemalloc, tcmalloc, etc...) ?
Hi folks, I'm curious if there are reasons to continue to use the system (glibc) allocator instead of one of the modern high-performance allocators like jemalloc, tcmalloc, mimalloc, etc. Especially in the context of a multi-threaded program.
I'm not interested in answers like "my program is single threaded" or "never tried em, didn't need em", "default allocator seems fine".
I'm more interested in answers like "we tried Xmalloc and experienced a performance regression under Y scenario", or "Xmalloc caused conflicts when building with Y library".
Context: I'm nearing the first major release of my C++20 coroutine runtime / tasking library and one thing I noticed is that many of the competitors (TBB, libfork, boost::cobalt) ship some kind of custom allocator behavior. This is because coroutines in the current state nearly always allocate, and thus allocation can become a huge bottleneck in the program when using the default allocator. This is especially true in a multithreaded program - glibc malloc performs VERY poorly when doing fork-join work stealing.
However, I observed that if I simply link all of the benchmarks to tcmalloc, the performance gap nearly disappears. It seems to me that if you're using a multithreaded program with coroutines, then you will also have other sources of multithreaded allocations (for data being returned from I/O), so it would behoove you to link your program to tcmalloc anyway.
I frankly have no desire to implement a custom allocator, and any attempts to do so have been slower than the default when just using tcmalloc. I already have to implement multiple queues, lockfree data structures, all the coroutine machinery, awaitable customizations, executors, etc.... but implementing an allocator is another giant rabbit hole. Given that allocator design is an area of active research, it seems like hubris to assume I can even produce something performant in this area. It seems far more reasonable to let the allocator experts build the allocator, and focus on delivering the core competency of the library.
So far, my recommendation is to simply replace your system allocator (it's very easy to add -ltcmalloc). But I'm wondering if this is a showstopper for some people? Is there something blocking you from replacing global malloc?
https://redd.it/1k30fcd
@r_cpp
Come here if you need a project to get started in C++!
Hi,
Every once in a while we have posts of people asking how to get into C++, or ideas of projects they could contribute to. I'd like to try and propose something for these people.
I work on an open source game written in C++ and targeting Android devices. The game is playable but incomplete, and there is always more work to be done, and stuff that would be great but won't be a priority before long. What I propose is to provide some kind of mentoring for anyone who would want to try software development on my project.
The project: Bim! is a 2D last-man-standing arcade online game. It is in a playable state and not available in the stores yet. You can get the APK from the releases page if you want to try it out. You can do gameplay, server, client, UI, tooling... The technology stack contains Axmol, EnTT, CMake, GoogleTest, Boost, to name the most known. This is free software: AGPL 3 and CC-BY-SA. Development is done in a Linux environment.
What you get: concrete work with meaningful goals; experience in non-toy projects; feedback from a random developer with I-don't-count-anymore years of programming behind him. I used to write code reviews for fun for a couple of public projects (e.g. toml++, stevensStringLib, among others). This is the kind of feedback you could get. Bonus: you'll bring joy in the life of people who play the game ;)
Note that this is a pet project for me, so the main goal is to have fun working on it :) The exchanges will happen during my free time.
What I get: "free" workforce for my project, a way to have progress on the tasks on which I can't work, and an opportunity to become a better mentor.
I've written a couple of tasks to work on. If you're interested, pick one, and let's start a discussion!
- Use bim::table_2d in bim::arena
- Game feature: invisibility
- Enable LTO in Android release builds
- Display GeoIP-guessed country in server logs
- Add support for server stats
https://redd.it/1k2r75z
@r_cpp
Brand new CPP programmer, what am I getting into?
I'd like to start by saying I did not choose to learn C++ as my first language, it's just the language that my school is teaching us, and I (as well as the vast majority of students) don't know any others. What I want to know is, what am I getting into with this? What benefits does C++ give over Python, C, Zig, Rust, etc? How hard will it be once I get past the very basics? How hard would it be to learn Objective-C (for GNUStep and MacOS X app dev) and C afterwards? Thanks!
https://redd.it/1k2mmuq
@r_cpp
C-style with snake case mindset
About half a year ago I started writing C-style code in C++ using Pascal_Snake_Case (idk if its the real existing name) for user types and snake_case for all other stuff, and SCREAMING_SNAKE_CASE for macros or global constants.
And is actually one of the best combos I've tried so far, at least for solo projects. I mean it became so much easier to write, read and follow code, distinguish actual variable/type names even in text editors where syntax highlighting is minimal. Now when I see local variable name at start of line, I do not expect it to call methods/operators/etc., I expect it to be transformed by assignment family operators which is also reduces the amount of complexity you need to keep in your head, I mean there is no sort of little surprise or unexpected usage or smth like that. The code became predictable and solid in this way.
So I definitely recommend at least to try it. The hardest part would be to use C-style in C++ and hence removing unnecessary abstractions.
https://redd.it/1k2ga5o
@r_cpp
Best resource to polish CPP knowledge for intermediate to advanced people?
So I'm going to interview for a teaching assistant position as a programming language instructor (cpp). I've been using cpp for competitive programming for a while now and have a good grip on it but want to perfect my craft for the interview. What books would you guys recommend? Should I go through Bjarne Stroustroup's books or is there any other book you would recommend? I have around 2 weeks to prep for this interview so a smaller primer would be preferred.
https://redd.it/1k2br36
@r_cpp
Language support for object retirement?
It is normally the job of the destructor to clean an object at the end if its life, but destructors cannot report errors. There are situations where one may wish to retire an object before its destruction with a function that can fail, and after which the object should not be used any more at all.
A typical example is std::fstream: if I want to properly test for write errors, I have to close it before destruction, because there is no way to find out whether its destructor failed to close it properly. And then it feels like being back to programming in C and losing the advantages of RAII: I must not forget to close the file before returning from the middle of the function, I must not use the file after closing it, etc.
Another typical example would be a database transaction: at the end of the transaction, it can be either committed or aborted. Committing can fail, so should be tested for errors, and cannot be in the destructor. But after committing, the transaction is over, and the transaction object should not be used any more at all.
It is possible to enforce a final call to a retirement function that can fail by using a transaction function that takes a lambda as parameter like this:
client.transaction([](Writable_Database &db)
{
db.new_person("Joe");
});
This may be a better design than having a transaction object in situations where it works, but what if I wish to start a transaction in a function, and finish it in another one? What if I want the transaction to be a member of a class? What if I want to have two transactions that overlap but one is not nested inside the other?
After thinking about potential solutions to this problem, I find myself wishing for better language support for this retirement pattern. I thought about two ways of doing it.
The less ambitious solution would be to have a [[retire]] attribute like this:
class File
{
public:
File(std::string_view name);
void write(const char *buffer, size_t size);
[[retire]] void close();
};
If I use the file like this:
File file("test.txt");
file.write("Hello", 5);
file.close();
file.write("Bye", 3); // The compiler should warn that I am using the object after retirement
This would help, but is not completely satisfying, because there is no way for the compiler to find all possible cases of use after retirement.
Another more ambitious approach would be to make a special "peaceful retirement" member function that would be automatically called before peaceful destruction (ie, not during stack unwinding because of an exception). Unlike the destructor, this default retirement function could throw to handle errors. The file function could look like this:
class File
{
private:
void close();
public:
~File() {try {close();} catch (...) {}} // Destructor, swallows errors
~~File() {close();} // Peaceful retirement, may throw in case of error
};
So I could simply use a File with proper error checking like this:
void f()
{
File file ("test.txt");
file.write("Hello", 5);
if (condition)
return;
file.write("Bye", 3);
}
The peaceful retirement function would take care of closing the file and handling write errors automatically. Wouldn't this be nice? Can we have this in C++? Is there any existing good solution to this problem? I'd be happy to have your feedback about this idea.
It seems that C++ offers no way for a destructor to know whether it is being called because of an exception or because the object peacefully went out of scope. There is std::uncaught_exceptions(), but it seems to be of no use at all (I read https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4152.pdf, but I still think it is buggy: https://godbolt.org/z/9hEo69r5q). Am I missing anything? I am sure more knowledgeable people must have thought about this question before, and I wonder why there seem to be no solution. This would help to implement proper retirement as well: errors
Less Slow C++
https://github.com/ashvardanian/less_slow.cpp
https://redd.it/1k2a1oy
@r_cpp
SFML 3.0.1 is released!
https://github.com/SFML/SFML/releases/tag/3.0.1
https://redd.it/1k59g82
@r_cpp
I love Cplusplus
I have seen the pattern of influencer hating on CPP and I never understand their hate for CPP.
Many other great languages and it's really cool but cplusplus already does all of those things in one single unified language so yes there will be some complexity because your learning programming of any possible type not just a language. Why people doesn't make it clear and jump on hate train.
You will get loose when you start using pointers reference, try to accees data in certain ways but fundamentally stored in other way and few other things and these are source of early frustration with CPP but this is how it's suppose to be, not sure how any other language can fix this, they just lock you in a specific way so you don't venture on your own way and that is pathetic.
https://redd.it/1k4xp5p
@r_cpp
Why its showing error?
https://ibb.co/CKdZTwZm
https://redd.it/1k4w18h
@r_cpp
New C++ Conference Videos Released This Month - April 2025 (Updated to Include Videos Released 2025-04-14 - 2025-04-20)
**CppCon**
2025-04-14 - 2025-04-20
* Lightning Talk: What Does a CMake Developer Want From CMake? - Ben Boeckel - [https://youtu.be/-kUL4AFblCA](https://youtu.be/-kUL4AFblCA)
* Lightning Talk: What LLMs Won't Ever be Able to Do - Ben Deane - [https://youtu.be/km0JFBfFNJQ](https://youtu.be/km0JFBfFNJQ)
* Lightning Talk: C++ in the Cloud: One NIF at a Time with Elixir - Sakshi Verma - [https://youtu.be/5x9cYWt-BYM](https://youtu.be/5x9cYWt-BYM)
* Lightning Talk: The Present and Future of Cross-Platform GUI in C++ - Matt Aber - [https://youtu.be/p9LeAqoshkQ](https://youtu.be/p9LeAqoshkQ)
* Lightning Talk: Micro C++ Benchmarks & Murphy's Law - Lexington Brill - [https://youtu.be/4yu5PgDEhx8](https://youtu.be/4yu5PgDEhx8)
2025-04-07 - 2025-04-13
* Lightning Talk: C++ and Rust Bindings - Mixing It Best With CMake - Damien Buhl - [https://youtu.be/EcbmDXA4Inc](https://youtu.be/EcbmDXA4Inc)
* Lightning Talk: Every Use Case of Colon and Ellipses in C++ - Ali Almutawa Jr - [https://youtu.be/1blspAWnjUQ](https://youtu.be/1blspAWnjUQ)
* Lightning Talk: Do You Love or Hate Your C++ Build System? - Helen Altshuler - [https://youtu.be/jBnQ69ZMtHw](https://youtu.be/jBnQ69ZMtHw)
* Lightning Talk: Generative C++ - Alon Wolf - [https://youtu.be/y8NXF7WsSEc](https://youtu.be/y8NXF7WsSEc)
* Lightning Talk: Remote Execution Caching Compiler (RECC) for C++ Builds - Shivam Bairoliya - [https://youtu.be/oH1JKMKwDDA](https://youtu.be/oH1JKMKwDDA)
2025-03-31 - 2025-04-06
* Lightweight Operator Fusion Using Data-Centric Function Interfaces in C++ - Manya Bansal - [https://youtu.be/pEcOZDRXhNM](https://youtu.be/pEcOZDRXhNM)
* Security Beyond Memory Safety - Using Modern C++ to Avoid Vulnerabilities by Design - Max Hoffmann - [https://youtu.be/mv0SQ8dX7Cc](https://youtu.be/mv0SQ8dX7Cc)
* To Int or to Uint, This is the Question - Alex Dathskovsky - [https://youtu.be/pnaZ0x9Mmm0](https://youtu.be/pnaZ0x9Mmm0)
* Leveraging C++ for Efficient Motion Planning: RRT Algorithm for Robotic Arms - Aditi Pawaskar - [https://youtu.be/CEY4qRLcLmI](https://youtu.be/CEY4qRLcLmI)
* Guide to Linear Algebra With the Eigen C++ Library - Daniel Hanson - [https://youtu.be/99G-APJkMc0](https://youtu.be/99G-APJkMc0)
**Audio Developer Conference**
2025-04-14 - 2025-04-20
* Roland’s Holistic Approach to AI for Music Creation - Paul McCabe, Ichiro Yazawa & Kazuyoshi Sasamori - [https://youtu.be/ZvUGS754u5Y](https://youtu.be/ZvUGS754u5Y)
* Making Accessible Audio Software - Perspectives of a Blind Music Producer - Trey Culver & Adam Wilson - [https://youtu.be/JeyWnToyd1c](https://youtu.be/JeyWnToyd1c)
* Building a Plugin Assembly Line - The Road to Rapid Plugin Development - Bence Kovács & Linus Corneliusson - [https://youtu.be/Iwgd7ulJHa4](https://youtu.be/Iwgd7ulJHa4)
2025-04-07 - 2025-04-13
* Intro to Software Development of Audio Devices - From Plugins to Hardware - Wojtek Jakobczyk - [https://youtu.be/eqHaiV5uNnM](https://youtu.be/eqHaiV5uNnM)
* Teaching Audio Developers How to Build AI-Enhanced Audio Plugins - Matthew Yee-King - [https://youtu.be/Uy7BXe9crUM](https://youtu.be/Uy7BXe9crUM)
* Expanding SDKs and APIs in Pro Tools - Dave Tyler - [https://youtu.be/v31yooYnvYs](https://youtu.be/v31yooYnvYs)
2025-03-31 - 2025-04-06
* Workshop: Designing and Developing an AVB/Milan-Compliant Audio Network Endpoint - Fabian Braun - [https://youtu.be/Xs0UvCOjpnU](https://youtu.be/Xs0UvCOjpnU)
* JUCE and Direct2D - Matt Gonzalez - [https://youtu.be/7qepqLo5bGU](https://youtu.be/7qepqLo5bGU)
* Intro to Software Development of Audio Devices - From Plugins to Hardware - Wojtek Jakobczyk - [https://youtu.be/eqHaiV5uNnM](https://youtu.be/eqHaiV5uNnM)
**C++ Under The Sea**
2025-03-31 - 2025-04-06
* BJÖRN FAHLLER - Cache-friendly data + functional + ranges = ❤️ - [https://www.youtube.com/watch?v=QStPbnKgIMU](https://www.youtube.com/watch?v=QStPbnKgIMU)
https://redd.it/1k4gsi3
@r_cpp
Just dropped: TinyMCP - a C++ MCP SDK
Hey C++ developers!
After days of coffee-fueled coding sessions, we've released TinyMCP into the wild! It's our take on a C++ SDK for the Model Context Protocol (MCP) that lets your apps talk to AI assistants like Claude and Cursor.
## Why we made this
We built TinyMCP because our team needed a lightweight C++ solution that could:
- Run super fast (because who likes waiting?)
- Use minimal resources (your RAM will thank you)
- Work on different platforms without a fuss
- Play nicely with desktop applications (especially on Windows
## Perfect for desktop apps
This is especially handy if you're building desktop AI clients or tools because:
- Your users get snappy response times
- Everything can run locally if needed
- It's easy to integrate with existing C++ desktop applications
- Resource usage stays reasonable (no Chrome-level memory hogging)
## Give it a spin!
If you're curious about adding AI capabilities to your projects, swing by our GitHub repo: https://github.com/Qihoo360/TinyMCP
We're still ironing out some kinks, so any feedback, issues, or PRs would be awesome. And if you just want to give us a star to boost our morale, we wouldn't complain either! 😉
https://redd.it/1k4biyr
@r_cpp
Is fire'n'forget style asynchrony available via the STL alone?
I'm wrapping a C API with C++ and would prefer to not become a runtime beyond using what's already in the STL. (No global state beyond depending on libstdc++/vclib.) One API func supports setting a callback which is mandated to return promptly. If I wanted to provide a convenient interface to users to opt-in to long running callbacks which don't execute on the calling thread but asynchronously and sync using the API primitives, what are my options?
std::async returns a future which I either return to the user to hold on to and keep alive (while possible is "unnecessary" bloat), because its dtor waits for the async op. I'd need a preferably light weight manner to launch an async op without returning anything to the user or having to keep variables alive in my wrapper (in a global array, thread pool or whatever). I'd want the C++ runtime to carry out the async op as promptly as reasonably possible without a sync channel, which the async op takes on the onus to signal its completion.
https://redd.it/1k3jykt
@r_cpp
Error Handling
Hi, i have a question regarding error handling, I come from C# and Python where you generally just throw exceptions to build errror handling. Starting in c++ i have seen a lot of different opinions and solutions regarding error handling. I've seen people throwing exceptions everywhere and always, use error Code Systems or just doing none i guess. So my question would be what to use in certain situations. From my understanding so far you use Error Code Systems for Performance Critical Code. Exceptions should be used for more "high level" Programs and Tasks. Would this be right or am just completly wrong?
https://redd.it/1k3iyqv
@r_cpp
Jupyter Notebook
Have you ever tried CPP on jupyter Notebook
https://redd.it/1k3g6m5
@r_cpp
I wanna make a friends
We can talk about anything especially c++ or another it discussion
https://redd.it/1k2syxi
@r_cpp
What are the differences in math operations from MSVC (windows) to g++ (Linux)
I've heard that C++ math operations can yield different results when compiled with MSVC versus g++, and even between different versions of g++.
Is this true? If so, which operations tend to produce different results, and why does that happen?
Is there a way to ensure that both compilers produce the same results for mathematical operations?
https://redd.it/1k2nqum
@r_cpp
Best practices for migrating legacy code bases to modularized import std; ?
I maintain a large, legacy C++ code base. Now that both g++ and cmake support using the modularized standard library, I'm curious to see how that might impact my build times. However, while some of the people who compile this code use compilers and build systems with modularized standard library support, not all do. So, if using `import std;` is a big enough win, I would have to conditionally support it. Generally, the code Includes What We Use, so there are thousands of include sites include-ing specific standard library header files.
Condtionally #include'ing standard library header at each include site seems awful. Forming the set union of all needed header files, and moving all those into a global list of header files, which are only included when building in the tradition way seems even worse.
Are there any best practices for moving from traditional include's to import std? All of the tutorials I've seen assume green-field development. Does anyone have build performance numbers for similar work they could share?
https://redd.it/1k2l13h
@r_cpp
Reference/Example of LAPACK Use in C++
Hello!
I would like to use LAPACK in C++ and have only found a (good and useful) stackoverflow answer on how to do this: How to start using lapack in c++
While I'm interested in the API, it is the linking and compilation steps that are least comfortable to me.
Do such references, examples, or docs exist?
https://redd.it/1k2ezyi
@r_cpp
that occur in a destructor cannot be thrown, but they could be sent to another object that outlives the object being destroyed. And knowing whether it is being destroyed by an exception or not could help the destructor of a transaction to decide whether it should commit or abort.
Thanks for any discussion about this topic.
https://redd.it/1k29690
@r_cpp
Valgrind 3.25 RC1 Announcement
Here is the announcement for Valgrind 3.25 RC1.
Slightly later than originally planned, but the RC1 is finally out!
An RC1 tarball for 3.25.0 is now available at
https://sourceware.org/pub/valgrind/valgrind-3.25.0.RC1.tar.bz2
(md5sum = 2f02fe951278ebde62bba65c3a311a40)
(sha1sum = 3679ddc3237455f07de0ae30f21e947868c2218e)
https://sourceware.org/pub/valgrind/valgrind-3.25.0.RC1.tar.bz2.asc
Please give it a try in configurations that are important for you and
report any problems you have, either on this mailing list, or
(preferably) via our bug tracker at https://bugs.kde.org/enter_bug.cgi?product=valgrind
The NEWS file isn't complete up to date yet, but some highlights:
- Initial RISCV64/Linux support.
- Valgrind gdbserver supports 'x' packets.
- Numerous bug fixes for Illumos.
- --track-fds=yes now treats all inherited file descriptors like
stdin/out/err (0,1,2) and there is a --modify-fds=high option.
- s390x support for various new instructions (BPP, BPRP and NIAI)
- Various new linux syscalls are supported (landlock*, open_tree,
move_mount, fsopen, fsconfig, fsmount, fspick, userfaultfd)
- The Linux Test Project (ltp) is integrated in the testsuite
try 'make ltpchecks' (this will take a while and will point out
various missing syscalls and valgrind crashes!)
Since this RC1 is slightly later than planned and it is a long Easter
weekend for those that celebrate, lets do the RC2 on Wed Apr 25, with
the 3.25.0 final on Fri Apr 27.
The full NEWS file can be found here:
https://sourceware.org/git/?p=valgrind.git;a=blob;f=NEWS;h=e5be7f53a909d171f2b2375903fdddd715f88f3b;hb=HEADHere is the announcement for Valgrind 3.25 RC1.Slightly later than originally planned, but the RC1 is finally out!
An RC1 tarball for 3.25.0 is now available at
https://sourceware.org/pub/valgrind/valgrind-3.25.0.RC1.tar.bz2
(md5sum = 2f02fe951278ebde62bba65c3a311a40)
(sha1sum = 3679ddc3237455f07de0ae30f21e947868c2218e)
https://sourceware.org/pub/valgrind/valgrind-3.25.0.RC1.tar.bz2.asc
Please give it a try in configurations that are important for you and
report any problems you have, either on this mailing list, or
(preferably) via our bug tracker at https://bugs.kde.org/enter_bug.cgi?product=valgrind
The NEWS file isn't complete up to date yet, but some highlights:
- Initial RISCV64/Linux support.
- Valgrind gdbserver supports 'x' packets.
- Numerous bug fixes for Illumos.
- --track-fds=yes now treats all inherited file descriptors like
stdin/out/err (0,1,2) and there is a --modify-fds=high option.
- s390x support for various new instructions (BPP, BPRP and NIAI)
- Various new linux syscalls are supported (landlock*, open_tree,
move_mount, fsopen, fsconfig, fsmount, fspick, userfaultfd)
- The Linux Test Project (ltp) is integrated in the testsuite
try 'make ltpchecks' (this will take a while and will point out
various missing syscalls and valgrind crashes!)
Since this RC1 is slightly later than planned and it is a long Easter
weekend for those that celebrate, lets do the RC2 on Wed Apr 25, with
the 3.25.0 final on Fri Apr 27.
The full NEWS file can be found here: [https://sourceware.org/git/?p=valgrind.git;a=blob;f=NEWS;h=e5be7f53a909d171f2b2375903fdddd715f88f3b;hb=HEAD](https://sourceware.org/git/?p=valgrind.git;a=blob;f=NEWS;h=e5be7f53a909d171f2b2375903fdddd715f88f3b;hb=HEAD)
https://redd.it/1k2b72o
@r_cpp
Took me 6 months but made my first app!
https://www.youtube.com/watch?v=ehGolVAHm8U
https://redd.it/1k25cds
@r_cpp