> 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.
It 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.
> 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 .
I 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).
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.
We 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.
Did 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?
I'm using Wayland exclusively for 4 years now on Archlinux (may be more, I forget). At this point, it is better than X11. It still has bugs, but then so does X11.
Fractional scaling is fixed in Plasma 6 though. So, if you need that, it has been good for 1 year now.
i dont want to call linux old fashioned but to still be working the kinks out of windowing system in 2025 boggles me... its almost as if there's a resistance to GUIs or something.
The window manager in windows is horribly buggy and extremely slow. Lots of animation flickering and snapping for seemingly no reason. Try maximizing Firefox while a video is playing and watch the animation - or, usually, lack thereof.
Wayland is, by far, the best windowing system I've ever used. No dropped frames, ever. Its actually kind of uncanny, it feels like you're using an iPhone.
GUIs are tough in open source because they need way more than just code.
You need UX designers, testers, feedback loops, and infrastructure — stuff most volunteer projects can’t sustain. That’s why devs can dogfood CLI tools but GUIs are a whole different beast.
Doctolib is not the problem at all. he real problem is the lack of government proactivity on these initiatives.
If the government had already thought about this in advanced (even in 2013 when doctolib was just starting out), then there could be very strong protectiosn for data which would then allay all of these concerns, and we might have had multiple players in this space.
The best use of Doctolib for me is that I can make appointments without having to speak perfect German on phone. I can make appointments in evening when I'm back from office and can relax a little bit. So, doctolib is a godsend for me as an immigrant here. and I'm guessing for a lot of people too. I can look up doctors who are available without having to bother the receptionist. This is much more efficient way of doing things.
Wrong analogy. You have no idea how wrong you are. Just look at the difference in performance analysis tools for AMD and Nvidia for GPUs. Nvidia makes it simple for people to write GPU programs.
Nvidia's own people are the ones who have made Vulkan performance so close to CUDA's. AMD is behind, but the data shows that they're off in performance proportional to the cost of the device. If they implement coop mat 2, then they would bridge the gap.
99.9% of people who use Pytorch and so on could achieve good enough performance using a "simple vulkan backend" for whatever Python stuff they're used to writing. That would strip out millions of lines of code.
The reason nobody has done this outside of a few github projects that Nvidia themselves have contributed to, is because there isn't a whole lot of money in iterative performance gains, when in reality better algorithmic approaches are being invented quite near every month or so.
It is hard to do in the sense that it requires a very good taste about programming languages, which in turn requires really listening to the customers, and that requires huge number of people who are skilled. And no one has really invested that much money into their software ecosystem yet.
That was the story but the legality of cloning an API/ABI/etc is well established by, for example Google vs Oracle (though with gotchas that might Nvidia to put a legal fight).
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.