difference?
* Has anyone here managed to push a CPU-only tracker into the **100–300+ FPS** range on Raspberry Pi-class hardware? If so, what lessons did you learn that aren't obvious from reading papers?

# Future directions I'm considering

Beyond getting the core tracker running efficiently, some areas I'd like to explore include:

* DSST-based scale estimation.
* Lightweight re-detection and automatic target re-acquisition.
* More robust confidence estimation beyond PSR.
* Hybrid detector–tracker pipelines that combine fast tracking with occasional detection.
* FFT optimization, cache-aware memory layouts, and ARM/NEON-specific performance tuning.
* General techniques for squeezing the maximum performance out of embedded CPU-only vision systems.

I'm not looking for someone to redesign the project or suggest replacing it with deep learning. My goal is to understand where the real bottlenecks are and learn from people who've already built or optimized similar systems before I spend weeks optimizing the wrong component.

If you've worked on anything similar, or achieved high frame rates with classical tracking methods, I’d love to hear about your experience, benchmark results, profiling insights, or even things that *didn't* work. Thanks in advance!

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

Tired of mutex hell and spaghetti event handlers? Here's a single-threaded FSM methodology that keeps your async logic clean — forever. Just #include "uniflow.hpp".

We've all been there. A module that starts simple —
connect, send, wait for ack — and six months later looks like this:

bool connecting_, connected_, cmd_sent_, waiting_ack_, draining_, fault_;

void Update() {
if (estop_) {
connecting_ = false;
cmd_sent_ = false;
waiting_ack_ = false;
// forgot draining_ — ghost ack bug waiting to happen
...
}
if (!connected_) { ... }
else if (!cmd_sent_) { ... }
else if (waiting_ack_) { ... }
// where does fault_ get handled? what if estop_ and fault_ fire together?
}

Flags that must move in pairs. Resets that get forgotten.
E-stop logic that has to know about every stage.
Two developers write the same flow in completely different shapes.

**uniflow** keeps what works about the tick-based FSM — cooperative,
single-thread, no mutex — and fixes what doesn't.

Each stage becomes a named step function:

StepResult Step1_Connect() { device_.BeginConnect();
return Next(UF_FN(Step2_WaitConnected)); }

StepResult Step2_WaitConnected() { if (!device_.IsConnected()) return Stay();
return Next(UF_FN(Step3_WaitRequest)); }

StepResult Step3_WaitRequest() { if (!input_.HasRequest()) return Stay();
device_.Send(input_.Take());
return Next(UF_FN(Step4_WaitAck)); }

StepResult Step4_WaitAck() { if (device_.HasAck()) return Done();
return StayUntil(3000ms, UF_FN(Step5_Timeout)); }

One function = one state. Entry is explicit. Transitions are pinned in code.
No hidden jumps. No forgotten resets. Brace depth stays flat forever.

---

**How it works**

One `Runtime` owns one pump thread. Attach as many modules as you want.
The pump visits each module once per round — cooperative, round-robin.

uniflow::Runtime rt;
Flow_XAxis x_axis{rt};
Flow_YAxis y_axis{rt};
Flow_Conveyor conveyor{rt};

x_axis.ctx_home_.StartFlow(); // start homing X
y_axis.ctx_home_.StartFlow(); // start homing Y — simultaneously, no thread, no mutex

Modules on the same Runtime share the single-thread invariant.
No locks needed. Ever.

The pump adapts its sleep to the situation:
- Back-to-back transitions? No sleep, full speed.
- Polling with Stay()? 20ms yield. CPU near 0.
- All idle? 1ms — ready to wake immediately.

External event arrives? Call `rt.Wake()` from any thread. No waiting out a sleep cycle.

---

**Blocking work? No problem.**

Heavy I/O goes to the built-in thread pool via SubmitAsync.
The pump never blocks. Every other module keeps running.

StepResult Step1_Fetch() {
AsyncId job = SubmitAsync(UF_FN(DoFetch), 5000ms, url_);
return Next(UF_FN(Step2_Process), job);
}

StepResult Step2_Process(AsyncId job) {
auto r = AsyncResult<std::string>(job);
if (r.pending()) return StayUntil(5000ms, UF_FN(Step_Timeout));
if (!r.ok()) return Fail();
data_ = *r.return_value;
return Next(UF_FN(Step3_Save));
}

---

**Built-in tracing — zero instrumentation code**

Because every execution is "a step function was called once,"
one measurement point inside the pump sees everything:

[JobWorker] FLOW START
[JobWorker] Entry -> Step2_Validate elapsed=0.01ms
[JobWorker] ASYNC SUBMIT CallApi
[JobWorker] ASYNC DONE CallApi wait=124.38ms
[JobWorker] Step2_Validate -> Step3_WaitSave elapsed=124.42ms
[JobWorker] FLOW END DONE wall=143.21ms

