C++26, AI & GPU Computing | Meeting C++ Warm-Up

The next Berlin C++ Meetup hosted by thinkcell takes place on Wednesday, November 25, the evening before Meeting C++ — the perfect warm-up for a conference full of ideas, conversation, and connection.

Join us for an evening with the Berlin C++ community, this time as a warmup to Meeting C++! This meetup is a chance to step away from your day-to-day work, meet other developers, exchange ideas, and have real conversations about modern C++ in a relaxed setting.
--------------------------------
📅 Date & Time: Wednesday, November 25, 2026 – 18:30–22:00
📍 Location: Circuit (w3.hub) - Möckernstraße 120
10963 Berlin

🕒 Agenda
18:30 – Doors open
19:15 – Talks + Q&A
20:45 – Food, Drinks and Networking
22:00 – Closing doors
--------------------------------

## Talk

### Speaker: Sandor Dargo

Bio: Sandor Dargo is a Senior Software Engineer at Spotify, where he works with C++. He cares about writing code that stays maintainable long after it's shipped, and about helping other engineers do the same. He shares what he learns on his blog, sandordargo.com, in conference talks, and in his books, including The C++ Interview Book. Outside of work, he enjoys baking, travelling to new places, and spending time with his wife and two children.

Title: The Real Story of C++26: Beyond the Headline Features

Description: C++26 is often defined by its headline features — reflection, contracts, and senders/receivers. But those don’t tell the whole story.

In this talk, we’ll look beyond the headlines to explore the changes that more accurately reflect where C++ is heading. While less visible, these features address long-standing pain points, improve consistency, and quietly reshape everyday programming in C++.

We'll examine the continued expansion of constexpr, including the ability to throw exceptions at compile time, and what it means for the boundary between compile-time and runtime. We'll also discuss the evolving model of erroneous behavior and indeterminate values, making it more explicit what constitutes incorrect code — and how implementations can reason about it.

Safety is also becoming a stronger focus in the standard library. With the introduction of library hardening, C++26 takes steps toward making incorrect usage easier to detect and harder to ignore, without sacrificing performance.

Along the way, we'll look at improvements to function wrappers with std::function_ref and std::copyable_function , enhancements to structured bindings, and the growing capabilities of std::format . We'll also cover pack indexing and its impact on template expressiveness, as well as the ongoing expansion of the freestanding library.

Rather than focusing on individual features in isolation, this talk connects them into a broader narrative: the real direction of C++26 — toward greater clarity, expressiveness, and safety in everyday code.

## Lightning Talks

### Speaker: Adi Seshaditya

Bio: Background in simulations; worked on projects related to applied ML for industrial systems (Consortium Projects Germany) as Data Scientist

Title: AI for Simulations
Description: LLM agents can now write OpenFOAM case files from a single natural-language sentence, but a case that runs is not necessarily a case that is right. We examine how AutoFOAMagent (Neelan & Seshaditya, arXiv:2608.00003) checks its own output: constrained generation, deterministic solver selection, execution-based scoring, a held-out benchmark, and regression auditing of the model itself. It then covers where that validation still falls short and how the same ideas can carry over to Digital Twin work.

### Speaker: Ankit Mittal

Bio: Ankit Mittal is a Senior Real-Time Software Developer at Lake Fusion Technologies in Berlin. He has over 13 years of experience in C++, GPU computing, and numerical software across fluid simulation, automotive radar, and real-time sensor processing. He works on Brae, an open-source GPU solver for OpenFOAM cases.

Title: Keeping the Solver on the GPU with C++ and CUDA
Description: A dot product returns one number. What does it cost when a C++ solver has to wait for that number on every iteration?

Using Brae’s pressure solver as a case study, I’ll walk through two versions of the same iterative solve. In the first, a C++ loop launches GPU work and waits for dot-product results. In the second, a CUDA Graph keeps those results on the GPU and lets the GPU decide whether to run another iteration. With short code excerpts, I’ll show how that changes which parts of the C++ code manage buffers, launch work, and check for convergence. You’ll see how to spot the same kind of synchronization in your own GPU code, even when the amount of data being transferred is just one number.
--------------------------------

RSVP now to save your seat!