Hi r/cpp! I've been working on clice, a C++ language server built on Clang, for about two and a half years, and 1.0 is out today. The main differences from clangd:

• Every compile runs in a worker process, so a Clang crash costs one request instead of the whole server.

• C++20 modules work out of the box from a `compile_commands.json`, with PCHs and PCMs cached on disk across sessions.

• Non-self-contained headers are compiled in the context of a file that includes them, and you can switch contexts and build configurations.

• Template support: completion and go-to-implementation through dependent names, using instantiations when there are any.

• A CLI to index, query, refactor and modularize whole projects.

The post covers the features and the story behind it. Binaries for Linux, macOS and Windows (x64 and arm64) are on the release page, and the VS Code extension is on the Marketplace. Feedback and bug reports are very welcome!

Release post: https://ykiko.me/en/articles/2105384023094834022/

The C++26 ballot failed, and everyone is arguing about contracts and the future of C++. I think we're worried about the wrong thing.

I'm a "pro-fiber" guy, which gets lonely fast when you search the internet for friends and mostly run into Gor Nishanov tearing them apart in P1364 ("Fibers under the magnifying glass"), or Raymond Chen writing that Win32 fibers "aren't useful for much any more."

Sometimes it feels like Microsoft just lacks the imagination for where fibers actually work. Fair point though: if you try to use fibers as a general-purpose replacement for OS threads in arbitrary code, the warnings are right. TLS issues, fixed stacks, and third-party libraries blocking worker threads are very real problems.

I built a fiber-based task scheduler anyway (the first version goes back to 2007), because when you're parallelizing sequential, CPU-bound code like an encoder or compressor on a single file, the tradeoffs are completely different. You own the task code, the number of active fibers is bounded by the work in flight, and tasks often run for just tens of microseconds before waiting on each other mid-work. In that spot, OS threads cost way too much and stackless coroutines force you to tear apart existing call chains.

I wrote up my side of the story - where the usual criticism hits the mark, where it misses, and why fibers still make sense here:

https://www.thinkmeta.com/concurrenttasks/why-fibers

Any other "pro-fiber" folks out there, or has everyone moved on to stackless coroutines / std::execution?

Harald is experimenting with new ways to create YouTube content, and Jonas is kind enough to join in. The topic is C++26 and contracts, since this is a hot topic at the moment and might help to get views.
So Harald does his best to potentially upset a few people by offering a slightly different perspective on the topic, while Jonas raises some interesting questions along the way.

Hi, MSVC dev lead here. We're back with more MSVC Build Tools Preview blog posts. Here's what's new since mid-September. The preview is up to version 14.53 now, as 14.52 is GA (blog post coming soon).

Instructions to install & use the latest preview bits are at https://aka.ms/msvc/preview.

The updated edition of Terrible Tips for a C++ Developer will feature 60 "tips" on programming practices that C++ developers really shouldn't follow.

Now that MSVC 14.52 is released with Visual Studio 2026 18.12 I have tried to rebuild the project I am working on with /std:c++23. Thx for finally releasing C++23 support.

I have previously used /std:c++23preview and my assumption was that the migration would be effortless. But not so. So this is a heads up.

Most of the issues I have ran into is related to C++23 and how incomplete types are used in headers. So C++23 changed so that std::unique_ptr destructor now is constexpr. This means that I have to add/move destructor to .cpp source file. For reference, see Github issues https://github.com/microsoft/STL/issues/4215 and https://github.com/microsoft/STL/issues/4417

But I also have issues with code like:

// Forward declaration
class Foo;

class A
{
public:
    void Add(const Foo & foo ) { _foos.push_back(foo); }

private:
    std::vector<Foo> _foos;
};

class Foo
{
};

Godbolt with MSVC 14.51 and /std:c++23preview - https://godbolt.org/z/ae5M53fK1 Works also perfectly well in GCC 16.2 -std=c++23 - https://godbolt.org/z/rhEM5MMhG

As of this writing MSVC 14.52 and /std:c++23 is not yet available on Godbolt.

But I get error C2139: 'Foo': an undefined class is not allowed as an argument to compiler intrinsic type trait '__is_nothrow_constructible'

A tad annoying.

Your CI runners have better things to do than compile the same dependencies again. Learn how to put them on the fast track with vcpkg-github-cache, a GitHub Action that connects vcpkg binary caching to GitHub Packages.

We'll go beneath the workflow YAML to explore how NuGet packages store compiled dependencies, how vcpkg restores them, and how to manage a cache across multiple open source projects. Along the way, we'll tackle authentication, package visibility, repository permissions, and cache diagnostics. Leave ready to turn repeated compilation into reusable binaries and give your C++ builds a head start.

Join the online meeting here: https://meet.xmission.com/Utah-Cpp-Programmers

Watch previous topics on the Utah C++ Programmers YouTube channel.

Future topics
Past topics

I haven’t seen an announcement for C++26 implementation in MSVC. Honestly, I am mostly interested in reflection. Anyone know of any estimate of when it ships in MSVC?

C++Now

2026-11-02 - 2026-11-08

• Lightning Talk: The Hidden Superpower of Modern CPUs - Why ILP Can Make “More Work” Run Faster - Sampad Acharya - https://youtu.be/WZl7tMBBn3U

• Lightning Talk: When Weird Things Happen - Ruslan Arutyunyan - https://youtu.be/VEIJkIEKEQ4

