0.5.2 — a namespace segment is derived by path arithmetic

The island fixture, run on windows-2022 for the first time, failed to compile with no member named 'image' in namespace 'island_interface::kernels'. The same fixture passes on Linux and macOS.

namespace_of trimmed the base directory off a file's directory as a string. On Windows the two spellings differ even when the paths are the same: a caller states a root with forward slashes, directory_iterator appends with the preferred separator, so the leftover was \image rather than image. Iterating that yields the root directory as its first component, the sanitiser turns it into _, and the entry point landed in island_interface::kernels::_::image.

lexically_relative compares components, so the separator a caller happened to write is not part of the question.

The shader lane had this too. namespace_of is shared by both lanes since 0.5.0, and rules-spirv's Windows fixture keeps every payload in one directory, so a namespace segment was never derived there.

The island fixture now builds and asserts its namespaces on macOS and Windows as well as Linux, and a step asserts that the derivation exists once so that run keeps protecting both lanes.

The floor does not move: mcpp 2026.9.8.1.

0.5.1 — roots that overlap are refused

Completes the design record 0.5.0 implements.

Overlapping roots are refused. roots = { "src/kernels", "src" } was accepted: a file reachable from both has two namespace paths, and which one it got depended on the order of the list. It was also read twice and merged with itself, so the entry looked like two implementations agreeing rather than one file counted twice. A misconfiguration that produces a plausible result is worse than one that stops.

A file root globs nothing beside it. The re-run glob was registered from a root's base directory, which for a single-file root is that file's parent, so an unrelated file beside it became an input to the build program. The glob is now registered only for a directory root, and a root that is the package root itself no longer produces a ./**/* pattern.

The floor does not move: mcpp 2026.9.8.1.

0.5.0 — an island's entry points arrive in the module's own namespace

docs/42 states one rule for both lanes: the module name and the namespace are one identifier path. The shader lane followed it; mcpp.tools.island did not, and emitted every entry point at global scope, so import app.kernels bought a file name and nothing else.

The names

A root's directories extend the namespace exactly as a payload tree's do:

src/backends/cuda/image/blur.cu   myapp_blur   ->  myapp::kernels::image::myapp_blur
src/backends/cuda/saxpy.cu        myapp_saxpy  ->  myapp::kernels::myapp_saxpy

One import, one flat header. The header keeps no namespace: it is read by a C or a device compiler.

The check that makes them honest

A namespace over a flat symbol is a lookup alias. Measured with clang++ (DPC++ 7.1.0), -std=c++23: two modules re-exporting one extern "C" name into two namespaces give two spellings of one entity, &a::f == &b::f. So one name declared twice in one root is refused, naming both files and saying that two implementations of one entry point belong in two roots.

Roots, not a file list

options::roots names the directories implementations live under; options::layout_root names the one whose structure decides where entry points live and defaults to the first. Every other root only has to define the same names, so a fallback tree may be one flat file and may be reorganised without renaming anything a consumer wrote.

A file list's common ancestor moves when a file is added. Roots must also not come from mcpp::device_sources(), which accel narrows to nothing under --no-accel.

scan registers every file it reads and each root as a glob, so adding a file re-runs the build program.

options::strip_prefix

Emits a short spelling beside the authored name, which stays canonical. A constexpr function pointer costs the artifact nothing: the pair is one symbol.

One sanitiser

common_base_dir and namespace_of had been written in rules/spirv.cppm and again in rules/slang.cppm. They move to mcpp::plugins::names with the identifier sanitiser, so a directory named default or 2d gets one answer.

Compatibility

Breaking. A consumer writes app::kernels::saxpy_device(...) where it wrote saxpy_device(...). The floor does not move: this changes what the package generates, not what it asks the engine for. Requires mcpp 2026.9.8.1.

mcpp:plugins 0.2.1

rules-sycl names the C library. See the PR for the measurement.

mcpp:plugins 0.2.0

Two new rule packages and a route that had no payload behind it.

mcpp.rules.sycl (feature rules-sycl, mcpp >= 2026.9.6.1) drives the
xim:dpcpp payload over .sycl translation units. It submits one compile
action per source and one that consumes their outputs, because a SYCL object
carries its device image and nothing registers it until -fsycl-link emits a
wrapper.

mcpp.rules.hip (feature rules-hip, mcpp >= 2026.9.5.2) compiles .hip
units on the NVIDIA platform, where HIP is a header layer over the CUDA
runtime: the compiler is the project's own clang and there is no ROCm on the
machine. The AMD platform is refused by name with the reason.

mcpp.rules.spirv gains the glslc route. Its own source used to say the route
was unsupported "because nothing in this ecosystem publishes it, and a route
with no payload behind it is a claim rather than a feature". xim:shaderc now
publishes one.

Measured on an RTX 4080: both new lanes answer 12 24 36 48 on the device and
again under --no-accel, with no host C++ standard library on any device
compile.

mcpp:plugins 0.1.1

The first member of the tools half, mcpp.tools.embed, which writes a data file into a header the program compiles in. It is selected by the feature tools-embed and needs mcpp 2026.9.5.4, whose fast path compares a declared file input.

The rule sources also lose the decorative markers the rest of the project removed.

0.1.0

The official mcpp build plugin collection, selected by features: mcpp.rules.cuda (feature rules-cuda, mcpp >= 2026.9.5.2) and mcpp.rules.spirv (feature rules-spirv, mcpp >= 2026.9.5.3). The index descriptor names this tag's source archive; the same bytes are mirrored to gitcode.com/mcpp-res/mcpp-plugins.