5 ms·
C++20 Modules: Practical Insights, Status and TODOs
- triknomeister 1y ago> Yes, we can. C++20 Modules are usable in a Linux + Clang environment. There are also examples showing that C++20 Modules are usable in a Windows environment with MSVC. I have not yet heard of GCC’s C++20 Modules being used in non-trivial projects. People keep saying this and yet I do not know of a good example from a real life project which did this which I can test. This seems very much still an experimental thing.
- Kelteseth 1y agoFor me it is simply because Qt moc does not support modules yet. This is my last comment from the tracking issue https://bugreports.qt.io/browse/QTBUG-86697 https://bugreports.qt.io/browse/QTBUG-86697 > C++ 26 reflections have now been voted in. This would get rid of moc entirely, but I really do not see how this will become widely available in the next 5-10 Years+. This would require Qt to move to C++ 26, but only if compiler support is complete for all 3 compilers AND older Linux distros that ship these compilers. For example, MSVC still has no native C++ 23 flag (In CMake does get internally altered to C++ latest aka. C++ 26) , because they told me that they will only enable it is considered 100% stable. So I guess we need to add modules support into moc now, waiting another 10 years is not an option for me .
- pjmlp 1y agoHere, Raytracing in a Weekend, using modules, https://github.com/pjmlp/RaytracingWeekend-CPP https://github.com/pjmlp/RaytracingWeekend-CPP Also shows how to use static libraries alongside modules.
- wild_pointer 1y agolol > can haz real life project? > sure, here's X in a Weekend
- pjmlp 1y agoUnfortunately I lack the Office source code to share with you.
- bluGill 1y agoIt is just beyond experimental now, and finally in the early adopter phase. Those early adopters are trying things are trying to develop best practices - which is to say as always: they will be trying things that future us will laugh at how stupid it was to do. There are still some features that are missing from compilers, but enough is there that you can target all 3 major compilers and still get most of modules and benefit from them. However if you do this remember you are an early adopter and you need to be prepared to figure out the right way to do things - including fixing things that you get wrong once you figure out what is right. Also, if you are writing a library you cannot benefit from modules unless you are willing to force all your consumers to adopt modules. This is not reasonable for major libraries used by many so they will be waiting until more projects adopt modules. Still modules need early adopters and they show great promise. If you write C++ you should spend a little time playing with them in your current project even if you can't commit anything.
- juliangmp 1y agoI think it still is in a "well technically its possible" state. And I fear it'll remain that way for a bit longer. A while ago I made a small example to test how it would work in an actual project and that uses cmake (https://codeberg.org/JulianGmp/cpp-modules-cmake-example https://codeberg.org/JulianGmp/cpp-modules-cmake-example). And while it works™, you can't use any compiler provided modules or header modules. Which means that 1) so you'll need includes for anything from the standard library, no import std 2) you'll also need includes for any third party library you want to use When I started a new project recently I was considering going with modules, but in the end I chose against it because I dont want to mix modules and includes in one project.
- monax 1y agoWe are building a document rendering tool using them. It’s a pretty large project, and there have been some really good improvements in Clang’s implementation of C++20 modules in the past few versions. https://github.com/odoo/paper-muncher/blob/main/src/main.cpp https://github.com/odoo/paper-muncher/blob/main/src/main.cpp
- dataflow 1y agoDid you create your own dialect of C++ along the way? I see co_try$(...) and co_trya$(...) whose definitions I can't find, and I assume they're macros that work either with or without coroutines... did you measure the performance overhead with coroutines?
- monax 1y agoTheses macros are defined in our framework, the coroutine code is not that hot so we didn't measure the overhead https://github.com/skift-org/karm https://github.com/skift-org/karm
- delta_p_delta_x 1y agoI'd like to understand your build tool. I see references to 'cutekit'. Is this it: https://pypi.org/project/cutekit/ https://pypi.org/project/cutekit/ Very cool.
- monax 1y agoYes it is
- menaerus 1y ago> The data I have obtained from practice ranges from 25% to 45%, excluding the build time of third-party libraries, including the standard library. > Online, this number varies widely. The most exaggerated figure I recall is a 26x improvement in project compilation speed after a module-based refactoring. > Furthermore, if a project uses extensive template metaprogramming and stores constexpr variable values in Modules, the compilation speed can easily increase by thousands of times, though we generally do not discuss such cases. > Apart from these more extreme claims, most reports on C++20 Modules compilation speed improvements are between 10% and 50%. I'd like to see references to those claims and experiments, size of the codebase etc. I find it hard to believe the figures since the bottleneck in large codebases is not a compute, e.g. headers preprocessing, but it's a memory bandwidth.
- skeezyboy 1y ago> I find it hard to believe the figures since the bottleneck in large codebases is not a compute, e.g. headers preprocessing, but it's a memory bandwidth. source? language? what exactly does memory bandwidth have to do with compilation times in your example?
- menaerus 1y agoChill out. Compiler is a heavily multithreaded program that is utilizing all of the cores in C and C++ compilation model. Since each thread is doing the work, it will obviously also consume memory, no? Computing 101. Total amount of data being touched R/W we call a dataset. A dataset in cases of larger codebases does not fit into the cache. When dataset does not fit into the cache then the data starts to live in main memory. Accessing the data in main memory consumes memory bandwidth of the system. Try running 64 threads and 64-core system touching the data in memory and you will see for yourself.
- compiler-guy 1y agoCompilers are typically not multithreaded. llvm certainly isn’t, although its linker is. C++ builds are usually many single threaded compilation processes running in parallel.
- ho_schi 1y agoLooking at the examples from using Clang (I use GCC btw.): clang++ -std=c++20 Hello.cppm --precompile -o Hello.pcm clang++ -std=c++20 use.cpp -fmodule-file=Hello=Hello.pcm Hello.pcm -o Hello.out ./Hello.out Why is something which shall makes things easy and secure so complicated? I'm used to: g++ -o hello hello.cpp It can use headers. Or doesn't use headers. I doesn't matter. That's the decision of the source file. To be fair, the option -std=c++20 probably isn't necessary in future. I recommend skimming over this issue from Meson: https://github.com/mesonbuild/meson/issues/5024 https://github.com/mesonbuild/meson/issues/5024 Reading the last few blog posts from a developer of Meson, providing some insights why Meson doesn't support modules until now: https://nibblestew.blogspot.com/ https://nibblestew.blogspot.com/
- bluGill 1y agoBecause hello is so simple you don't need complicated. When you are doing something complicated though you have to accept that it is complicated. I could concatenate all 20 million lines of C++ (round number) I work with into one file and building would be as simple as your hello example - but that simple building comes at great cost (you try working with a 20 million line file, and then merging it with changes someone else made) and so I'm willing to accept more complex builds.
- ho_schi 1y agoThank you. That's right and where usually issues arise and tools challenged. If the hello worlds case starts that complicated already I'm going to being careful. I'm eager to gather info but the weak spots of headers (and macros) are obvious. Probably holding a waiting position for undefined time. At least as long Meson doesn't support them. Wikipedia contains false info about toolings: https://en.wikipedia.org/wiki/Modules_(C%2B%2B)#Tooling_support https://en.wikipedia.org/wiki/Modules_(C%2B%2B)#Tooling_supp... Meson doesn't support modules as of 2025-09-11. PS: I'm into new stuff when it looks stable and the benefits are obvious. But this looks complicated and backing out of complicated stuff is painful, when necessary.
- 1y ago
- achatham 1y agoWe use c++ modules at Waymo, inside the google monorepo. The Google toolchain team did all the hard work, but we applied it more aggressively than any team I know of. The results have been fantastic, with our largest compilation units getting a 30-40% speedup. It doesn't make a huge difference in a clean build, as that's massively distributed. But it makes an enormous difference for iterative compilation. It also has the benefit of avoiding recompilation entirely in some cases. Every once in a while something breaks, usually around exotic use of templates. But on the whole we love it, and we'd have to do so much ongoing refactoring to keep things workable without them. Update: I now recall those numbers are from a partial experiment, and the full deployment was even faster, but I can't recall the exact number. Maybe a 2/3 speedup?
- tbaeder 1y agoAre those actually the C++20 modules or clang modules (-fmodules)?
- wavemode 1y agoHow much of the speedup you're seeing is modules, versus the inherent speedup of splitting and organizing your codebase/includes in a cleaner way? It doesn't sound like your project is actually compiling faster than before, but rather it is REcompiling faster, suggesting that your real problem was that too much code was being recompiled on every change (which is commonly due to too-large translation units and too many transitive dependencies between headers).