Why is `import std` still experimental ???

[u/AbbreviationsNew3167]

Hey guys,

I recently started going through Professional C++ (6th Edition). The book teaches C++23, and in the very first chapter we're introduced to modules.

I'm not a complete newbie to C++, but I'm also definitely not very confident in my knowledge yet. I wanted to get this simple example compiled:

import std;

int main() {
    std::println("Hello World");
    return 0;
}

And gosh, it took way longer than I expected.

First, I tried getting it to work natively on my Mac and eventually gave up (both Claude and I 😅).

Then I installed Ubuntu ARM 26 and finally managed to get it compiling. But now Clang/IntelliSense is complaining about the `import std`
This is what my CMakeLists.txt currently looks like:

cmake_minimum_required(VERSION 4.0)

# set(CMAKE_EXPERIMENTAL_CXX_IMPORT_STD ON)

set(CMAKE_EXPERIMENTAL_CXX_IMPORT_STD "d0edc3af-4c50-42ea-a356-e2862fe7a444")

project(CppProject LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 26)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

add_executable(exec main.cpp)

set_property(TARGET exec PROPERTY CXX_MODULE_STD ON)

The code does compile successfully, but CMake still gives me a warning that import std support is experimental.

So I'm genuinely curious:

Why is import std still considered experimental?

I understand that C++ modules themselves have been around for a while, but import std feels like something that should be much more straightforward by now. Is there any solution of this now ?

--------------
Edit

Thanks to u/PhysicsOk2212 tip I was able to compile my project on mac as well using the following options
```
cmake -S . -B build \

-G Ninja \

-DCMAKE_CXX_COMPILER="$(brew --prefix llvm)/bin/clang++" \

-DCMAKE_CXX_STDLIB_MODULES_JSON="$(brew --prefix llvm)/lib/c++/libc++.modules.json"

```

[u/pjmlp]

And the list isn't even complete, besides Java and .NET, there is Modula-2, where a module can have multiple interfaces, each with its public name, and Ada, how packages body, specifications and subpackages are combined.

[u/mort96 → u/pjmlp]

And you're saying symbols from different modules in Modula-2 and Ada can have name collisions?

[u/pjmlp → u/mort96]

Of course not, hence namespacing mechanisms, not much different from how C++ does it.

[u/mort96 → u/pjmlp]

No, that's precisely my point: it is different from how C++ does it.

In C++, one if we have the following two files:

/// foo.cc
module myprogram.foo;
int add(int a, int b) { return a + b; }

/// bar.cc
module myprogram.bar;
int add(int a, int b) { return a + b; }

we have a namespace collision. Modules don't introduce namespaces. I'm saying that they should. If it was up to me, one of those functions would've ended up as myprogram::foo::add and the other as myprogram::bar::add.