Which step, how long, where it slowed down — visible without touching your logic code.

---

**What it's not**

- Not Boost.Asio — no new type system to learn, zero deps, doesn't absorb your objects
- Not C++20 coroutines — C++17, and style is

enforced by the framework not left to each developer
- Not a replacement for your existing objects — sockets, handles, device drivers stay as-is

---

**Single header. Zero deps. C++17. Windows / Linux / macOS.**
Also ported to Python and C# with identical APIs.

Demos included:
- `city_traffic` — 15 cars + intersections on one thread, zero mutex
- `pick_and_place` — two pickers sharing a CNC zone with no collision

→ https://github.com/splendidz/uniflow

Feedback and questions welcome — especially from anyone who's felt this pain.

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

2026 EuroLLVM Developers’ Meeting Talks
https://www.youtube.com/playlist?list=PL_R5A0lGi1ABJTIK5_5MkvHDb12mUmpSz

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

CPP Algorithm & Concurrency visualiser watch your code run step by step

Built a platform where you can visualise your own cpp code datastructure and concurrency side by side supported one

1D arrays — int\[\], int\[N\]
Dynamic arrays — std::vector<int>
2D arrays / matrices — int\[R\]\[C\], std::vector<std::vector<int>>
Maps — std::map<int,int>, std::unordered_map<int,int>
Sets — std::set<int>, std::unordered\_set<int>
Stacks / queues / heaps — std::stack<int>, std::queue<int>, std::priority_queue<int>
Concurrency (threads & mutexes) — std::thread, std::mutex
Linked lists & trees — self-referential structs (struct Node { int val; Node* next; } / { int val; Node *left, *right; })

Try it here https://8gwifi.org/online-cpp-compiler/

Feedback and Bug's Welcomed for Improvement

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

UI Toolkit Slint 1.17 released with drag & drop, system tray icons, tooltips, two-way model bindings, and improved Node.js integration
https://slint.dev/blog/slint-1.17-released

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

How do you keep toolchain drift across windows, linux, and mac manageable at 30+ engineers?

We're about 30 engineers split across Windows and Linux, with a handful on macOS. All C++, CMake + Ninja as the build sytem. The compiler situation is where it gets messy. Someone's always on a slightly different version and it surfaces in the strangest ways, usually right before a release.

We've gone back and forth on a few approaches...pinning versions across machines, containerizing the build environment, leaning on build servers and treating local builds as second-class, or some mix. None feel clean. All have tradeoffs, and the tradeoff's shift depending on the platform.

What's held up at a similar scale?

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

What are some things you don't like about C++?

I asked this question in the C programming sub too.

What are some things you don't like about C++

If you were to change some things about C++, add keywords, or other similar things,

what would you change? Replace? Add?

My most important question is about keywords. What keyword would you add ( even just describing its functionality) to help YOU as a programmer?

Thank you :)

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

Trip report: ACCU On Sea 2026
https://sandordargo.com/blog/2026/06/24/trip-report-accu-on-sea-2026

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

oh GOD, it's good to come back to C++

Just been going around vanilla javascript, php, perl, LUA, some C#, batchscript over and over for a year but finally came back to C++ and it's good to be home.

To some they find it agonizing with memory management, consts, function prototyping and what not.. some wouldn't even touch it but to me, it's like riding a bike. It's all coming back and I need that extra control! Besides MySQL.. this is it! 🔥🔥

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

C++23 Dependency Injection library with automatic dependency building

I open-sourced my dependency injection library.
Link: https://github.com/n0F4x/redi

This was developed for my game engine.
- feature-rich dependency configuration
- optimized for fast compile time
- helpful error messages when a cyclic dependency is detected
- dependencies are automatically constructed - no need to register them by hand

I am giving this project to the community so that everybody can benefit. This kind of approach is mostly useful when dealing with intricate systems, such as a plugin system.
I welcome all kinds of feedback, as this was mostly a learning opportunity for me.
If you'd like to use this in your project but don't have access to the required compiler features, let me know, and I'll see if I can reduce the requirements.


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

**Has the AI coding era changed how we should evaluate C++ frameworks?**

# **Has the AI coding era changed how we should evaluate C++ frameworks?**

**Has the AI coding era changed how we should evaluate C++ frameworks?**

I’ve been thinking about this while working with U++ (formerly Ultimate++).

For a long time, discussions around U++ usually start with comparisons to frameworks like Qt, wxWidgets, or CMake-based stacks.

But I’m starting to think that in 2026, a more interesting question might be:

**Why might cohesive C++ ecosystems like U++ be well-suited to AI-assisted development?**

