sussurro.cpp: I reimplemented the OPUS-MT / Marian translation architecture (encoder–decoder seq2seq) in C++ on ggml
https://github.com/whispem/sussurro.cpp

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

Bloomberg Terminal costs $24,000/year. I built a free open-source clone in C++ that runs in your terminal.
https://github.com/Sqwerzyyy/Quaanz/tree/main/bloomberg-terminal

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

Upcoming C++ User Group meetings in July 2026
https://meetingcpp.com/meetingcpp/news/items/Upcoming-Cpp-User-Group-meetings-in-July-2026.html

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

Introducing the Boost Documentary! Teaser & CppCon Preview

"If I were to tell a story about Boost, I'd start with the people."

Today we're sharing the official teaser for the Boost documentary. A film about the people, the politics, and decades of work behind possibly the most important open source library most people have never heard of.

Teaser link – [https://youtu.be/87jvuDbnwqQ](https://youtu.be/87jvuDbnwqQ)

The documentary looks at:

* Boost as a kind of "app store for C++, 30 years early"
* What decades of open source dedication looks like up close
* The honest, sometimes uncomfortable dynamics of how proposals and people move through the C++ committee

There will be a preview screening at CppCon 2026 for all attendees. So if you're going to be in Aurora, CO September 16, 2026, please join us!





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

Fastest theoretical Wordle solver written in pure C++ by hand
https://github.com/saieshshirodkar/wordle-solver

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

Latest News From Upcoming C++ Conferences (2026-06-30)

This is the latest news from upcoming C++ Conferences. You can review all of the news at https://programmingarchive.com/upcoming-conference-news/

TICKETS AVAILABLE TO PURCHASE

The following conferences currently have tickets available to purchase

CppCon (12th – 18th September) – You can buy standard tickets until August 29th at [https://cppcon.org/registration/](https://cppcon.org/registration/)
C++ Under The Sea (14th – 16th October) – You can buy early bird tickets at https://sales.ticketing.cm.com/cppunderthesea2026/
(NEW) ADC – (9th – 11th November) – Tickets for ADC can now be purchased at [https://ti.to/audio-developer-conference/adc-bristol-2026](https://ti.to/audio-developer-conference/adc-bristol-2026)
Meeting C++ (26th – 28th November) – You can buy early bird tickets at https://meetingcpp.com/2026/

OPEN CALL FOR SPEAKERS

OTHER OPEN CALLS

(NEW) CppCon Call For Volunteers Now Open – Interested volunteers have until August 1st to apply at the CppCon main conference which is scheduled to take place from 14th – 18th September. For more information including how to apply visit [https://cppcon.org/cfv2026/](https://cppcon.org/cfv2026/)
(Last Chance) CppCon Call For Posters Now Open – Interested poster presenters have until July 15th to submit their applications for the CppCon main conference which is scheduled to take place from 14th – 18th September. For more information including how to apply visit https://cppcon.org/cppcon-2026-call-for-poster-submissions/
CppCon Call For Authors Now Open! – CppCon are looking for book authors who want to engage with potential reviewers and readers. Read the full announcement at [https://cppcon.org/call-for-author-2026/](https://cppcon.org/call-for-author-2026/) 

TRAINING COURSES AVAILABLE FOR PURCHASE

Conferences are offering the following training courses:

C++Online

1. AI++ 101 – Build an AI Coding Assistant in C++ – Jody Hagins – 1 day online workshop available on Friday 24th July 16:00 – 00:00 UTC/0900-1700 PDT – [https://cpponline.uk/workshop/ai-101/](https://cpponline.uk/workshop/ai-101/)
Watch the preview session here https://youtu.be/suP5zA7QqW4

CppCon Online Workshops

9th – 11th September

1. Modern C++: When Efficiency Matters – Andreas Fertig – 3 day online workshop available on 9th – 11th September 09.00 – 15.00 MDT – https://cppcon.org/class-2026-when-efficiency-matters/
2. System Architecture And Design Using Modern C++ – Charley Bay – 3 day online workshop available on 9th – 11th September 09.00 – 15.00 MDT – https://cppcon.org/class-2026-system-architecture-and-design-using-modern-cpp/

21st – 23rd September

1. C++ Fundamentals You Wish You Had Known Earlier – Mateusz Pusz – 3 day online workshop available on 21st– 23rd September 09.00 – 15.00 MDT – https://cppcon.org/class-2026-cpp-fundamentals/
2. C++23 in Practice: A Complete Introduction – Nicolai Josuttis – 3 day online workshop available on 21st– 23rd September 09.00 – 15.00 MDT – https://cppcon.org/class-2026-cpp23-in-practice/
3. Programming with C++20 – Andreas Fertig – 3 day online workshop available on 21st– 23rd September 09.00 – 15.00 MDT – https://cppcon.org/class-2026-programming-with-cpp20/

26th – 27th September

1. Using C++ for Low-Latency Systems – Patrice Roy – 2 day online workshop available on 26th– 27th September 09.00 – 17.00 MDT –

https://cppcon.org/class-2026-low-latency/

CppCon Onsite Workshops

All onsite workshops will take place in the Gaylord Rockies in Aurora, Colorado

12th & 13th September

1. Advanced and Modern C++ Programming: The Tricky Parts – Nicolai Josuttis – 2 day in-person workshop available on 12th & 13th September – 09:00 – 17:00 – https://cppcon.org/class-2026-tricky-parts/
2. C++ Best Practices – Jason Turner – 2 day in-person workshop available on 12th & 13th September – 09:00 – 17:00 – https://cppcon.org/class-2026-best-practices/
3. How Hardware Gets Hacked: Breaking and Defending Embedded Systems – Nathan Jones – 2 day in-person workshop available on 12th & 13th September – 09:00 – 17:00 – https://cppcon.org/class-2026-hardware-hack/
4. Mastering `std::execution`: A Hands-On Workshop – Mateusz Pusz – 2 day in-person workshop available on 12th & 13th September – 09:00 – 17:00 – https://cppcon.org/class-2026-execution/
5. Performance and Efficiency in C++ for Experts, Future Experts, and Everyone Else – Fedor Pikus – 2 day in-person workshop available on 12th & 13th September – 09:00 – 17:00 – https://cppcon.org/class-2026-performance-and-efficiency/
6. Talking Tech – Sherry Sontag – 2 day in-person workshop available on 12th & 13th September – 09:00 – 17:00 – https://cppcon.org/class-2026-talking-tech/

 13th September

1. AI++ 101 : Build a C++ Coding Agent from Scratch – Jody Hagins – 2 day in-person workshop available on 12th & 13th September – 09:00 – 17:00 – https://cppcon.org/class-2026-AI101/
2. Essential GDB and Linux System Tools – Mike Shah – 1 day in-person workshop available on 13th September – 09:00 – 17:00 – https://cppcon.org/class-2026-essential-gdb/

19th & 20th September

1. AI++ 201: Building High Quality C++ Infrastructure with AI – Jody Hagins – 2 day in-person workshop available on 19th & 20th September – 09:00 – 17:00 – https://cppcon.org/class-2026-ai201/
2. Function and Class Design with C++2x – Jeff Garland – 2 day in-person workshop available on 19th & 20th September – 09:00 – 17:00 – https://cppcon.org/class-2026-function-class-design/
3. High-performance Concurrency in C++ – Fedor Pikus – 2 day in-person workshop available on 19th & 20th September – 09:00 – 17:00 – https://cppcon.org/class-2026-high-perf-concurrency/

OTHER NEWS

(NEW) Accepted Sessions For Meeting C++ Announced – Visit [https://meetingcpp.com/mcpp/schedule/talklisting.php](https://meetingcpp.com/mcpp/schedule/talklisting.php) to see the list of accepted talks
(NEW) Last Chance To Apply For CppCon 2026 Attendance Support Ticket Program! – Includes free tickets for people who would not be able to attend otherwise. Find out more including how to apply at https://cppcon.org/cppcon-2026-attendance-support-ticket-program/

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

Nuevo framework en c++ vixcpp

Hace un tiempo sigo a gari el creador de vixcpp en framework bastante interesante vengo practicando cosas en drogon y obviamente lo mas difícil no es c++ en si, sino lograr ingresar todo hasta despliegue, algo que vixpp a mitigate mucho con su vix run al estilo cargo de run. Me gustaría escuchar las opiniones de los expertos y los que no lo conozcan hechenle un ojito

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

Vix.cpp vs. Drogon/Crow: Is a "Node.js-like" workflow the future for modern C++ backend development? Looking for expert feedback!

Hi everyone,

I’ve been deeply exploring modern C++ (C++20/23) for backend architecture, looking at how we can make high-performance systems more accessible to developers coming from ecosystems like Node.js, Go, or Rust without losing raw native performance or explicit control.

We all know the established giants: Drogon is incredibly fast and feature-rich (but relies heavily on its own CMake setups, complex configuration files, and drogon_ctl), and Crow is fantastic for small, microservice-like Express-style APIs, but can feel limited when scaling full production runtimes.

Recently, I’ve been looking into Vix.cpp, and I feel it approaches the problem from a completely different angle that benefits both beginners and modern backend design. I’d love to get the community's expert thoughts on its architecture and ergonomics.

Why Vix.cpp caught my attention (especially compared to Drogon/Crow):

It’s a Runtime, not just an HTTP Library: While Crow and Drogon focus heavily on routing and HTTP, Vix.cpp acts more like a native application runtime (akin to a native alternative to Node/Bun, but without a GC or engine overhead). It bundles out-of-the-box non-blocking asynchronous modules (async, fs, crypto, db, p2p_http, webrpc) designed to work together coherently.

The Developer Workflow (UX/DX): For beginners or developers migrating to C++, managing CMakeLists.txt pipelines, linking dependencies, and configuring build environments is usually a massive friction point. Vix provides a unified CLI toolchain:

Bash

vix new api vix install vix run main.cpp vix build vix tests

It doesn't replace CMake underneath (you can keep your custom setups), but it abstracts the lifecycle smoothly.

Ergonomic Middleware and State Management: Unlike older frameworks where middleware composition can accidentally introduce blocking calls or obscure types, Vix utilizes a modern context-based layout (MiddlewareFn) with safe, explicit type-based request storage (similar to std::any via state injections).

The Trade-offs & Questions for the Experts:

As much as I like the ergonomics and the data-oriented feel of Vix, I want to spark an honest discussion:

Performance at Scale: Drogon is consistently at the top of TechEmpower benchmarks. Vix uses a modern Asio-based async core and boasts great local release metrics, but how does its runtime abstraction handle raw throughput under extreme hardware utilization compared to Drogon’s thread-pool model?

Ecosystem Isolation: Does building an integrated module ecosystem (vix::db, vix::net, vix::json) run the risk of alienating developers who prefer to manually stitch together standalone libraries (like nlohmann/json or fmt) via vcpkg/Conan?

Is this the right path for beginners? Do you think providing an "all-in-one" workflow layer lowers the barrier to entry for C++ backend engineering, or does it abstract too much of the underlying native toolchain mechanics?

I’d highly appreciate it if the veterans here could take a look at the architecture, tell me where this approach might fall short, or share your experiences if you've integrated Vix into your production stack.

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

Modern GPU Programming with SDL3, Wed, Jul 8, 2026, 6:00 PM (MDT)
https://www.meetup.com/utah-cpp-programmers/events/315322571

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

What's the fastest c++ build pipeline you've achieved ?

Trying to get a realistic picture of what's actually achievable on a large c++ codename before we commit to anything. We're at 450k LOC, full clean builds sitting around at 55 minites on a 16-core machine. Incremental builds are manageable but a full rebuild after a branch switch or a CI run is painful. We've moved to Ninja, cache is in place, worst of the header bloat is cleaned up. At this point it feels like We're pushing against a hardware ceiling rather than a tooling one. Distributed compilation seems like the logical next move , but I'm also wondering if there's something between local optimizations and a full distrubuted setup that actually moves the needle. Anyone hit similar numbers at this scale and seen meaningful improvements?

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

Can windows devs provide us with a visual studio sdk in a tarball/zip form?

Currently, in order to cross compile to windows properly we either download visual studio in a windows machine, copy it's contents to our machine and pass /winsysroot to clang-cl or it's equilevent gnu flag.

Or we use msvc wine to download using wine and deal with capitalization issues.

Why can't windows devs provide us with something similar to msvc wine? It would really simplify getting sysroots to setting up your toolchain.

I filed a ticked to but didn't heard a reply. If anyone here can raise awareness on this issue it would help the whole community.

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

Rate my code!

#include <stdio.h> #include <string.h> #include <iostream> #include <filesystem> using namespace std; namespace fs = std::filesystem; using S = string; using H = const unsigned char; using F = void()(); using G = S()(); using D = void()(fs::path); using Q = void()(S); template<int N, int K> struct Z { S d(H h) { S r; int key = K; for(int i = 0; i < N; i++) { r += char(h[i] ^ key); key = (key 0x5F + 0x13) & 0xFF; } for(char &c : r) c = (c ^ 0x7F) - 3; return r; } }; S b(H h, int n) { S s; for(int i=0;i<n;i++) s+=char(hi); return s; } struct Obf { void o(S x) { cout << x; } S i() { S t; cin >> t; return t; } }; bool d(S p) { return fs::isdirectory(p); } void l(fs::path p) { for(auto& e : fs::directoryiterator(p)) cout << e.path().filename().string() << '\n'; } Obf ob; void e() { ob.o(b((H)"\x73\x6f\x72\x72\x79\x20\x77\x65\x20\x63\x6f\x75\x6c\x64\x20\x6e\x6f\x74\x20\x66\x69\x6e\x64\x20\x79\x6f\x75\x72\x20\x64\x69\x72\x65\x63\x74\x6f\x72\x79\x0a",38)); } void r(S p) { d(p) ? l(p) : e(); } S g() { return ob.i(); } F vf32; G gf8; D df8; Q qf8; void s1() { ob.o(Z<76, 0x37>().d((H)"\x4f\x5a\x58\x4e\x4b\x4e\x20\x60\x65\x5e\x52\x52\x20\x5d\x5e\x20\x5e\x5e\x63\x5e\x20\x57\x5d\x5e\x55\x5e\x5e\x5f\x5e\x20\x5e\x5f\x20\x5e\x5e\x5f\x20\x27\x2e\x2e\x27\x20\x5a\x5e\x5f\x20\x60\x5d\x5d\x5e\x27\x60\x20\x5f\x63\x5f\x5f\x5e\x5e\x5f\x20\x57\x5d\x5e\x55\x5e\x5e\x5f\x0a")); S x = gf0; x == "CD" ? vf9 : qf0; } void s2() { vf10; } void s3() { df0); } void s4(S p) { qf1; } void s5() { ob.o(b((H)"\x0a",1)); } int main() { vf0 = s1; vf9 = s3; vf10 = s2; df0 = l; qf0 = r; qf[1] = s4; gf[0] = g; vf0; s5(); return 0; }

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

Pystd standard library, similar-ish functionality with a fraction of the compile time
https://nibblestew.blogspot.com/2026/06/pystd-standard-library-similar-ish.html

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

Learning about Asymmetric Fences and its Underlying Mechanism - Membarrier

https://nekrozqliphort.github.io/posts/membarrier/

Hey, everyone! You might remember my previous write-ups on \[\[no\_unique\_address\\]](https://www.reddit.com/r/cpp/s/YwbtMBDgz9) and strongly happens before. It took a few months of researching but I finally have a draft version of my new write-up on asymmetric fences (hopefully building up to a write-up on RCU).

This write-up essentially goes into what asymmetric fences are supposed to achieve, its underlying mechanism (the membarrier syscall), and the wording in the standard. Special thanks to u/davidtgoldblatt for his insights and discussions regarding this topic!

Feel free to provide any feedback! This one is denser than my usual write-ups, but I hope you'll find it interesting and insightful.

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

Request for feedback on an AI framework that I coded in my free time.

I've spent several months developing a C++ AI engine with a runtime, planner, memory management, and multi-language scripting. I'd like some feedback on the architecture.



https://github.com/brit45/mimir-framework.git

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

I’m 17, I love C++, but I feel lost trying to get my first remote programming job

I’m 17 and I genuinely love C++ because it is difficult in many ways. It constantly challenges you to think deeply, and it has a wide range of applications, like robotics, game development, embedded systems, and similar fields.

The problem is that all of these jobs seem extremely hard to find, especially for someone my age. I don’t really know what to do. I would love to get my first remote job, but there are almost no opportunities, at least from what I see on X/Twitter. A friend recommended cold emailing, and some people I know said they got jobs that way, but I honestly don’t know how to approach it.

I don’t know if I sound pessimistic, but programming has become the center of many jobs that attract scammy behavior. Sometimes I feel like, in the job market, I will be treated the same as someone who just watched a YouTube video, heard that programmers are highly paid, and decided that programming is a great work-from-home career.

There are just too many of us.

When I think about how many people I knew on Discord who were depressed and only wanted a remote job so they could use AI to do the work, it makes me feel even more confused. Then I look at people on YouTube,Instagram,tik-tok making money from the most ridiculous things, and it honestly feels like people today don’t even think deeply anymore.

Times feel very hard, and I don’t know what I should do.

My friends told me to try cold emailing, and they say they got work that way, but I really don’t know what I am supposed to become in today’s world: a good person and a real programmer, or just another scammy person who only wants money, like it feels many people are doing now.

I know this might sound negative, but I’m being honest. I like programming, especially C++, and I want to build real skills. I just don’t know what the realistic path is for someone who is 17, has no degree, wants remote work, and is interested in hard fields like robotics, game dev, embedded systems, or low-level programming.

Any honest advice from people who have been in a similar position would mean a lot.

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

Meeting C++ online: Giving Students a space to present their C++ Projects
https://meetingcpp.com/meetingcpp/news/items/Giving-Students-a-space-to-present-their-Cpp-Projects.html

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

Redundancy seen in AAA game engines
https://zero-irp.github.io/Redundancy-seen-in-AAA-game-engines/

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

SoaTable: A header-only C++23 Structure-of-Arrays table with a row-shaped API

I've been working on SoaTable, a header-only C++23 library that stores data as a Structure-of-Arrays (one contiguous array per field) but keeps a row-shaped API on top: you insert() a record, assign<Column>() fields to it, and iterate with view<Position, Velocity>().

The goal was to get columnar/cache-friendly layout without

forcing the code that uses it to think in columns.

Repo: https://github.com/bbalouki/soatable

A few design points that might be worth discussing here:

1- Columns are sparse and optional per row. A record only pays for the fields it actually has. Data-less column types (struct Frozen {};) act as tags and cost \~nothing. Reading a missing field is a defined "not present", not UB.

2- Handles are generational. insert() returns a row_id that survives erase, insert, and full re-sorts, and a stale handle reports itself invalid instead of aliasing a reused slot (ABA).

3- Joins start from the smallest column. view/select<A, B>() scans the smaller of the two validity sets and probes the other, so selective queries touch far fewer rows.

4- Layout is a policy, not a rewrite. soa_table (flat, 64B-aligned), aosoa_table<Tile> (tiled, growth never copies), pmr_soa_table (arena/pool), and mmap_soa_table (larger-than-RAM) all share the identical row API.

5- Zero-copy escape hatch. column<T>() hands back a std::span over the real aligned storage for SIMD/BLAS/FFT, with a separate validity bitmap.

6- Opt-in everything. Core is one dependency-free header; compute, query/group-by, serialize, concurrent, timeseries, units, and a runtime dynamic_table are separate headers you include only if you use them. There's also a SOATABLE_NO_EXCEPTIONS / no-RTTI build for embedded/flight targets, kept honest by a dedicated CI leg.

Where it earns its keep: large, sparse tables with selective queries (ECS worlds, tick stores, telemetry).

Where it doesn't: if the table is small, every row has every field, and every pass touches every field, a plain std::vector<Struct> is simpler and just as fast. I tried to be upfront about that in the README.

Numbers (selective join, 250k rows, Release; machine-dependent, harness in the repo):

smallest-drawer select \~168µs vs \~1.55ms when forced to start from the largest column, vs \~1.06ms for a hand-rolled columnar scan and \~1.30ms for an AoS branch scan.

It is not an ECS framework (no systems scheduler, no archetypes), it's the storage layer, so it's more comparable to a sparse-set column store than to EnTT/flecs.

C++23 required (GCC 13+, Clang 18+, MSVC VS2022), CMake/Conan/vcpkg.

Feedback on the API, the sparse-column design, and the benchmark methodology is very welcome m, especially from people doing ECS or columnar-analytics work.

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