• Lightning Talk: A Metaprogramming Checklist - Ben Deane - https://youtu.be/6n_mOFP_kBA

2026-10-26 - 2026-11-01

• AI is Forcing us to Obey Scott Meyers - Jody Hagins - https://youtu.be/CiaZq4kCH08

• C++ Libraries - The Road Ahead - Jeffrey Garland - https://youtu.be/bNipVnNaDdk

• Lightning Talk: ?: - Jonathan Müller - https://youtu.be/TLj6NVx5xvk

ACCU

2026-11-02 - 2026-11-08

• Implementing C++ Standard Library - Design and Optimisations in Libc++ - Hui Xie - https://youtu.be/9efvPYY7CuY

• How Invariant are Invariants? - David Olsen - https://youtu.be/TLk4mm4u02A

• The Biggest Misconception of Computer Science - Alex Dathskovsky - https://youtu.be/EwgkN3an1Gs

2026-10-26 - 2026-11-01

• Creating Composable Callables in Contemporary C++ - Using Senders / Receivers as a Frame Graph - Björn Fahller - https://youtu.be/A4mMO5xeQDA

• Incrementally Migrating C++ to a Memory Safe Language with Swift - Tim Condon - https://youtu.be/LMQ21X6_2FQ

• CallMeMaybe - Building Modern Runtime Reflection via C++26 - Laurie Kirk - https://youtu.be/cA0F3wRtZIU

ADC

2026-11-02 - 2026-11-08

• Are You Shipping Your Source Code? - Ryan Wardell - https://youtu.be/ToPPQ6uTUJ0

• Porting a Native C++ Synth Engine to the Browser: Lessons from Katokatone - Kazuhito Inoue - https://youtu.be/KmX7mfkvDHg

• Generative Instruments with Large Piano Models - Tomek Roszczynialski - https://youtu.be/EO-hGj8_BUY

2026-10-26 - 2026-11-01

• TX/RX Part 2 - AI Audio on the Raspberry Pi - Kieran Coulter - https://youtu.be/QSiyLDHoBpo

• JUCE in DJ Products - Current Status and Future Prospects - Masamichi Tomii, Akihito Yamada & Tetsuro Abe - https://youtu.be/VElORkcpE78

• Generative Instruments with Large Piano Models - Tomek Roszczynialski - https://youtu.be/EO-hGj8_BUY

C++Day

2026-10-26 - 2026-11-01

• [C++ Day 2026] Old-School C++ for the Agentic Age: Lessons from Sane C++ (Stefano Cristiano) - https://www.youtube.com/watch?v=tAf-HsET0pE

• [C++ Day 2026] Zero-cost GIS: parsing binary formats in C++23 (Giorgio Bignotti) - https://www.youtube.com/watch?v=VHeNHf6t76Q

I have had several patches that I’ve sent PRs for )(using my work email since I thought that looked a bit more legitimate)

1. Someone who was nice responded to one of them and said that someone at Intel needed to code review i. Never got another response, I followed up in the comments and emailed the person at Intel no response

Patch 2) Someone responded that they were busy and would get around to it when they had a chance to. It’s been a few months and followed up in the comments to no response

patch 3) Someone was assigned to look at it. They worked at a company I haven’t heard about but they seem to no longer work there and the account has been deactivated since. I haven’t been able to get it reassigned.

I don’t really contribute to open source projects at all and I‘m unsure if this is the norm. All of them are fairly small patches to fix bugs I’ve experienced day to day and I’m curious if there’s a way to get file PRs that I am missing

A walkthrough of the new C++ 26 reflection feature, from high-level benefits via end-user usage and previous workaround hacks to the standard's final form and some of its grittier details

What's the point of spending years debating new syntax, language features, and abstractions if the majority of future C++ code might not be written by humans anyway?

Sharing https://hpx.dev, the central web portal for the open-source HPX C++ runtime.

The site serves as a dedicated hub for HPX developer resources, engineering updates, and community content. Currently, you can find:

• Official Documentation: Direct, searchable access to the HPX API references and technical manuals.

• Engineering Blog & Release Notes: Technical write-ups on architectural updates, subsystem integration, and project releases.

• Contributor Reports: Detailed summaries from open-source contributors, including deep-dives into recent Google Summer of Code (GSoC) projects.

• The "HPX In Action" Series: Ongoing interviews featuring developers, researchers, and contributors discussing their workflows and HPC challenges.

Feedback from the C++ community on the site's content and organization is always welcome.

I work at a C++ shop with coders that I really respected - very deep C++ knowledge and are building very technical deep systems products. Over the last few months the CTO has gone off the deep end with AI talking of creating software factory (He’s been reading too much X), he releases huge multi thousand line PRs with basically no review. All sense of scientific temperament and engineering rigour has gone out of the window it seems.
I do believe that AI is a transformational tool and I use it plenty in the development process but I still strive to understand what the AI has written and often use the AI as multiplier rather than surrendering my thinking to it. it’s become increasingly hard to actually develop while deeply understanding the codebase because it has become so sloppy.

I am very sad as this means I’m not really interfacing with writing C++ as much and exploring cool new corners of the language in my daily work.

There is definitely some cool stuff this lets us do a bit more of - high level planning and systems design by reading many papers as well as exploring formal verification.
But overall I am left disappointed. I wonder how it is like at everyone else’s work places and if anyone has any thoughts and suggestions on how I can still develop my C++ knowledge.