Modern AI coding tools don’t just generate isolated functions well—they tend to work better when the surrounding system is **consistent, structured, and predictable**. Less time spent stitching together unrelated libraries, build systems, and tooling often improves end-to-end results.

That’s where U++ [https://github.com/ultimatepp/ultimatepp](https://github.com/ultimatepp/ultimatepp) becomes interesting.

It’s not just a GUI toolkit. It’s an integrated C++ ecosystem that includes:

* cross-platform application framework
* native GUI (CtrlLib)
* Skylark web framework
* SQL abstraction layer
* package/build system (.upp / .var assemblies)
* integrated documentation system (Topic++)
* command-line builds (`umk`)
* and a design philosophy centered around value semantics and reduced pointer ownership complexity

One of the long-standing criticisms of U++ is that it effectively pushed developers toward TheIDE as the primary workflow environment.

I think that criticism is fair.

To address this more directly, I built a **VS Code extension for U++ (**`upp-umk`**)** [**https://github.com/arilect/upp-umk**](https://github.com/arilect/upp-umk), which brings U++ closer to a modern editor-based workflow.

It provides:

* **Assembly & package management** — browse, select, and create U++ packages from a sidebar UI
* **Build & run** — build and run projects with a single click or shortcut
* **Debug support** — build with debug symbols and launch GDB automatically
* **IntelliSense integration** — auto-generate `c_cpp_properties.json` and `compile_commands.json`
* **clangd support** — compile database generation with watch mode and auto-restart
* **Workspace management** — automatic `.code-workspace` creation per assembly
* **Configurable builds** — flags, link modes, output paths, and more

This effectively removes one of the biggest practical barriers people mention when trying U++: IDE lock-in.

There is also work around integrating U++’s documentation system (Topic++) into external editors, but the build/tooling integration is what makes the real difference in daily usage.

What I find interesting is not that U++ is “better” or “worse” than other C++ stacks, but that it represents a different design philosophy: **integration over composition**.

I’m curious how others see this.

As AI becomes a bigger part of development workflows, do you think tightly integrated ecosystems become more valuable? Or does flexibility from loosely assembled toolchains still win?

Would love to hear thoughts from people who have used Qt, wxWidgets, Boost, Unreal, or other large C++ ecosystems.

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

Examples of C++23 - The Complete Guide

More than 150 examples of C++23 can be found now at **www.cppstd23.com**.

I hope it helps.

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

std::formatter specialization for smart pointers

Currently something like

std::uniqueptr<int> uptr = std::makeunique<int>(42);
std::sharedptr<int> sptr = std::makeshared<int>(42);
std::println("uptr: {}", uptr);
std::println("sptr: {}", sptr);

is ill formed because there is no specialization of std::formatter for smart pointer types.

On the other hand,

std::cout << "uptr: " << uptr << '\n';
std::cout << "sptr: " << sptr << '\n';

do work because ostream defines overloads for smart pointer types.

Please let me know if anyone has thoughts or if there's some reason that these types haven't been specialized that I'm missing.

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

Am I the only one who thinks this? (about enum)

The main differences between an enum and enum class|struct is that the latter has its own scope, but you lose the implicit operators from enum, and the closest to it is as presented. I wish that enum struct maintained the operators, acting like the C enum, but with it's own scope.

// Dummy wrapper struct
struct EnumName
{
enum Value
{
ZERO
};
// the scope is located in "EnumName"
// so you access "EnumName::ZERO"
};

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

Easy JSON ImGui Config Files for Hack Menus
https://youtu.be/2P7uSx7EA2c?si=9b-jpvqZvDQ6FL9E

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

ACCU On Sea 2026 trip report, still with AI!
https://mropert.github.io/2026/06/24/accu_on_sea_2026/

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

Latches in C++ 20 concurrency - just like the CountdownLatch of Java concurrency package...
https://som-itsolutions.hashnode.dev/latches-in-c-20-concurrency-just-like-the-countdownlatch-of-java-concurrency-package

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

Tuning a Server for Benchmarking
https://david.alvarezrosa.com/posts/tuning-a-server-for-benchmarking/

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

An Invitation For a Controlled Experiment

Hello.
I am a self-taught operator/software designer.
I developed Anubis. A cpp forensic AI weights scanner.
I tested Anubis against algorithms of my design and I think it has matured enough for outsider testing.

I propose a rigorous, controlled experiment where a corporation or even professionals to send or share any format of weights with any kind of payloads in them to test Anubis's efficacy and detection capabilities.

We -both me and the whoever is interested in collaboration- will adhere to ISO/IEEE standards in experiment design, reporting and final whitepapers or documents resulting from this experiment.

I offer NO FINANCIAL COMPENSATION. This is a scientific experiment.

Please DM or leave a comment if you are:

1. Serious
2. a Professional
3. Know what ISO/IEEE frameworks are

\---
Cheers!

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