diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d9f4fef4..80bc988c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -10,41 +10,176 @@ on:
   workflow_dispatch:
     # allow this workflow to be triggered manually
 
+# Only allow for one job to run at a time, and cancel any jobs currently in progress.
+concurrency:
+  group: gh-actions-${{ github.actor }}-${{ github.head_ref }}
+  cancel-in-progress: true
+
 jobs:
-  builder:
-    name: 'Build and test on ${{ matrix.arch }}-${{ matrix.os }}/${{ matrix.dc }}'
-    runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ contains(matrix.dc, 'beta') }}
+  setup:
+    name: 'Load job configuration'
+    runs-on: ubuntu-20.04
+    outputs:
+      compilers: ${{ steps.load-config.outputs.compilers }}
+    steps:
+    - uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579
+    # This step checks if we want to only run tests on a specific platform or
+    # if we want to skip CI entirely, then outputs the compilers to be used for
+    # each job.
+    - id: load-config
+      uses: actions/github-script@9ac08808f993958e9de277fe43a64532a609130e
+      with:
+        script: |
+          const base_compiler_config = require("./.github/workflows/compilers.json");
+          const compilers = {"windows": [], "macos": [], "ubuntu": []};
+          const {owner, repo} = context.repo;
+          let commit_sha = context.sha;
+          if (context.eventName == "pull_request") 
+          {
+            commit_sha = context.payload.pull_request.head.sha;
+          }
+
+          const commit = await github.rest.git.getCommit({
+            owner,
+            repo,
+            commit_sha
+          });
+          const head_commit_message = commit.data.message;
+
+          if (head_commit_message.startsWith("[windows-only]"))
+          {
+            compilers.windows = base_compiler_config;
+          }
+          else if (head_commit_message.startsWith("[macos-only]"))
+          {
+            compilers.macos = base_compiler_config;
+          }
+          else if (head_commit_message.startsWith("[ubuntu-only]"))
+          {
+            compilers.ubuntu = base_compiler_config;
+          }
+          else if (!head_commit_message.startsWith("[skip-ci]"))
+          {
+            compilers.windows = base_compiler_config;
+            compilers.macos = base_compiler_config;
+            compilers.ubuntu = base_compiler_config;
+          }
+          core.setOutput("compilers", JSON.stringify(compilers));
+
+  macos:
+    name: '[macos] x86_64/${{ matrix.dc }}'
+    runs-on: macos-11
+    needs: setup
+    # Only run if the setup phase explicitly defined compilers to be used
+    if: ${{ fromJSON(needs.setup.outputs.compilers).macos != '' && fromJSON(needs.setup.outputs.compilers).macos != '[]' }}
+    # Beta / master versions of any compiler are allowed to fail
+    continue-on-error: ${{ contains(matrix.dc, 'beta') || contains(matrix.dc, 'master') }}
+    env:
+      ARCH: x86_64
+    strategy:
+      fail-fast: false
+      matrix:
+        dc: ${{ fromJSON(needs.setup.outputs.compilers).macos }}
+    steps:
+      - name: Checkout repo 
+        uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579
+      - name: Setup D compiler 
+        uses: dlang-community/setup-dlang@763d869b4d67e50c3ccd142108c8bca2da9df166
+        with:
+          compiler: ${{ matrix.dc }}
+      - name: Cache dub dependencies
+        uses: actions/cache@937d24475381cd9c75ae6db12cb4e79714b926ed
+        with:
+          path: ~/.dub/packages
+          key: macos-latest-build-${{ hashFiles('**/dub.sdl', '**/dub.json') }}
+          restore-keys: |
+            macos-latest-build-
+      - name: Build / test
+        run: |
+          dub test --arch=$ARCH --build=unittest-cov
+          dub test --arch=$ARCH --combined
+        shell: bash
+      - name: Upload coverage data
+        uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b
+
+  ubuntu:
+    name: '[ubuntu] ${{ matrix.arch }}/${{ matrix.dc }}'
+    runs-on: ubuntu-20.04
+    needs: setup
+    # Only run if the setup phase explicitly defined compilers to be used
+    if: ${{ fromJSON(needs.setup.outputs.compilers).ubuntu != '' && fromJSON(needs.setup.outputs.compilers).ubuntu != '[]' }}
+    # Beta / master versions of any compiler are allowed to fail
+    continue-on-error: ${{ contains(matrix.dc, 'beta') || contains(matrix.dc, 'master') }}
     env:
       ARCH: ${{ matrix.arch }}
     strategy:
       fail-fast: false
       matrix:
-        dc: [ldc-latest, ldc-beta, dmd-latest, dmd-beta]
-        os: [ubuntu-latest, windows-latest]
+        dc: ${{ fromJSON(needs.setup.outputs.compilers).ubuntu }}
         arch: [x86, x86_64]
-        include:
-          - dc: ldc-latest
-            os: macos-latest
-            arch: x86_64
-          - dc: dmd-latest
-            os: macos-latest
-            arch: x86_64
     steps:
-      - uses: actions/checkout@v2
-      - uses: dlang-community/setup-dlang@v1.1.0
+      - name: Checkout repo 
+        uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579
+      - name: Setup D compiler 
+        uses: dlang-community/setup-dlang@763d869b4d67e50c3ccd142108c8bca2da9df166
         with:
           compiler: ${{ matrix.dc }}
       - name: Install multi-lib for 32-bit systems
-        if: matrix.arch == 'x86' && matrix.os == 'ubuntu-latest'
-        run: sudo apt-get install gcc-multilib
-      - id: build
-        name: Test building
+        if: matrix.arch == 'x86'
+        run: sudo apt-get update && sudo apt-get install gcc-multilib
+      - name: Cache dub dependencies
+        uses: actions/cache@937d24475381cd9c75ae6db12cb4e79714b926ed
+        with:
+          path: ~/.dub/packages
+          key: ubuntu-latest-build-${{ hashFiles('**/dub.sdl', '**/dub.json') }}
+          restore-keys: |
+            ubuntu-latest-build-
+      - name: Build / test 
         run: |
           dub test --arch=$ARCH --build=unittest-cov
-          dub test --arch=$ARCH --combined
+          dub test --arch=$ARCH --combined 
+        shell: bash
+      - name: Upload coverage data
+        uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b
+  
+  windows:
+    name: '[windows] x86_64/${{ matrix.dc }}'
+    runs-on: windows-2022
+    needs: setup
+    # Only run if the setup phase explicitly defined compilers to be used
+    if: ${{ fromJSON(needs.setup.outputs.compilers).windows != '' && fromJSON(needs.setup.outputs.compilers).windows != '[]' }}
+    # Beta / master versions of any compiler are allowed to fail
+    continue-on-error: ${{ contains(matrix.dc, 'beta') || contains(matrix.dc, 'master') }}
+    env:
+      ARCH: x86_64
+    strategy:
+      fail-fast: false
+      matrix:
+        dc: ${{ fromJSON(needs.setup.outputs.compilers).windows }}
+    steps:
+      - name: Checkout repo 
+        uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579
+      - name: Setup D compiler 
+        uses: dlang-community/setup-dlang@763d869b4d67e50c3ccd142108c8bca2da9df166
+        with:
+          compiler: ${{ matrix.dc }}
+      - name: Cache dub dependencies
+        uses: actions/cache@937d24475381cd9c75ae6db12cb4e79714b926ed
+        with:
+          path: ~\AppData\Local\dub
+          key: windows-latest-build-${{ hashFiles('**/dub.sdl', '**/dub.json') }}
+          restore-keys: |
+            windows-latest-build-
+      # Tests are split up to work around OOM errors -- no combined testing is done
+      # as it's simply too big for the compiler to handle on Windows.
+      - name: Build / test
+        run: |
+          dub test --arch=$ARCH --build=unittest-ci -c ci-bignum-test
+          dub test --arch=$ARCH --build=unittest-ci -c ci-core-test
+          dub test --arch=$ARCH --build=unittest-ci -c ci-ndslice-test
+          dub test --arch=$ARCH --build=unittest-ci -c ci-test
         shell: bash
-      - id: coverage
-        uses: codecov/codecov-action@v2
+      - name: Upload coverage data
+        uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b
     
         
diff --git a/.github/workflows/compilers.json b/.github/workflows/compilers.json
new file mode 100644
index 00000000..dc811c76
--- /dev/null
+++ b/.github/workflows/compilers.json
@@ -0,0 +1,10 @@
+[
+    "dmd-master",
+    "dmd-latest",
+    "dmd-beta",
+    "dmd-2.098.1",
+    "ldc-master",
+    "ldc-latest",
+    "ldc-beta",
+    "ldc-1.28.1"
+]
\ No newline at end of file
diff --git a/README.md b/README.md
index 4cabc6fe..948d924f 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
 [![codecov.io](https://codecov.io/github/libmir/mir-algorithm/coverage.svg?branch=master)](https://codecov.io/github/libmir/mir-algorithm?branch=master)
-[![Build Status](https://travis-ci.org/libmir/mir-algorithm.svg?branch=master)](https://travis-ci.org/libmir/mir-algorithm)
+[![GitHub Workflow Status](https://img.shields.io/github/workflow/status/libmir/mir-algorithm/CI/master)](https://github.com/libmir/mir-algorithm/actions)
 [![Circle CI](https://circleci.com/gh/libmir/mir-algorithm.svg?style=svg)](https://circleci.com/gh/libmir/mir-algorithm)
 
 [![Dub downloads](https://img.shields.io/dub/dt/mir-algorithm.svg)](http://code.dlang.org/packages/mir-algorithm)
diff --git a/dub.sdl b/dub.sdl
index 0489caae..8366872f 100644
--- a/dub.sdl
+++ b/dub.sdl
@@ -9,12 +9,12 @@ dependency "mir-core" version=">=1.1.88"
 
 buildType "unittest" {
     buildOptions "unittests" "debugMode" "debugInfo"
-    versions "mir_bignum_test" "mir_test" "mir_core_test"
+    versions "mir_bignum_test" "mir_ndslice_test" "mir_test" "mir_core_test"
     dflags "-lowmem"
 }
 buildType "unittest-dip1008" {
     buildOptions "unittests" "debugMode" "debugInfo"
-    versions "mir_bignum_test" "mir_test"
+    versions "mir_bignum_test" "mir_ndslice_test" "mir_test"
     dflags "-lowmem" "-preview=dip1008"
 }
 buildType "unittest-dip1000" {
@@ -24,12 +24,16 @@ buildType "unittest-dip1000" {
 }
 buildType "unittest-cov" {
     buildOptions "unittests" "coverage" "debugMode" "debugInfo"
-    versions "mir_bignum_test" "mir_test"
+    versions "mir_bignum_test" "mir_ndslice_test" "mir_test"
+    dflags "-lowmem"
+}
+buildType "unittest-ci" {
+    buildOptions "unittests" "coverage" "debugMode" "debugInfo"
     dflags "-lowmem"
 }
 buildType "unittest-release" {
     buildOptions "unittests" "releaseMode" "optimize" "inline" "noBoundsCheck"
-    versions "mir_bignum_test" "mir_test"
+    versions "mir_bignum_test" "mir_ndslice_test" "mir_test"
     dflags "-lowmem"
 }
 
@@ -47,3 +51,19 @@ configuration "dip1008" {
 configuration "dips" {
     dflags "-preview=dip1000" "-preview=dip1008"
 }
+
+configuration "ci-bignum-test" {
+    versions "mir_bignum_test"
+}
+
+configuration "ci-core-test" {
+    versions "mir_core_test"
+}
+
+configuration "ci-ndslice-test" {
+    versions "mir_ndslice_test"
+}
+
+configuration "ci-test" {
+    versions "mir_test"
+}
diff --git a/meson.build b/meson.build
index 5b2ac982..04028a55 100644
--- a/meson.build
+++ b/meson.build
@@ -117,7 +117,7 @@ this_dep = declare_dependency(
     dependencies: required_deps,
 )
 
-test_versions = ['mir_test', 'mir_bignum_test', 'mir_secure_memory']
+test_versions = ['mir_test', 'mir_bignum_test', 'mir_ndslice_test', 'mir_secure_memory']
 
 if has_cpp_headers
     install_subdir('include/',
diff --git a/source/mir/ndslice/allocation.d b/source/mir/ndslice/allocation.d
index 419b0cff..70fce888 100644
--- a/source/mir/ndslice/allocation.d
+++ b/source/mir/ndslice/allocation.d
@@ -120,7 +120,7 @@ auto rcslice(T, I)(I[] array)
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow @nogc unittest
 {
     import mir.ndslice.slice: Slice;
@@ -136,7 +136,7 @@ version(mir_test)
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow @nogc unittest
 {
     import mir.ndslice.slice: Slice;
@@ -159,7 +159,7 @@ auto rcslice(size_t dim, Slices...)(Concatenation!(dim, Slices) concatenation)
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow @nogc unittest
 {
     import mir.rc.array: RCI;
@@ -188,7 +188,7 @@ Slice!(RCI!T, N)
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow @nogc unittest
 {
     import mir.ndslice.slice: Slice;
@@ -219,7 +219,7 @@ Slice!(FieldIterator!(BitField!(RCI!size_t)), N) bitRcslice(size_t N)(size_t[N]
 
 /// 1D
 @safe pure nothrow @nogc
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto bitarray = 100.bitRcslice; // allocates 16 bytes total (plus RC context)
     assert(bitarray.shape == cast(size_t[1])[100]);
@@ -230,7 +230,7 @@ version(mir_test) unittest
 
 /// 2D
 @safe pure nothrow @nogc
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto bitmatrix = bitRcslice(20, 6); // allocates 16 bytes total (plus RC context)
     assert(bitmatrix.shape == cast(size_t[2])[20, 6]);
@@ -254,7 +254,7 @@ Slice!(RCI!T, N) mininitRcslice(T, size_t N)(size_t[N] lengths...)
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 pure nothrow @nogc unittest
 {
     import mir.ndslice.slice: Slice;
@@ -317,7 +317,7 @@ template slice(Args...)
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow unittest
 {
     import mir.ndslice.slice: Slice;
@@ -329,7 +329,7 @@ version(mir_test)
 }
 
 /// 2D DataFrame example
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure unittest
 {
     import mir.ndslice.slice;
@@ -410,7 +410,7 @@ auto slice(Iterator, size_t N, SliceKind kind)(Slice!(Iterator, N, kind) slice)
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow unittest
 {
     auto tensor = slice([2, 3], 5);
@@ -436,7 +436,7 @@ auto slice(size_t dim, Slices...)(Concatenation!(dim, Slices) concatenation)
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow unittest
 {
     import mir.ndslice.slice: Slice;
@@ -466,7 +466,7 @@ Slice!(FieldIterator!(BitField!(size_t*)), N) bitSlice(size_t N)(size_t[N] lengt
 }
 
 /// 1D
-@safe pure version(mir_test) unittest
+@safe pure version(mir_ndslice_test) unittest
 {
     auto bitarray = bitSlice(100); // allocates 16 bytes total
     assert(bitarray.shape == [100]);
@@ -476,7 +476,7 @@ Slice!(FieldIterator!(BitField!(size_t*)), N) bitSlice(size_t N)(size_t[N] lengt
 }
 
 /// 2D
-@safe pure version(mir_test) unittest
+@safe pure version(mir_ndslice_test) unittest
 {
     auto bitmatrix = bitSlice(20, 6); // allocates 16 bytes total
     assert(bitmatrix.shape == [20, 6]);
@@ -505,7 +505,7 @@ auto uninitSlice(T, size_t N)(size_t[N] lengths...)
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow unittest
 {
     import mir.ndslice.slice: Slice;
@@ -535,7 +535,7 @@ auto uninitAlignedSlice(T, size_t N)(size_t[N] lengths, uint alignment) @system
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @system pure nothrow unittest
 {
     import mir.ndslice.slice: Slice;
@@ -600,7 +600,7 @@ auto makeSlice(Allocator, Iterator, size_t N, SliceKind kind)
 }
 
 /// Initialization with default value
-version(mir_test)
+version(mir_ndslice_test)
 @nogc unittest
 {
     import std.experimental.allocator;
@@ -620,7 +620,7 @@ version(mir_test)
     Mallocator.instance.dispose(ar2);
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @nogc unittest
 {
     import std.experimental.allocator;
@@ -664,7 +664,7 @@ makeUninitSlice(T, Allocator, size_t N)(auto ref Allocator alloc, size_t[N] leng
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @system @nogc unittest
 {
     import std.experimental.allocator;
@@ -701,7 +701,7 @@ auto ndarray(Iterator, size_t N, SliceKind kind)(Slice!(Iterator, N, kind) slice
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow unittest
 {
     import mir.ndslice.topology : iota;
@@ -737,7 +737,7 @@ auto makeNdarray(T, Allocator, Iterator, size_t N, SliceKind kind)(auto ref Allo
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @nogc unittest
 {
     import std.experimental.allocator;
@@ -797,7 +797,7 @@ L:
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure unittest
 {
     int err;
@@ -810,7 +810,7 @@ version(mir_test)
 }
 
 /// Slice from ndarray
-version(mir_test)
+version(mir_ndslice_test)
 unittest
 {
     import mir.ndslice.allocation: slice, shape;
@@ -821,7 +821,7 @@ unittest
     assert(s == array);
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure unittest
 {
     int err;
@@ -830,7 +830,7 @@ version(mir_test)
     assert(shape[1] == 0);
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 nothrow unittest
 {
     import mir.ndslice.allocation;
@@ -915,7 +915,7 @@ void stdcFreeSlice(T, size_t N)(Slice!(T*, N) slice)
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 unittest
 {
     import mir.ndslice.topology: iota;
@@ -953,7 +953,7 @@ auto stdcUninitAlignedSlice(T, size_t N)(size_t[N] lengths, uint alignment) @sys
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @system pure nothrow unittest
 {
     import mir.ndslice.slice: Slice;
diff --git a/source/mir/ndslice/chunks.d b/source/mir/ndslice/chunks.d
index 97dff53c..16acc47e 100644
--- a/source/mir/ndslice/chunks.d
+++ b/source/mir/ndslice/chunks.d
@@ -72,7 +72,7 @@ Chunks!([0], Iterator, N, kind) chunks(Iterator, size_t N, SliceKind kind)(Slice
 
 
 /// 1Dx1D
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     import mir.ndslice.chunks: chunks, isChunks;
     import mir.ndslice.topology: iota;
@@ -112,7 +112,7 @@ Chunks!([0], Iterator, N, kind) chunks(Iterator, size_t N, SliceKind kind)(Slice
 
 /// 2Dx2D
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.chunks: chunks, isChunks;
     import mir.ndslice.topology: iota;
@@ -179,7 +179,7 @@ version(mir_test) unittest
 }
 
 /// 1Dx2D
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.chunks: chunks, isChunks;
     import mir.ndslice.topology: iota;
@@ -209,7 +209,7 @@ version(mir_test) unittest
 }
 
 // conversion to ndslice
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice : slicedField;
     import mir.ndslice.chunks: chunks;
@@ -565,7 +565,7 @@ template isChunks(T)
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.chunks: chunks, isChunks;
     import mir.ndslice.topology: iota;
@@ -613,7 +613,7 @@ do
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.chunks: chunks;
     import mir.ndslice.topology: iota;
diff --git a/source/mir/ndslice/concatenation.d b/source/mir/ndslice/concatenation.d
index c6672cef..043302fd 100644
--- a/source/mir/ndslice/concatenation.d
+++ b/source/mir/ndslice/concatenation.d
@@ -121,7 +121,7 @@ auto concatenation(size_t dim = 0, Slices...)(Slices slices)
 }
 
 /// Concatenation of slices with different dimmensions. 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: repeat, iota;
@@ -147,7 +147,7 @@ version(mir_test) unittest
 }
 
 /// Multidimensional
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
@@ -195,7 +195,7 @@ version(mir_test) unittest
 }
 
 /// 1D
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
@@ -416,7 +416,7 @@ auto pad(string direction = "both", S, T, size_t N)(S s, T value, size_t[N] leng
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
@@ -429,7 +429,7 @@ version(mir_test) unittest
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
@@ -510,7 +510,7 @@ template pad(size_t[] dimensions, string[] directions)
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
@@ -525,7 +525,7 @@ version(mir_test) unittest
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
@@ -562,7 +562,7 @@ auto padWrap(string direction = "both", Iterator, size_t N, SliceKind kind)(Slic
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
@@ -575,7 +575,7 @@ version(mir_test) unittest
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
@@ -678,7 +678,7 @@ template padWrap(size_t[] dimensions, string[] directions)
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
@@ -693,7 +693,7 @@ version(mir_test) unittest
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
@@ -730,7 +730,7 @@ auto padSymmetric(string direction = "both", Iterator, size_t N, SliceKind kind)
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
@@ -743,7 +743,7 @@ version(mir_test) unittest
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
@@ -864,7 +864,7 @@ template padSymmetric(size_t[] dimensions, string[] directions)
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
@@ -879,7 +879,7 @@ version(mir_test) unittest
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
@@ -916,7 +916,7 @@ auto padEdge(string direction = "both", Iterator, size_t N, SliceKind kind)(Slic
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
@@ -929,7 +929,7 @@ version(mir_test) unittest
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
@@ -1040,7 +1040,7 @@ template padEdge(size_t[] dimensions, string[] directions)
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
@@ -1058,7 +1058,7 @@ version(mir_test) unittest
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: iota;
diff --git a/source/mir/ndslice/connect/cpython.d b/source/mir/ndslice/connect/cpython.d
index 07584e6f..a3b8a9cd 100644
--- a/source/mir/ndslice/connect/cpython.d
+++ b/source/mir/ndslice/connect/cpython.d
@@ -75,7 +75,7 @@ PythonBufferErrorCode fromPythonBuffer(T, size_t N, SliceKind kind)(ref Slice!(T
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice: Slice;
     auto bar(ref const Py_buffer view)
@@ -213,7 +213,7 @@ PythonBufferErrorCode toPythonBuffer(T, size_t N, SliceKind kind)(Slice!(T*, N,
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice : Slice, Structure, Universal, Contiguous, SliceKind;
     Py_buffer bar(SliceKind kind)(Slice!(double*, 2, kind) slice)
diff --git a/source/mir/ndslice/dynamic.d b/source/mir/ndslice/dynamic.d
index 47e625af..9cbcebf3 100644
--- a/source/mir/ndslice/dynamic.d
+++ b/source/mir/ndslice/dynamic.d
@@ -131,7 +131,7 @@ bool normalizeStructure(Iterator, size_t N, SliceKind kind)(ref Slice!(Iterator,
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: iota;
 
@@ -233,7 +233,7 @@ Slice!(Iterator, 2, Universal) swapped(Iterator, SliceKind kind)(Slice!(Iterator
 }
 
 /// Template
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.topology: iota;
@@ -248,7 +248,7 @@ Slice!(Iterator, 2, Universal) swapped(Iterator, SliceKind kind)(Slice!(Iterator
 }
 
 /// Function
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.topology: iota;
@@ -263,7 +263,7 @@ Slice!(Iterator, 2, Universal) swapped(Iterator, SliceKind kind)(Slice!(Iterator
 }
 
 /// 2D
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.topology: iota;
@@ -365,7 +365,7 @@ Slice!(Iterator, 2, Universal) rotated(Iterator, SliceKind kind)(Slice!(Iterator
 }
 
 ///
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.topology: iota;
@@ -431,7 +431,7 @@ auto everted(Iterator, size_t N, SliceKind kind)(Slice!(Iterator, N, kind) _slic
 }
 
 ///
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.topology: iota;
@@ -558,7 +558,7 @@ Slice!(Iterator, 2, Universal) transposed(Iterator, SliceKind kind)(Slice!(Itera
 }
 
 /// Template
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.topology: iota;
@@ -573,7 +573,7 @@ Slice!(Iterator, 2, Universal) transposed(Iterator, SliceKind kind)(Slice!(Itera
 }
 
 /// Function
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.topology: iota;
@@ -588,7 +588,7 @@ Slice!(Iterator, 2, Universal) transposed(Iterator, SliceKind kind)(Slice!(Itera
 }
 
 /// Single-argument function
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.topology: iota;
@@ -603,7 +603,7 @@ Slice!(Iterator, 2, Universal) transposed(Iterator, SliceKind kind)(Slice!(Itera
 }
 
 /// _2-dimensional transpose
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.topology: iota;
@@ -642,7 +642,7 @@ Slice!(Iterator, N, Universal) allReversed(Iterator, size_t N, SliceKind kind)(S
 
 ///
 @safe @nogc pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.topology: iota, retro;
@@ -719,7 +719,7 @@ auto reversed(Iterator, size_t N, SliceKind kind)(Slice!(Iterator, N, kind) slic
 }
 
 ///
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: iota;
 
@@ -747,7 +747,7 @@ auto reversed(Iterator, size_t N, SliceKind kind)(Slice!(Iterator, N, kind) slic
 }
 
 ///
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: iota, canonical;
     auto slice = iota([2, 2], 1).canonical;
@@ -762,7 +762,7 @@ auto reversed(Iterator, size_t N, SliceKind kind)(Slice!(Iterator, N, kind) slic
     assert(slice.reversed (0, 0, 0) == [[3, 4], [1, 2]]);
 }
 
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.algorithm.iteration : equal;
     import mir.ndslice.concatenation : concatenation;
@@ -818,7 +818,7 @@ auto strided(Iterator, size_t N, SliceKind kind)(Slice!(Iterator, N, kind) slice
 }
 
 ///
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: iota;
     // 0  1   2  3
@@ -880,7 +880,7 @@ Slice!(Iterator, N, Universal) strided(Iterator, size_t N, SliceKind kind)(Slice
 }
 
 ///
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: iota;
     auto slice = iota(3, 4);
@@ -910,7 +910,7 @@ pure nothrow version(mir_test) unittest
 }
 
 ///
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: iota, universal;
     static assert(iota(13, 40).universal.strided!(0, 1)(2, 5).shape == [7, 8]);
@@ -918,7 +918,7 @@ pure nothrow version(mir_test) unittest
 }
 
 ///
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: iota, canonical;
     auto slice = iota(3, 4).canonical;
@@ -935,7 +935,7 @@ pure nothrow version(mir_test) unittest
         == [[0,1,2,3],            [8,9,10,11]]);
 }
 
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice;
     import mir.algorithm.iteration : equal;
@@ -986,7 +986,7 @@ Slice!(Iterator, N, Canonical) dropToHypercube(Iterator, size_t N)(Slice!(Iterat
 }
 
 ///
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: iota, canonical, universal;
 
diff --git a/source/mir/ndslice/field.d b/source/mir/ndslice/field.d
index bc79c9ea..b9b6db1a 100644
--- a/source/mir/ndslice/field.d
+++ b/source/mir/ndslice/field.d
@@ -392,7 +392,7 @@ struct BitField(Field, I = typeof(cast()Field.init[size_t.init]))
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.iterator: FieldIterator;
     ushort[10] data;
diff --git a/source/mir/ndslice/filling.d b/source/mir/ndslice/filling.d
index d151a9a7..554f3073 100644
--- a/source/mir/ndslice/filling.d
+++ b/source/mir/ndslice/filling.d
@@ -43,7 +43,7 @@ do {
 }
 
 ///
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice: sliced;
     import mir.ndslice.allocation: uninitSlice;
diff --git a/source/mir/ndslice/fuse.d b/source/mir/ndslice/fuse.d
index 0407199b..cc488f5b 100644
--- a/source/mir/ndslice/fuse.d
+++ b/source/mir/ndslice/fuse.d
@@ -37,7 +37,7 @@ alias fuse(Dimensions...) = fuseImpl!(false, void, Dimensions);
 alias rcfuse(Dimensions...) = fuseImpl!(true, void, Dimensions);
 
 ///
-@safe pure version(mir_test) unittest
+@safe pure version(mir_ndslice_test) unittest
 {
     import mir.ndslice.fuse;
     import mir.ndslice.slice : Contiguous, Slice;
@@ -66,7 +66,7 @@ alias rcfuse(Dimensions...) = fuseImpl!(true, void, Dimensions);
 }
 
 /// Transposed
-@safe pure version(mir_test) unittest
+@safe pure version(mir_ndslice_test) unittest
 {
     import mir.ndslice.fuse;
     import mir.ndslice.topology: iota;
@@ -94,7 +94,7 @@ alias rcfuse(Dimensions...) = fuseImpl!(true, void, Dimensions);
 }
 
 /// 3D
-@safe pure version(mir_test) unittest
+@safe pure version(mir_ndslice_test) unittest
 {
     import mir.ndslice.fuse;
     import mir.ndslice.topology: iota;
@@ -115,7 +115,7 @@ alias rcfuse(Dimensions...) = fuseImpl!(true, void, Dimensions);
 }
 
 /// Work with RC Arrays of RC Arrays
-@safe pure version(mir_test) unittest
+@safe pure version(mir_ndslice_test) unittest
 {
     import mir.ndslice.fuse;
     import mir.ndslice.slice;
@@ -143,7 +143,7 @@ alias fuseAs(T, Dimensions...) = fuseImpl!(false, T, Dimensions);
 alias rcfuseAs(T, Dimensions...) = fuseImpl!(true, T, Dimensions);
 
 ///
-@safe pure version(mir_test) unittest
+@safe pure version(mir_ndslice_test) unittest
 {
     import mir.ndslice.fuse;
     import mir.ndslice.slice : Contiguous, Slice;
@@ -368,7 +368,7 @@ auto fuseCells(S)(S cells)
 }
 
 /// 1D
-@safe pure version(mir_test) unittest
+@safe pure version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: iota;
     enum ar = [[0, 1], [], [2, 3, 4, 5], [6], [7, 8, 9]];
@@ -377,7 +377,7 @@ auto fuseCells(S)(S cells)
 }
 
 /// 2D
-@safe pure version(mir_test) unittest
+@safe pure version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: iota;
     import mir.ndslice.chunks;
diff --git a/source/mir/ndslice/internal.d b/source/mir/ndslice/internal.d
index b0207e78..93d001fa 100644
--- a/source/mir/ndslice/internal.d
+++ b/source/mir/ndslice/internal.d
@@ -265,7 +265,7 @@ bool isPermutation(size_t N)(auto ref const scope size_t[N] perm)
     return isValidPartialPermutationImpl(perm, mask);
 }
 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     assert(isPermutation([0, 1]));
     // all numbers 0..N-1 need to be part of the permutation
@@ -336,7 +336,7 @@ size_t lengthsProduct(size_t N)(auto ref const scope size_t[N] lengths)
     return length;
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     const size_t[3] lengths = [3, 4, 5];
     assert(lengthsProduct(lengths) == 60);
diff --git a/source/mir/ndslice/iterator.d b/source/mir/ndslice/iterator.d
index 6fe737e7..57457d09 100644
--- a/source/mir/ndslice/iterator.d
+++ b/source/mir/ndslice/iterator.d
@@ -151,7 +151,7 @@ pure:
 }
 
 ///
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     IotaIterator!int iota;
     assert(*iota == 0);
@@ -177,7 +177,7 @@ pure:
 }
 
 ///
-pure nothrow @nogc version(mir_test) unittest
+pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     int[32] data;
     auto iota = IotaIterator!(int*)(data.ptr);
@@ -209,7 +209,7 @@ auto RetroIterator__map(Iterator, alias fun)(ref RetroIterator!Iterator it)
     return RetroIterator!(typeof(iterator))(iterator);
 }
 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology;
     import mir.ndslice.allocation;
@@ -286,7 +286,7 @@ struct RetroIterator(Iterator)
 }
 
 ///
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     IotaIterator!int iota;
     RetroIterator!(IotaIterator!int) retro;
@@ -326,7 +326,7 @@ auto StrideIterator__map(Iterator, alias fun)(StrideIterator!Iterator it)
     return StrideIterator!(typeof(iterator))(it._stride, iterator);
 }
 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology;
     import mir.ndslice.allocation;
@@ -402,7 +402,7 @@ struct StrideIterator(Iterator)
 }
 
 ///
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     IotaIterator!int iota;
     StrideIterator!(IotaIterator!int) stride;
@@ -511,7 +511,7 @@ struct StrideIterator(Iterator, ptrdiff_t factor)
 }
 
 ///
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     IotaIterator!int iota;
     StrideIterator!(IotaIterator!int, -3) stride;
@@ -697,7 +697,7 @@ struct ZipIterator(Iterators...)
 }
 
 ///
-pure nothrow @nogc version(mir_test) unittest
+pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     import mir.ndslice.traits: isIterator;
 
@@ -1149,7 +1149,7 @@ auto _vmapIterator(Iterator, Fun)(Iterator iterator, Fun fun)
        return MapIterator!(Iterator, fun)(iterator);
 }
 
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     // https://github.com/libmir/mir-algorithm/issues/111
     import mir.ndslice.topology : iota, map;
@@ -1482,7 +1482,7 @@ struct SlideIterator(Iterator, size_t params, alias fun)
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.functional: naryFun;
     auto data = [1, 3, 8, 18];
@@ -1498,7 +1498,7 @@ auto IndexIterator__map(Iterator, Field, alias fun)(ref IndexIterator!(Iterator,
     return IndexIterator!(Iterator, typeof(field))(it._iterator, field);
 }
 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology;
     import mir.ndslice.allocation;
@@ -1733,7 +1733,7 @@ public auto FieldIterator__map(Field, alias fun)(FieldIterator!(Field) it)
     return FieldIterator!(typeof(field))(it._index, field);
 }
 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology;
     import mir.ndslice.allocation;
@@ -1854,7 +1854,7 @@ auto FlattenedIterator__map(Iterator, size_t N, SliceKind kind, alias fun)(Flatt
     return FlattenedIterator!(TemplateArgsOf!(typeof(slice)))(it._indices, slice);
 }
 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology;
     import mir.ndslice.allocation;
@@ -2029,7 +2029,7 @@ struct FlattenedIterator(Iterator, size_t N, SliceKind kind)
     }
 }
 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology;
     import mir.ndslice.slice;
@@ -2208,7 +2208,7 @@ struct StairsIterator(Iterator, string direction)
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     // 0
     // 1 2
@@ -2233,7 +2233,7 @@ version(mir_test) unittest
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     // [0, 1, 2, 3, 4],
     //    [5, 6, 7, 8],
diff --git a/source/mir/ndslice/mutation.d b/source/mir/ndslice/mutation.d
index d1d81b54..6d0becd4 100644
--- a/source/mir/ndslice/mutation.d
+++ b/source/mir/ndslice/mutation.d
@@ -43,7 +43,7 @@ do {
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow
 unittest
 {
@@ -68,7 +68,7 @@ void reverseInPlace(Iterator)(Slice!Iterator slice)
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow
 unittest
 {
diff --git a/source/mir/ndslice/package.d b/source/mir/ndslice/package.d
index 4fd18b6f..9bf7fd63 100644
--- a/source/mir/ndslice/package.d
+++ b/source/mir/ndslice/package.d
@@ -38,7 +38,7 @@
 
 8. Memory allocation and algorithm logic should be separated whenever possible.
 
-9. CTFE version(mir_test) unittests should be added to new functions.
+9. CTFE version(mir_ndslice_test) unittests should be added to new functions.
 +/
 
 /**
@@ -511,7 +511,7 @@ public import mir.ndslice.topology;
 public import mir.ndslice.traits;
 
 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto matrix = new double[12].sliced(3, 4);
     matrix[] = 0;
@@ -524,7 +524,7 @@ version(mir_test) unittest
 }
 
 // relaxed example
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.qualifier;
 
@@ -585,7 +585,7 @@ version(mir_test) unittest
     }
 }
 
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     immutable r = 1000.iota;
 
@@ -612,7 +612,7 @@ version(mir_test) unittest
     assert(t1 == iota([6], 12));
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota;
     import mir.array.allocation : array;
@@ -703,7 +703,7 @@ pure nothrow version(mir_test) unittest
     assert(&t1[$ - 1] is &(t1.back()));
 }
 
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import std.range : iota;
     auto r = (10_000L * 2 * 3 * 4).iota;
@@ -716,14 +716,14 @@ pure nothrow version(mir_test) unittest
     assert(t0.length!3 == 40);
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     auto tensor = new int[3 * 4 * 8].sliced(3, 4, 8);
     assert(&(tensor.back.back.back()) is &tensor[2, 3, 7]);
     assert(&(tensor.front.front.front()) is &tensor[0, 0, 0]);
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     auto slice = new int[24].sliced(2, 3, 4);
     auto r0 = slice.pack!1[1, 2];
@@ -732,7 +732,7 @@ pure nothrow version(mir_test) unittest
     assert(slice[1, 2, 3] == 4);
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     auto ar = new int[3 * 8 * 9];
 
diff --git a/source/mir/ndslice/slice.d b/source/mir/ndslice/slice.d
index e592369d..adf6436a 100644
--- a/source/mir/ndslice/slice.d
+++ b/source/mir/ndslice/slice.d
@@ -60,7 +60,7 @@ template hasAsSlice(T)
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.series;
     static assert(!hasAsSlice!(int[]));
@@ -73,7 +73,7 @@ Check if $(LREF toConst) function can be called with type T.
 enum isConvertibleToSlice(T) = isSlice!T || isDynamicArray!T || hasAsSlice!T;
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.series: SeriesMap;
     static assert(isConvertibleToSlice!(immutable int[]));
@@ -155,7 +155,7 @@ enum isSlice(T) = is(T : Slice!(Iterator, N, kind), Iterator, size_t N, SliceKin
 
 ///
 @safe pure nothrow @nogc
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     alias A = uint[];
     alias S = Slice!(int*);
@@ -211,7 +211,7 @@ enum kindOf(T : Slice!(Iterator, N, kind), Iterator, size_t N, SliceKind kind) =
 
 ///
 @safe pure nothrow @nogc
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     static assert(kindOf!(Slice!(int*, 1, Universal)) == Universal);
 }
@@ -270,7 +270,7 @@ auto sliced(size_t N, Iterator)(Iterator iterator, size_t[N] lengths...)
 }
 
 /// Random access range primitives for slices over user defined types
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     struct MyIota
     {
@@ -312,7 +312,7 @@ Slice!(T*) sliced(T)(T[] array) @trusted
 }
 
 /// Creates a slice from an array.
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     auto slice = new int[10].sliced;
     assert(slice.length == 10);
@@ -345,7 +345,7 @@ Slice!(Iterator, N, kind)
 }
 
 ///
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota;
     auto data = new int[24];
@@ -388,7 +388,7 @@ auto slicedField(Field)(Field field)
 }
 
 /// Creates an 1-dimensional slice over a field, array, or random access range.
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota;
     auto slice = 10.iota.slicedField;
@@ -904,7 +904,7 @@ public:
 
     // static if (doUnittest)
     // ///
-    // @safe pure version(mir_test) unittest
+    // @safe pure version(mir_ndslice_test) unittest
     // {
     //     import mir.ndslice.slice;
     //     alias Array = Slice!(double*);
@@ -922,7 +922,7 @@ public:
     static if (doUnittest)
     /// Creates a 2-dimentional slice with custom strides.
     nothrow pure
-    version(mir_test) unittest
+    version(mir_ndslice_test) unittest
     {
         uint[8] array = [1, 2, 3, 4, 5, 6, 7, 8];
         auto slice = Slice!(uint*, 2, Universal)([2, 2], [4, 1], array.ptr);
@@ -1089,7 +1089,7 @@ public:
 
         static if (doUnittest)
         ///
-        version(mir_test) unittest
+        version(mir_ndslice_test) unittest
         {
             static struct Foo
             {
@@ -1114,7 +1114,7 @@ public:
 
         static if (doUnittest)
         ///
-        version(mir_test) unittest
+        version(mir_ndslice_test) unittest
         {
             Slice!(double*, 2, Universal) nn;
             Slice!(immutable(double)*, 2, Universal) ni;
@@ -1216,7 +1216,7 @@ public:
 
     static if (doUnittest)
     ///
-    @safe version(mir_test) unittest
+    @safe version(mir_ndslice_test) unittest
     {
         auto arr = [1, 2, 3, 4];
         auto sl0 = arr.sliced;
@@ -1246,7 +1246,7 @@ public:
 
     static if (doUnittest)
     /// Regular slice
-    @safe @nogc pure nothrow version(mir_test) unittest
+    @safe @nogc pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : iota;
         assert(iota(3, 4, 5).shape == cast(size_t[3])[3, 4, 5]);
@@ -1255,7 +1255,7 @@ public:
     static if (doUnittest)
     /// Packed slice
     @safe @nogc pure nothrow
-    version(mir_test) unittest
+    version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : pack, iota;
         size_t[3] s = [3, 4, 5];
@@ -1292,7 +1292,7 @@ public:
     static if (doUnittest)
     /// Regular slice
     @safe @nogc pure nothrow
-    version(mir_test) unittest
+    version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : iota;
         size_t[3] s = [20, 5, 1];
@@ -1301,7 +1301,7 @@ public:
 
     static if (doUnittest)
     /// Modified regular slice
-    @safe @nogc pure nothrow version(mir_test) unittest
+    @safe @nogc pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : pack, iota, universal;
         import mir.ndslice.dynamic : reversed, strided, transposed;
@@ -1315,7 +1315,7 @@ public:
 
     static if (doUnittest)
     /// Packed slice
-    @safe @nogc pure nothrow version(mir_test) unittest
+    @safe @nogc pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : pack, iota;
         size_t[3] s = [20 * 42, 5 * 42, 1 * 42];
@@ -1335,7 +1335,7 @@ public:
 
     static if (doUnittest)
     /// Regular slice
-    @safe @nogc pure nothrow version(mir_test) unittest
+    @safe @nogc pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : iota;
         assert(iota(3, 4, 5)
@@ -1344,7 +1344,7 @@ public:
 
     static if (doUnittest)
     /// Modified regular slice
-    @safe @nogc pure nothrow version(mir_test) unittest
+    @safe @nogc pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : pack, iota, universal;
         import mir.ndslice.dynamic : reversed, strided, transposed;
@@ -1358,7 +1358,7 @@ public:
 
     static if (doUnittest)
     /// Packed slice
-    @safe @nogc pure nothrow version(mir_test) unittest
+    @safe @nogc pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : pack, iota;
         assert(iota(3, 4, 5, 6, 7)
@@ -1376,7 +1376,7 @@ public:
 
     static if (doUnittest)
     /// Save range
-    @safe @nogc pure nothrow version(mir_test) unittest
+    @safe @nogc pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : iota;
         auto slice = iota(2, 3).save;
@@ -1384,7 +1384,7 @@ public:
 
     static if (doUnittest)
     /// Pointer type.
-    @safe pure nothrow version(mir_test) unittest
+    @safe pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.allocation;
         //sl type is `Slice!(2, int*)`
@@ -1404,7 +1404,7 @@ public:
 
     static if (doUnittest)
     ///
-    @safe @nogc pure nothrow version(mir_test) unittest
+    @safe @nogc pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : iota;
         auto slice = iota(3, 4, 5);
@@ -1445,7 +1445,7 @@ public:
 
     static if (doUnittest)
     /// Regular slice
-    @safe @nogc pure nothrow version(mir_test) unittest
+    @safe @nogc pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : iota;
         auto slice = iota(3, 4, 5);
@@ -1457,7 +1457,7 @@ public:
 
     static if (doUnittest)
     /// Modified regular slice
-    @safe @nogc pure nothrow version(mir_test) unittest
+    @safe @nogc pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.dynamic : reversed, strided, swapped;
         import mir.ndslice.topology : universal, iota;
@@ -1679,7 +1679,7 @@ public:
 
     static if (doUnittest)
     ///
-    @safe @nogc pure nothrow version(mir_test) unittest
+    @safe @nogc pure nothrow version(mir_ndslice_test) unittest
     {
         import std.range.primitives;
         import mir.ndslice.topology : iota, canonical;
@@ -1752,7 +1752,7 @@ public:
 
         static if (doUnittest)
         ///
-        @safe pure nothrow @nogc version(mir_test) unittest
+        @safe pure nothrow @nogc version(mir_ndslice_test) unittest
         {
             import mir.ndslice.topology: iota, universal, canonical;
             auto f = 5;
@@ -1776,7 +1776,7 @@ public:
 
         static if (doUnittest)
         ///
-        @safe pure nothrow @nogc version(mir_test) unittest
+        @safe pure nothrow @nogc version(mir_ndslice_test) unittest
         {
             import mir.ndslice.topology: iota;
             auto f = 5;
@@ -1794,7 +1794,7 @@ public:
 
         static if (doUnittest)
         ///
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.topology: iota, canonical;
             auto v = [2, 3].iota.canonical;
@@ -1813,7 +1813,7 @@ public:
 
         static if (doUnittest)
         ///
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.topology: iota, canonical;
             auto v = [2, 3].iota.canonical;
@@ -1854,7 +1854,7 @@ public:
 
     static if (doUnittest)
     ///
-    @safe pure nothrow @nogc version(mir_test) unittest
+    @safe pure nothrow @nogc version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : iota, canonical;
         auto s = iota(2, 3).canonical;
@@ -1889,7 +1889,7 @@ public:
 
     static if (doUnittest)
     ///
-    @safe @nogc pure nothrow version(mir_test) unittest
+    @safe @nogc pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : iota;
         auto s = iota(2, 3);
@@ -1909,7 +1909,7 @@ public:
 
     static if (doUnittest)
     /// Regular slice
-    @safe @nogc pure nothrow version(mir_test) unittest
+    @safe @nogc pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : iota;
         assert(iota(3, 4, 5).elementCount == 60);
@@ -1918,7 +1918,7 @@ public:
 
     static if (doUnittest)
     /// Packed slice
-    @safe @nogc pure nothrow version(mir_test) unittest
+    @safe @nogc pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : pack, evertPack, iota;
         auto slice = iota(3, 4, 5, 6, 7, 8);
@@ -1955,7 +1955,7 @@ public:
 
     static if (doUnittest)
     ///
-    @safe @nogc pure nothrow version(mir_test) unittest
+    @safe @nogc pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : iota;
         auto sl = iota(3, 4);
@@ -1987,7 +1987,7 @@ public:
 
     static if (doUnittest)
     ///
-    @safe @nogc pure nothrow version(mir_test) unittest
+    @safe @nogc pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : iota;
         auto sl = iota(3, 4);
@@ -2020,7 +2020,7 @@ public:
 
     static if (doUnittest)
     ///
-    @safe @nogc pure nothrow version(mir_test) unittest
+    @safe @nogc pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology : iota;
         auto sl = iota(3, 4);
@@ -2085,7 +2085,7 @@ public:
     static if (doUnittest)
     ///
     @safe pure nothrow
-    version(mir_test) unittest
+    version(mir_ndslice_test) unittest
     {
         auto a = [1, 2, 3, 4].sliced(2, 2);
 
@@ -2100,7 +2100,7 @@ public:
     }
 
     static if (doUnittest)
-    @safe pure nothrow version(mir_test) unittest
+    @safe pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.allocation: slice;
         import mir.ndslice.topology : iota;
@@ -2277,7 +2277,7 @@ public:
 
     static if (doUnittest)
     ///
-    pure nothrow version(mir_test) unittest
+    pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.allocation;
         auto slice = slice!int(5, 3);
@@ -2307,7 +2307,7 @@ public:
 
     static if (doUnittest)
     ///
-    @safe pure nothrow version(mir_test) unittest
+    @safe pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.allocation: slice;
         auto sli = slice!int(4, 3);
@@ -2342,7 +2342,7 @@ public:
 
     static if (doUnittest)
     ///
-    @safe pure nothrow version(mir_test) unittest
+    @safe pure nothrow version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology: iota;
         import mir.ndslice.allocation: slice;
@@ -2387,7 +2387,7 @@ public:
 
     static if (doUnittest)
     ///
-    version(mir_test) unittest
+    version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology;
 
@@ -2428,7 +2428,7 @@ public:
 
     static if (doUnittest)
     ///
-    @safe pure nothrow @nogc version(mir_test) unittest
+    @safe pure nothrow @nogc version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology;
 
@@ -2442,7 +2442,7 @@ public:
 
     static if (doUnittest)
     ///
-    @safe pure nothrow @nogc version(mir_test) unittest
+    @safe pure nothrow @nogc version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology;
 
@@ -2473,7 +2473,7 @@ public:
 
     static if (doUnittest)
     ///
-    @safe pure nothrow @nogc version(mir_test) unittest
+    @safe pure nothrow @nogc version(mir_ndslice_test) unittest
     {
         import mir.ndslice.topology: iota, map, zip;
 
@@ -2527,7 +2527,7 @@ public:
 
     static if (doUnittest)
     ///
-    @safe pure version(mir_test) unittest
+    @safe pure version(mir_ndslice_test) unittest
     {
         import mir.ndslice;
         auto x = 3.iota!int;
@@ -2582,7 +2582,7 @@ public:
 
     static if (doUnittest)
     ///
-    @safe pure version(mir_test) unittest
+    @safe pure version(mir_ndslice_test) unittest
     {
         import mir.ndslice;
         auto x = 3.iota!int;
@@ -2646,7 +2646,7 @@ public:
     }
 
     ///
-    version(mir_test)
+    version(mir_ndslice_test)
     @safe pure @nogc nothrow
     unittest
     {
@@ -2726,7 +2726,7 @@ public:
 
         static if (doUnittest)
         ///
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.allocation;
             auto a = slice!int(2, 3);
@@ -2748,7 +2748,7 @@ public:
 
         static if (doUnittest)
         /// Left slice is packed
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.topology : blocks, iota;
             import mir.ndslice.allocation : slice;
@@ -2764,7 +2764,7 @@ public:
 
         static if (doUnittest)
         /// Both slices are packed
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.topology : blocks, iota, pack;
             import mir.ndslice.allocation : slice;
@@ -2850,7 +2850,7 @@ public:
 
         static if (doUnittest)
         ///
-        pure nothrow version(mir_test) unittest
+        pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.allocation;
             auto a = slice!int(2, 3);
@@ -2874,7 +2874,7 @@ public:
 
         static if (doUnittest)
         /// Packed slices
-        pure nothrow version(mir_test) unittest
+        pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.allocation : slice;
             import mir.ndslice.topology : blocks;
@@ -2956,7 +2956,7 @@ public:
         static if (doUnittest)
         ///
         @safe pure nothrow
-        version(mir_test) unittest
+        version(mir_ndslice_test) unittest
         {
             import mir.ndslice.allocation;
             auto a = slice!int(2, 3);
@@ -2983,7 +2983,7 @@ public:
 
         static if (doUnittest)
         /// Packed slices have the same behavior.
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.allocation;
             import mir.ndslice.topology : pack;
@@ -3019,7 +3019,7 @@ public:
 
         static if (doUnittest)
         ///
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.allocation;
             auto a = slice!int(2, 3);
@@ -3029,7 +3029,7 @@ public:
         }
 
         static if (doUnittest)
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             auto a = new int[6].sliced(2, 3);
 
@@ -3059,7 +3059,7 @@ public:
 
         static if (doUnittest)
         ///
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.allocation;
             auto a = slice!int(2, 3);
@@ -3069,7 +3069,7 @@ public:
         }
 
         static if (doUnittest)
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             auto a = new int[6].sliced(2, 3);
 
@@ -3092,7 +3092,7 @@ public:
 
         static if (doUnittest)
         ///
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.allocation;
             auto a = slice!int(2, 3);
@@ -3113,7 +3113,7 @@ public:
 
         static if (doUnittest)
         /// Left slice is packed
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.allocation : slice;
             import mir.ndslice.topology : blocks, iota;
@@ -3129,7 +3129,7 @@ public:
 
         static if (doUnittest)
         /// Both slices are packed
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.allocation : slice;
             import mir.ndslice.topology : blocks, iota, pack;
@@ -3157,7 +3157,7 @@ public:
 
         static if (doUnittest)
         ///
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.allocation : slice;
             auto a = slice!int(2, 3);
@@ -3178,7 +3178,7 @@ public:
         static if (doUnittest)
         /// Packed slices
         @safe pure nothrow
-        version(mir_test) unittest
+        version(mir_ndslice_test) unittest
         {
             import mir.ndslice.allocation : slice;
             import mir.ndslice.topology : blocks;
@@ -3236,7 +3236,7 @@ public:
 
         static if (doUnittest)
         ///
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.allocation;
             auto a = slice!int(2, 3);
@@ -3262,7 +3262,7 @@ public:
 
         static if (doUnittest)
         /// Packed slices have the same behavior.
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.allocation;
             import mir.ndslice.topology : pack;
@@ -3291,7 +3291,7 @@ public:
 
         static if (doUnittest)
         ///
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.allocation;
             auto a = slice!int(2, 3);
@@ -3302,7 +3302,7 @@ public:
 
         // Issue 16473
         static if (doUnittest)
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             import mir.ndslice.allocation;
             auto sl = slice!double(2, 5);
@@ -3310,7 +3310,7 @@ public:
         }
 
         static if (doUnittest)
-        @safe pure nothrow version(mir_test) unittest
+        @safe pure nothrow version(mir_ndslice_test) unittest
         {
             auto a = new int[6].sliced(2, 3);
 
@@ -3351,7 +3351,7 @@ public:
         static if (doUnittest)
         ///
         @safe pure nothrow
-        version(mir_test) unittest
+        version(mir_ndslice_test) unittest
         {
             import mir.ndslice.allocation;
             auto a = slice!int(2, 3);
@@ -3372,7 +3372,7 @@ alias Slice = mir_slice;
 /++
 Slicing, indexing, and arithmetic operations.
 +/
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation;
     import mir.ndslice.dynamic : transposed;
@@ -3406,7 +3406,7 @@ pure nothrow version(mir_test) unittest
 /++
 Operations with rvalue slices.
 +/
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation;
     import mir.ndslice.topology: universal;
@@ -3440,7 +3440,7 @@ pure nothrow version(mir_test) unittest
 Creating a slice from text.
 See also $(MREF std, format).
 +/
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.algorithm.iteration: filter, all;
     import mir.array.allocation;
@@ -3482,7 +3482,7 @@ version(mir_test) unittest
 }
 
 // Slicing
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota;
     auto a = iota(10, 20, 30, 40);
@@ -3495,7 +3495,7 @@ version(mir_test) unittest
 }
 
 // Operator overloading. # 1
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation;
     import mir.ndslice.topology : iota;
@@ -3515,7 +3515,7 @@ pure nothrow version(mir_test) unittest
 }
 
 // Operator overloading. # 2
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: map, iota;
     import mir.array.allocation : array;
@@ -3537,7 +3537,7 @@ pure nothrow version(mir_test) unittest
 }
 
 // Operator overloading. # 3
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation;
     import mir.ndslice.topology : iota;
@@ -3559,7 +3559,7 @@ pure nothrow version(mir_test) unittest
 }
 
 // Type deduction
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     // Arrays
     foreach (T; AliasSeq!(int, const int, immutable int))
@@ -3573,7 +3573,7 @@ version(mir_test) unittest
 }
 
 // Test for map #1
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: map, byDim;
     auto slice = [1, 2, 3, 4].sliced(2, 2);
@@ -3595,7 +3595,7 @@ version(mir_test) unittest
 }
 
 // Test for map #2
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: map, byDim;
     import std.range.primitives;
@@ -3656,7 +3656,7 @@ private bool _checkAssignLengths(
     }
 }
 
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota;
 
@@ -3666,7 +3666,7 @@ private bool _checkAssignLengths(
     assert(!_checkAssignLengths(iota(2, 2), iota(3, 3)));
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     auto slice = new int[15].slicedField(5, 3);
 
@@ -3679,7 +3679,7 @@ pure nothrow version(mir_test) unittest
     auto col = slice[0..$, 1];
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     auto a = new int[6].slicedField(2, 3);
     auto b = [1, 2, 3, 4].sliced(2, 2);
@@ -3697,7 +3697,7 @@ pure nothrow version(mir_test) unittest
     assert(a[1] == [1, 2, 0]);
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     auto a = new int[6].slicedField(2, 3);
     auto b = [[1, 2], [3, 4]];
@@ -3718,7 +3718,7 @@ pure nothrow version(mir_test) unittest
     assert(a[1] == [3, 4, 6]);
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     auto a = new int[6].slicedField(2, 3);
 
@@ -3741,7 +3741,7 @@ pure nothrow version(mir_test) unittest
     //assert(a[1] == [5, 5, 9]);
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     auto a = new int[6].slicedField(2, 3);
 
@@ -3749,7 +3749,7 @@ pure nothrow version(mir_test) unittest
     assert(a[1, 2] == 3);
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     auto a = new int[6].slicedField(2, 3);
 
@@ -3757,7 +3757,7 @@ pure nothrow version(mir_test) unittest
     assert(a[[1, 2]] == 3);
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     auto a = new int[6].slicedField(2, 3);
 
@@ -3765,7 +3765,7 @@ pure nothrow version(mir_test) unittest
     assert(a[1, 2] == 3);
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     auto a = new int[6].slicedField(2, 3);
 
@@ -3773,7 +3773,7 @@ pure nothrow version(mir_test) unittest
     assert(a[[1, 2]] == 3);
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     auto a = new int[6].slicedField(2, 3);
     auto b = [1, 2, 3, 4].sliced(2, 2);
@@ -3791,7 +3791,7 @@ pure nothrow version(mir_test) unittest
     assert(a[1] == [8, 12, 0]);
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     auto a = new int[6].slicedField(2, 3);
 
@@ -3808,7 +3808,7 @@ pure nothrow version(mir_test) unittest
     assert(a[1] == [8, 12, 0]);
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     auto a = new int[6].slicedField(2, 3);
 
@@ -3822,7 +3822,7 @@ pure nothrow version(mir_test) unittest
     assert(a[1] == [6, 6, 1]);
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     auto a = new int[6].slicedField(2, 3);
 
@@ -3830,7 +3830,7 @@ pure nothrow version(mir_test) unittest
     assert(a[1, 2] == 1);
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     auto a = new int[6].slicedField(2, 3);
 
@@ -3838,7 +3838,7 @@ pure nothrow version(mir_test) unittest
     assert(a[[1, 2]] == 1);
 }
 
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     auto a = new int[6].slicedField(2, 3);
 
@@ -3849,7 +3849,7 @@ pure nothrow version(mir_test) unittest
     assert(a[1] == [0, 0, 1]);
 }
 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: iota, universal;
 
@@ -3857,13 +3857,13 @@ version(mir_test) unittest
     assert(sl[0 .. $] == sl);
 }
 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: canonical, iota;
     static assert(kindOf!(typeof(iota([1, 2]).canonical[1])) == Contiguous);
 }
 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: iota;
     auto s = iota(2, 3);
@@ -3897,7 +3897,7 @@ auto ndassign(string op = "", L, R)(L lside, auto ref R rside) @property
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: iota;
     import mir.ndslice.allocation: slice;
@@ -3917,7 +3917,7 @@ version(mir_test) unittest
     assert(vector == [5, 7, 9]);
 }
 
-version(mir_test) pure nothrow unittest
+version(mir_ndslice_test) pure nothrow unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: universal;
@@ -3946,7 +3946,7 @@ version(mir_test) pure nothrow unittest
     assert(immdf2.label!1[1] == 2);
 }
 
-version(mir_test) pure nothrow unittest
+version(mir_ndslice_test) pure nothrow unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.topology: universal;
@@ -3962,7 +3962,7 @@ version(mir_test) pure nothrow unittest
     assert(immvalues[0][0] == 5);
 }
 
-version(mir_test) @safe unittest
+version(mir_ndslice_test) @safe unittest
 {
     import mir.ndslice.allocation;
     auto a = rcslice!double([2, 3], 0);
@@ -3972,7 +3972,7 @@ version(mir_test) @safe unittest
     assert(a == b);
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure @nogc nothrow
 unittest
 {
@@ -3986,7 +3986,7 @@ unittest
     }
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure @nogc nothrow
 unittest
 {
@@ -4000,7 +4000,7 @@ unittest
     }
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure @nogc nothrow
 unittest
 {
@@ -4016,7 +4016,7 @@ unittest
 }
 
 
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure @nogc nothrow
 unittest
 {
@@ -4032,7 +4032,7 @@ unittest
 }
 
 
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure @nogc nothrow
 unittest
 {
@@ -4048,7 +4048,7 @@ unittest
     }
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure @nogc nothrow
 unittest
 {
@@ -4064,7 +4064,7 @@ unittest
     }
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure @nogc nothrow
 unittest
 {
@@ -4078,7 +4078,7 @@ unittest
     }
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure @nogc nothrow
 unittest
 {
@@ -4092,7 +4092,7 @@ unittest
     }
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure @nogc nothrow
 unittest // check it can be compiled
 {
@@ -4101,7 +4101,7 @@ unittest // check it can be compiled
     alias D = Variant!S;
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 unittest
 {
     import mir.ndslice;
diff --git a/source/mir/ndslice/sorting.d b/source/mir/ndslice/sorting.d
index da0103bf..1c869b81 100644
--- a/source/mir/ndslice/sorting.d
+++ b/source/mir/ndslice/sorting.d
@@ -24,7 +24,7 @@ Macros:
 module mir.ndslice.sorting;
 
 /// Check if ndslice is sorted, or strictly monotonic.
-@safe pure version(mir_test) unittest
+@safe pure version(mir_ndslice_test) unittest
 {
     import mir.algorithm.iteration: all;
     import mir.ndslice.slice: sliced;
@@ -48,7 +48,7 @@ module mir.ndslice.sorting;
 }
 
 /// Create index
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.algorithm.iteration: all;
     import mir.ndslice.allocation: slice;
@@ -65,7 +65,7 @@ version(mir_test) unittest
 }
 
 /// Schwartzian transform
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.algorithm.iteration: all;
     import mir.ndslice.allocation: slice;
@@ -87,7 +87,7 @@ import mir.math.common: optmath;
 
 @optmath:
 
-@safe pure version(mir_test) unittest
+@safe pure version(mir_ndslice_test) unittest
 {
     import mir.algorithm.iteration: all;
     import mir.ndslice.topology: pairwise;
@@ -104,7 +104,7 @@ import mir.math.common: optmath;
     assert(c.pairwise!"a <= b".all);
 }
 
-@safe pure version(mir_test) unittest
+@safe pure version(mir_ndslice_test) unittest
 {
     import mir.algorithm.iteration: all;
     import mir.ndslice.topology: pairwise;
@@ -212,7 +212,7 @@ template sort(alias less = "a < b")
 }
 
 ///
-@safe pure version(mir_test) unittest
+@safe pure version(mir_ndslice_test) unittest
 {
     import mir.algorithm.iteration: all;
     import mir.ndslice.slice;
@@ -227,7 +227,7 @@ template sort(alias less = "a < b")
 }
 
 /// one-dimensional series
-pure version(mir_test) unittest
+pure version(mir_ndslice_test) unittest
 {
     import mir.series;
 
@@ -248,7 +248,7 @@ pure version(mir_test) unittest
 }
 
 /// two-dimensional series
-pure version(mir_test) unittest
+pure version(mir_ndslice_test) unittest
 {
     import mir.series;
     import mir.ndslice.allocation: uninitSlice;
@@ -579,7 +579,7 @@ template assumeSortedEqualIndex(alias test = "a < b")
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure unittest
 {
     // sorted: a < b
@@ -644,7 +644,7 @@ template transitionIndex(alias test = "a < b")
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure unittest
 {
     // sorted: a < b
@@ -709,7 +709,7 @@ I[] makeIndex(I = size_t, alias less = "a < b", T)(scope T[] r)
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow
 unittest
 {
@@ -723,7 +723,7 @@ unittest
 }
 
 /// Sort based on index created from a separate array
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow
 unittest
 {
@@ -811,7 +811,7 @@ template pivotPartition(alias less = "a < b")
 }
 
 /// pivotPartition with 1-dimensional Slice
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow
 unittest
 {
@@ -826,7 +826,7 @@ unittest
 }
 
 /// pivotPartition with 2-dimensional Slice
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure
 unittest
 {
@@ -846,7 +846,7 @@ unittest
     assert(xFlattened[pivot .. $].all!(a => a >= xFlattened[pivot]));
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @safe
 unittest
 {
@@ -943,7 +943,7 @@ template pivotPartitionImpl(alias less)
             for (;;)
             {
                 // Loop invariant
-                version(mir_test)
+                version(mir_ndslice_test)
                 {
                     // this used to import std.algorithm.all, but we want to
                     // save imports when unittests are enabled if possible.
@@ -1004,7 +1004,7 @@ template pivotPartitionImpl(alias less)
     }
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow
 unittest {
     import mir.ndslice.sorting: partitionAt;
@@ -1018,7 +1018,7 @@ unittest {
 }
 
 
-version(mir_test)
+version(mir_ndslice_test)
 @trusted pure nothrow
 unittest
 {
@@ -1091,7 +1091,7 @@ template partitionAt(alias less = "a < b")
 }
 
 /// Partition 1-dimensional slice at nth
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1103,7 +1103,7 @@ unittest {
 }
 
 /// Partition 2-dimensional slice
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1115,7 +1115,7 @@ unittest {
 }
 
 /// Can supply alternate ordering function
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1127,7 +1127,7 @@ unittest {
 }
 
 // Check issue #328 fixed
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1172,7 +1172,7 @@ version(unittest) {
     }
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1306,7 +1306,7 @@ void partitionAtImpl(alias less, Iterator)(
     }
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @trusted pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1319,7 +1319,7 @@ unittest {
     assert(x[nth] == 2);
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @trusted pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1332,7 +1332,7 @@ unittest {
     assert(x[2, 0] == 5);
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @trusted pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1345,7 +1345,7 @@ unittest {
     assert(x[nth] == 0);
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @trusted pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1358,7 +1358,7 @@ unittest {
     assert(x[nth] == 3);
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @trusted pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1371,7 +1371,7 @@ unittest {
     assert(x[nth] == 3);
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @trusted pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1384,7 +1384,7 @@ unittest {
     assert(x[nth] == 7);
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @trusted pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1397,7 +1397,7 @@ unittest {
     assert(x[nth] == 8);
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @trusted pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1411,7 +1411,7 @@ unittest {
 }
 
 // Check all partitionAt
-version(mir_test)
+version(mir_ndslice_test)
 @trusted pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1491,7 +1491,7 @@ Iterator partitionAtPartition(alias less, Iterator)(
     return expandPartition!less(frontI, lastI, loI, pivotI, hiI);
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @trusted pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1549,7 +1549,7 @@ Iterator partitionAtPartitionOffMedian(alias less, bool leanRight, Iterator)(
     return expandPartition!less(frontI, lastI, loI, pivotI, hiI);
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @trusted pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1562,7 +1562,7 @@ unittest {
     assert(x.equal([6, 7, 8, 9, 5, 0, 2, 7, 9, 15, 10, 25, 11, 10, 13, 18, 17, 13, 25, 22]));
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @trusted pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1598,7 +1598,7 @@ void p3(alias less, Iterator)(
     }
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @trusted pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1656,7 +1656,7 @@ template p4(alias less, bool leanRight)
     }
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @trusted pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1671,7 +1671,7 @@ unittest {
     assert(x.equal([3, 1, 0, 4, 2, 6, 4, 7, 5]));
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @trusted pure nothrow
 unittest {
     import mir.ndslice.slice: sliced;
@@ -1806,7 +1806,7 @@ template expandPartition(alias less)
     }
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 @trusted pure nothrow
 unittest
 {
@@ -1821,7 +1821,7 @@ unittest
     assert(expandPartition!((a, b) => a < b)(frontI, lastI, loI, pivotI, hiI) == (frontI + 9));
 }
 
-version(mir_test)
+version(mir_ndslice_test)
 unittest
 {
     import std.random;
diff --git a/source/mir/ndslice/topology.d b/source/mir/ndslice/topology.d
index 9aeb0c0c..05ddde30 100644
--- a/source/mir/ndslice/topology.d
+++ b/source/mir/ndslice/topology.d
@@ -165,7 +165,7 @@ template asKindOf(SliceKind kind)
 
 /// Universal
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice: Universal;
     auto slice = iota(2, 3).asKindOf!Universal;
@@ -176,7 +176,7 @@ version(mir_test) unittest
 
 /// Canonical
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice: Canonical;
     auto slice = iota(2, 3).asKindOf!Canonical;
@@ -187,7 +187,7 @@ version(mir_test) unittest
 
 /// Contiguous
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice: Contiguous;
     auto slice = iota(2, 3).asKindOf!Contiguous;
@@ -250,7 +250,7 @@ auto universal(Iterator, size_t N, SliceKind kind, Labels...)(Slice!(Iterator, N
 
 ///
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto slice = iota(2, 3).universal;
     assert(slice == [[0, 1, 2], [3, 4, 5]]);
@@ -259,7 +259,7 @@ version(mir_test) unittest
 }
 
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto slice = iota(2, 3).canonical.universal;
     assert(slice == [[0, 1, 2], [3, 4, 5]]);
@@ -269,7 +269,7 @@ version(mir_test) unittest
 
 ///
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.allocation: slice;
@@ -329,7 +329,7 @@ Slice!(Iterator, N, N == 1 ? Contiguous : Canonical, Labels)
 
 ///
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto slice = iota(2, 3).canonical;
     assert(slice == [[0, 1, 2], [3, 4, 5]]);
@@ -339,7 +339,7 @@ version(mir_test) unittest
 
 ///
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.allocation: slice;
@@ -396,7 +396,7 @@ Slice!(Iterator, N, Canonical, Labels)
 
 ///
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto slice = iota(2, 3).universal.assumeCanonical;
     assert(slice == [[0, 1, 2], [3, 4, 5]]);
@@ -406,7 +406,7 @@ version(mir_test) unittest
 
 ///
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.allocation: slice;
@@ -458,7 +458,7 @@ Slice!(Iterator, N, Contiguous, Labels)
 
 ///
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto slice = iota(2, 3).universal.assumeContiguous;
     assert(slice == [[0, 1, 2], [3, 4, 5]]);
@@ -468,7 +468,7 @@ version(mir_test) unittest
 
 ///
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.allocation: slice;
@@ -502,7 +502,7 @@ void assumeHypercube
 }
 
 ///
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     auto b = iota(5, 5);
     
@@ -526,7 +526,7 @@ void assumeSameShape(T...)
 }
 
 ///
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     auto a = iota(5, 5);
     auto b = iota(5, 5);
@@ -568,7 +568,7 @@ pack(size_t P, Iterator, size_t N, SliceKind kind)(Slice!(Iterator, N, kind) sli
 }
 
 ///
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice: sliced, Slice;
 
@@ -622,7 +622,7 @@ ipack(size_t P, Iterator, size_t N, SliceKind kind)(Slice!(Iterator, N, kind) sl
 }
 
 ///
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice: sliced, Slice;
 
@@ -696,7 +696,7 @@ evertPack(Iterator, size_t M, SliceKind innerKind, size_t N, SliceKind outerKind
 }
 
 ///
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.dynamic : transposed;
     auto slice = iota(3, 4, 5, 6, 7, 8, 9, 10, 11).universal;
@@ -710,7 +710,7 @@ evertPack(Iterator, size_t M, SliceKind innerKind, size_t N, SliceKind outerKind
 }
 
 ///
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.iterator: SliceIterator;
     import mir.ndslice.slice: sliced, Slice, Universal;
@@ -726,7 +726,7 @@ evertPack(Iterator, size_t M, SliceKind innerKind, size_t N, SliceKind outerKind
 
 ///
 @safe pure nothrow @nogc
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto a = iota(3, 4, 5, 6, 7, 8, 9, 10, 11);
     auto b = a.pack!2.unpack;
@@ -819,7 +819,7 @@ iota
 }
 
 ///
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     import mir.primitives: DeepElementType;
     auto slice = iota(2, 3);
@@ -834,7 +834,7 @@ iota
 
 ///
 pure nothrow @nogc
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     int[6] data;
     auto slice = iota([2, 3], data.ptr);
@@ -845,7 +845,7 @@ version(mir_test) unittest
 
 ///
 @safe pure nothrow @nogc
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto im = iota([10, 5], 100);
     assert(im[2, 1] == 111); // 100 + 2 * 5 + 1
@@ -856,7 +856,7 @@ version(mir_test) unittest
 }
 
 /// `iota` with step
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     auto sl = iota([2, 3], 10, 10);
 
@@ -906,7 +906,7 @@ Slice!(Iterator, 1, N == 1 ? kind : Universal)
 }
 
 /// Matrix, main diagonal
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     //  -------
     // | 0 1 2 |
@@ -919,7 +919,7 @@ Slice!(Iterator, 1, N == 1 ? kind : Universal)
 }
 
 /// Non-square matrix
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     //  -------
     // | 0 1 |
@@ -933,7 +933,7 @@ Slice!(Iterator, 1, N == 1 ? kind : Universal)
 }
 
 /// Loop through diagonal
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.allocation;
@@ -950,7 +950,7 @@ Slice!(Iterator, 1, N == 1 ? kind : Universal)
 
 /// Matrix, subdiagonal
 @safe @nogc pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     //  -------
     // | 0 1 2 |
@@ -965,7 +965,7 @@ version(mir_test) unittest
 }
 
 /// 3D, main diagonal
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     //  -----------
     // |  0   1  2 |
@@ -981,7 +981,7 @@ version(mir_test) unittest
 }
 
 /// 3D, subdiagonal
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     //  -----------
     // |  0   1  2 |
@@ -1000,7 +1000,7 @@ version(mir_test) unittest
 
 /// 3D, diagonal plain
 @nogc @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     //  -----------
     // |  0   1  2 |
@@ -1065,7 +1065,7 @@ Slice!(Iterator, 1, Universal)
 }
 
 ///
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     //  -----
     // | 0 1 |
@@ -1079,7 +1079,7 @@ Slice!(Iterator, 1, Universal)
 }
 
 ///
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     //  -------
     // | 0 1 2 |
@@ -1140,7 +1140,7 @@ do
 }
 
 ///
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.allocation;
@@ -1168,7 +1168,7 @@ pure nothrow version(mir_test) unittest
 }
 
 /// Diagonal blocks
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.allocation;
@@ -1200,7 +1200,7 @@ pure nothrow version(mir_test) unittest
 }
 
 /// Matrix divided into vertical blocks
-@safe pure version(mir_test) unittest
+@safe pure version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation;
     import mir.ndslice.slice;
@@ -1272,7 +1272,7 @@ do
 
 ///
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation;
     import mir.ndslice.slice;
@@ -1295,7 +1295,7 @@ version(mir_test) unittest
 }
 
 ///
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation;
     import mir.ndslice.slice;
@@ -1316,7 +1316,7 @@ version(mir_test) unittest
 }
 
 /// Multi-diagonal matrix
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation;
     import mir.ndslice.slice;
@@ -1341,7 +1341,7 @@ version(mir_test) unittest
 }
 
 /// Sliding window over matrix columns
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation;
     import mir.ndslice.slice;
@@ -1364,7 +1364,7 @@ version(mir_test) unittest
 }
 
 /// Overlapping blocks using windows
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     //  ----------------
     // |  0  1  2  3  4 |
@@ -1399,7 +1399,7 @@ version(mir_test) unittest
               [[12, 13, 14], [17, 18, 19], [22, 23, 24]]]]);
 }
 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto w = iota(9, 9).windows(3, 3);
     assert(w.front == w[0]);
@@ -1521,7 +1521,7 @@ Slice!(Iterator, M, kind) reshape
 
 ///
 @safe nothrow pure
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.dynamic : allReversed;
     int err;
@@ -1538,7 +1538,7 @@ version(mir_test) unittest
 }
 
 /// Reshaping with memory allocation
-@safe pure version(mir_test) unittest
+@safe pure version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice: sliced;
     import mir.ndslice.allocation: slice;
@@ -1569,7 +1569,7 @@ version(mir_test) unittest
          [ 1, 2,  3]]);
 }
 
-nothrow @safe pure version(mir_test) unittest
+nothrow @safe pure version(mir_ndslice_test) unittest
 {
     import mir.ndslice.dynamic : allReversed;
     auto slice = iota(1, 1, 3, 2, 1, 2, 1).universal.allReversed;
@@ -1584,14 +1584,14 @@ nothrow @safe pure version(mir_test) unittest
 
 // Issue 15919
 nothrow @nogc @safe pure
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     int err;
     assert(iota(3, 4, 5, 6, 7).pack!2.reshape([4, 3, 5], err)[0, 0, 0].shape == cast(size_t[2])[6, 7]);
     assert(err == 0);
 }
 
-nothrow @nogc @safe pure version(mir_test) unittest
+nothrow @nogc @safe pure version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
 
@@ -1607,7 +1607,7 @@ nothrow @nogc @safe pure version(mir_test) unittest
 }
 
 nothrow @nogc @safe pure
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto pElements = iota(3, 4, 5, 6, 7)
         .pack!2
@@ -1670,7 +1670,7 @@ Slice!(StrideIterator!Iterator)
     return slice.move.hideStride;
 }
 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     auto sl1 = iota(2, 3).slice.universal.pack!1.flattened;
@@ -1679,14 +1679,14 @@ version(mir_test) unittest
 }
 
 /// Regular slice
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     assert(iota(4, 5).flattened == iota(20));
     assert(iota(4, 5).canonical.flattened == iota(20));
     assert(iota(4, 5).universal.flattened == iota(20));
 }
 
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     assert(iota(4).flattened == iota(4));
     assert(iota(4).canonical.flattened == iota(4));
@@ -1694,7 +1694,7 @@ version(mir_test) unittest
 }
 
 /// Packed slice
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.dynamic;
@@ -1702,7 +1702,7 @@ version(mir_test) unittest
 }
 
 /// Properties
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     auto elems = iota(3, 4).universal.flattened;
 
@@ -1717,7 +1717,7 @@ version(mir_test) unittest
 }
 
 /// Index property
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     auto slice = new long[20].sliced(5, 4);
@@ -1735,7 +1735,7 @@ version(mir_test) unittest
          [40, 43, 46, 49]]);
 }
 
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     auto elems = iota(3, 4).universal.flattened;
     assert(elems.front == 0);
@@ -1745,7 +1745,7 @@ version(mir_test) unittest
 /++
 Random access and slicing
 +/
-nothrow version(mir_test) unittest
+nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.slice: sliced;
@@ -1777,7 +1777,7 @@ nothrow version(mir_test) unittest
     assert(elems[2 .. 6] == sl);
 }
 
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.dynamic : allReversed;
 
@@ -1799,7 +1799,7 @@ nothrow version(mir_test) unittest
     }
 }
 
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import std.range.primitives : isRandomAccessRange, hasSlicing;
     auto elems = iota(4, 5).flattened;
@@ -1808,7 +1808,7 @@ nothrow version(mir_test) unittest
 }
 
 // Checks strides
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.dynamic;
     import std.range.primitives : isRandomAccessRange;
@@ -1824,7 +1824,7 @@ nothrow version(mir_test) unittest
     }
 }
 
-@safe @nogc pure nothrow version(mir_test) unittest
+@safe @nogc pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice;
     import mir.ndslice.dynamic;
@@ -1865,7 +1865,7 @@ nothrow version(mir_test) unittest
 }
 
 // Issue 15549
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import std.range.primitives;
     import mir.ndslice.allocation;
@@ -1880,7 +1880,7 @@ version(mir_test) unittest
 }
 
 // Issue 16010
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto s = iota(3, 4).flattened;
     foreach (_; 0 .. s.length)
@@ -1908,7 +1908,7 @@ Slice!(FieldIterator!(ndIotaField!N), N)
 }
 
 ///
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     auto slice = ndiota(2, 3);
     static immutable array =
@@ -1919,7 +1919,7 @@ Slice!(FieldIterator!(ndIotaField!N), N)
 }
 
 ///
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     auto im = ndiota(7, 9);
 
@@ -1930,7 +1930,7 @@ Slice!(FieldIterator!(ndIotaField!N), N)
     assert(cm[2, 1] == [3, 5]);
 }
 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto r = ndiota(1);
     auto d = r.front;
@@ -1966,7 +1966,7 @@ auto linspace(T, size_t N)(size_t[N] lengths, T[2][N] intervals...)
 }
 
 // example from readme
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice;
     // import std.stdio: writefln;
@@ -1985,7 +1985,7 @@ version(mir_test) unittest
 
 /// 1D
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto s = linspace!double([5], [1.0, 2.0]);
     assert(s == [1.0, 1.25, 1.5, 1.75, 2.0]);
@@ -2000,7 +2000,7 @@ version(mir_test) unittest
 
 /// 2D
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.functional: refTuple;
 
@@ -2025,7 +2025,7 @@ version(mir_test) unittest
 
 /// Complex numbers
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.complex;
     alias C = Complex!double;
@@ -2071,7 +2071,7 @@ Slice!(SliceIterator!(Iterator, N, kind), M, Universal)
 
 ///
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto sl = iota(3).repeat(4);
     assert(sl == [[0, 1, 2],
@@ -2081,7 +2081,7 @@ version(mir_test) unittest
 }
 
 ///
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.dynamic : transposed;
 
@@ -2097,7 +2097,7 @@ version(mir_test) unittest
 }
 
 ///
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation;
 
@@ -2113,7 +2113,7 @@ version(mir_test) unittest
 }
 
 ///
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.primitives: DeepElementType;
 
@@ -2186,7 +2186,7 @@ auto cycle(size_t loopLength, T)(T withAsSlice, size_t length)
 }
 
 ///
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     auto slice = iota(3);
     assert(slice.cycle(7) == [0, 1, 2, 0, 1, 2, 0]);
@@ -2279,7 +2279,7 @@ auto stride(T)(T withAsSlice, ptrdiff_t factor)
 }
 
 ///
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     auto slice = iota(6);
     static immutable str = [0, 2, 4];
@@ -2290,7 +2290,7 @@ auto stride(T)(T withAsSlice, ptrdiff_t factor)
 }
 
 /// ND-compile time
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     auto slice = iota(4, 6);
     static immutable str = [[0, 2, 4], [12, 14, 16]];
@@ -2435,7 +2435,7 @@ struct RetroRange(Range)
 }
 
 ///
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     auto slice = iota(2, 3);
     static immutable reversed = [[5, 4, 3], [2, 1, 0]];
@@ -2449,7 +2449,7 @@ struct RetroRange(Range)
 }
 
 /// Ranges
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     import mir.algorithm.iteration: equal;
     import std.range: std_iota = iota;
@@ -2515,7 +2515,7 @@ auto bitwise(T)(T withAsSlice)
 
 ///
 @safe pure nothrow @nogc
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     size_t[10] data;
     auto bits = data[].bitwise;
@@ -2532,7 +2532,7 @@ version(mir_test) unittest
 }
 
 @safe pure nothrow @nogc
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     size_t[10] data;
     auto slice = FieldIterator!(size_t[])(0, data[]).sliced(10);
@@ -2626,7 +2626,7 @@ auto bitpack(size_t pack, T)(T withAsSlice)
 
 ///
 @safe pure nothrow @nogc
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     size_t[10] data;
     // creates a packed unsigned integer slice with max allowed value equal to `2^^6 - 1 == 63`.
@@ -2679,7 +2679,7 @@ auto bytegroup(size_t pack, DestinationType, T)(T withAsSlice)
 
 /// 24 bit integers
 @safe pure nothrow @nogc
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice: DeepElementType, sliced;
 
@@ -2701,7 +2701,7 @@ version(mir_test) unittest
 
 /// 48 bit integers
 @safe pure nothrow @nogc
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice: DeepElementType, sliced;
     ushort[20] data;
@@ -2853,7 +2853,7 @@ struct MapRange(alias fun, Range)
 
 ///
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota;
     auto s = iota(2, 3).map!(a => a * 3);
@@ -2863,7 +2863,7 @@ version(mir_test) unittest
 
 /// String lambdas
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota;
     assert(iota(2, 3).map!"a * 2" == [[0, 2, 4], [6, 8, 10]]);
@@ -2871,7 +2871,7 @@ version(mir_test) unittest
 
 /// Input ranges
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.algorithm.iteration: filter, equal;
     assert (6.iota.filter!"a % 2".map!"a * 10".equal([10, 30, 50])); 
@@ -2879,7 +2879,7 @@ version(mir_test) unittest
 
 /// Packed tensors
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota, windows;
     import mir.math.sum: sum;
@@ -2900,7 +2900,7 @@ version(mir_test) unittest
 
 /// Zipped tensors
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota, zip;
 
@@ -2923,7 +2923,7 @@ In that case, the element type of `map` is a refTuple containing
 one element for each function.
 +/
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota;
 
@@ -2940,7 +2940,7 @@ version(mir_test) unittest
 /++
 `map` can be aliased to a symbol and be used separately:
 +/
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota;
 
@@ -2951,7 +2951,7 @@ pure nothrow version(mir_test) unittest
 /++
 Type normalization
 +/
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.functional : pipe;
     import mir.ndslice.topology : iota;
@@ -2962,7 +2962,7 @@ version(mir_test) unittest
 }
 
 /// Use map with byDim/alongDim to apply functions to each dimension
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure
 unittest
 {
@@ -2988,7 +2988,7 @@ unittest
 Use map with a lambda and with byDim/alongDim, but may need to allocate result. 
 This example uses fuse, which allocates. Note: fuse!1 will transpose the result. 
 +/
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure
 unittest {
     import mir.ndslice.topology: iota, byDim, alongDim, map;
@@ -3013,7 +3013,7 @@ unittest {
 }
 
 ///
-pure version(mir_test) unittest
+pure version(mir_ndslice_test) unittest
 {
     import mir.algorithm.iteration: reduce;
     import mir.math.common: fmax;
@@ -3075,7 +3075,7 @@ auto vmap(T, Callable)(T withAsSlice, Callable callable)
 
 ///
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota;
 
@@ -3094,7 +3094,7 @@ version(mir_test) unittest
 
 /// Packed tensors.
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.math.sum: sum;
     import mir.ndslice.topology : iota, windows;
@@ -3128,7 +3128,7 @@ version(mir_test) unittest
 
 /// Zipped tensors
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota, zip;
 
@@ -3165,7 +3165,7 @@ In that case, the element type of `vmap` is a refTuple containing
 one element for each function.
 +/
 @safe pure nothrow
-version(none) version(mir_test) unittest
+version(none) version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota;
 
@@ -3184,7 +3184,7 @@ version(none) version(mir_test) unittest
 }
 
 /// Use vmap with byDim/alongDim to apply functions to each dimension
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure
 unittest
 {
@@ -3219,7 +3219,7 @@ unittest
 Use vmap with a lambda and with byDim/alongDim, but may need to allocate result. 
 This example uses fuse, which allocates. Note: fuse!1 will transpose the result. 
 +/
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure
 unittest {
     import mir.ndslice.topology: iota, alongDim, map;
@@ -3410,7 +3410,7 @@ template rcmap(fun...)
 
 /// Returns RCArray for input ranges and one-dimensional slices.
 @safe pure nothrow @nogc
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.algorithm.iteration: filter, equal;
     auto factor = 10;
@@ -3421,7 +3421,7 @@ version(mir_test) unittest
 
 /// For multidimensional case returns `Slice!(RCI!T, N)`.
 @safe pure nothrow @nogc
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota;
     auto factor = 3;
@@ -3431,14 +3431,14 @@ version(mir_test) unittest
 
 /// String lambdas
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota;
     assert(iota(2, 3).rcmap!"a * 2" == iota(2, 3) * 2);
 }
 
 @safe pure nothrow @nogc
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.algorithm.iteration: filter, equal;
     auto factor = 10;
@@ -3477,7 +3477,7 @@ Slice!(CachedIterator!(Iterator, CacheIterator, FlagIterator), N, kind)
 
 ///
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: cached, iota, map;
     import mir.ndslice.allocation: bitSlice, uninitSlice;
@@ -3514,7 +3514,7 @@ version(mir_test) unittest
 
 /// Cache of immutable elements
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice: DeepElementType;
     import mir.ndslice.topology: cached, iota, map, as;
@@ -3589,7 +3589,7 @@ auto cachedGC(T)(T withAsSlice)
 
 ///
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: cachedGC, iota, map;
 
@@ -3623,7 +3623,7 @@ version(mir_test) unittest
 
 /// Cache of immutable elements
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice: DeepElementType;
     import mir.ndslice.topology: cachedGC, iota, map, as;
@@ -3709,7 +3709,7 @@ template as(T)
 }
 
 ///
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice: Slice;
     import mir.ndslice.allocation : slice;
@@ -3731,7 +3731,7 @@ template as(T)
 }
 
 /// Special behavior for pointers to a constant data.
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation : slice;
     import mir.ndslice.slice: Contiguous, Slice;
@@ -3741,7 +3741,7 @@ template as(T)
 }
 
 /// Ranges
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.algorithm.iteration: filter, equal;
     assert(5.iota.filter!"a % 2".as!double.map!"a / 2".equal([0.5, 1.5]));
@@ -3785,7 +3785,7 @@ auto indexed(Field, S)(Field source, S indices)
 }
 
 ///
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     auto source = [1, 2, 3, 4, 5];
     auto indices = [4, 3, 1, 2, 0, 4];
@@ -3835,7 +3835,7 @@ auto subSlices(S, Sliceable)(Sliceable sliceable, S slices)
 }
 
 ///
-@safe pure version(mir_test) unittest
+@safe pure version(mir_ndslice_test) unittest
 {
     import mir.functional: staticArray;
     auto subs =[
@@ -3901,7 +3901,7 @@ auto chopped(S, Sliceable)(Sliceable sliceable, S bounds)
 }
 
 ///
-@safe pure version(mir_test) unittest
+@safe pure version(mir_ndslice_test) unittest
 {
     import mir.functional: staticArray;
     import mir.ndslice.slice: sliced;
@@ -3973,7 +3973,7 @@ template zip(bool sameStrides = false)
 }
 
 ///
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation : slice;
     import mir.ndslice.topology : flattened, iota;
@@ -3993,7 +3993,7 @@ template zip(bool sameStrides = false)
     assert(alpha == beta);
 }
 
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation : slice;
     import mir.ndslice.topology : flattened, iota;
@@ -4036,7 +4036,7 @@ auto unzip
 }
 
 ///
-pure nothrow version(mir_test) unittest
+pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation : slice;
     import mir.ndslice.topology : iota;
@@ -4156,7 +4156,7 @@ template slideAlong(size_t params, alias fun, SDimensions...)
 }
 
 ///
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     auto data = [4, 5].iota;
 
@@ -4218,7 +4218,7 @@ template slide(size_t params, alias fun)
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto data = 10.iota;
     auto sw = data.slide!(3, "a + 2 * b + c");
@@ -4232,7 +4232,7 @@ version(mir_test) unittest
 /++
 ND-use case
 +/
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     auto data = [4, 5].iota;
 
@@ -4259,7 +4259,7 @@ See_also: $(LREF slide), $(LREF slideAlong), $(LREF subSlices).
 alias pairwise(alias fun, size_t lag = 1) = slide!(lag + 1, fun);
 
 ///
-@safe pure nothrow version(mir_test) unittest
+@safe pure nothrow version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice: sliced;
     assert([2, 4, 3, -1].sliced.pairwise!"a + b" == [6, 7, 2]);
@@ -4267,7 +4267,7 @@ alias pairwise(alias fun, size_t lag = 1) = slide!(lag + 1, fun);
 
 /// N-dimensional
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     // performs pairwise along each dimension
     // 0 1 2 3
@@ -4290,7 +4290,7 @@ See_also: $(LREF slide), $(LREF slide).
 alias diff(size_t lag = 1) = pairwise!(('a' + lag) ~ " - a", lag);
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice: sliced;
     assert([2, 4, 3, -1].sliced.diff == [2, -1, -4]);
@@ -4298,7 +4298,7 @@ version(mir_test) unittest
 
 /// N-dimensional
 @safe pure nothrow @nogc
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     // 0 1 2 3
     // 4 5 6 7     =>
@@ -4315,7 +4315,7 @@ version(mir_test) unittest
 }
 
 /// packed slices
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     // 0 1  2  3
     // 4 5  6  7
@@ -4363,7 +4363,7 @@ Slice!(Iterator, N, N > 1 && kind == Contiguous ? Canonical : kind, Labels)
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     assert([4, 5].iota.dropBorders == [[6, 7, 8], [11, 12, 13]]);
 }
@@ -4444,7 +4444,7 @@ template withNeighboursSum(alias fun = "a + b")
 }
 
 ///
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.algorithm.iteration: all;
@@ -4454,7 +4454,7 @@ template withNeighboursSum(alias fun = "a + b")
     assert(wn.map!"a" == wn.map!"b * 0.25");
 }
 
-@safe pure nothrow @nogc version(mir_test) unittest
+@safe pure nothrow @nogc version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.algorithm.iteration: all;
@@ -4480,7 +4480,7 @@ auto cartesian(NdFields...)(NdFields fields)
 }
 
 /// 1D x 1D
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto a = [10, 20, 30];
     auto b = [ 1,  2,  3];
@@ -4495,7 +4495,7 @@ version(mir_test) unittest
 }
 
 /// 1D x 2D
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto a = [10, 20, 30];
     auto b = iota([2, 3], 1);
@@ -4521,7 +4521,7 @@ version(mir_test) unittest
 }
 
 /// 1D x 1D x 1D
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto u = [100, 200];
     auto v = [10, 20, 30];
@@ -4572,7 +4572,7 @@ template kronecker(alias fun = product)
 }
 
 /// 2D
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.slice: sliced;
@@ -4598,7 +4598,7 @@ version(mir_test) unittest
 }
 
 /// 1D
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     auto a = iota([3], 1);
 
@@ -4610,7 +4610,7 @@ version(mir_test) unittest
 }
 
 /// 2D with 3 arguments
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.allocation: slice;
     import mir.ndslice.slice: sliced;
@@ -4657,7 +4657,7 @@ auto magic(size_t length)
 
 ///
 @safe pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.math.sum;
     import mir.ndslice: slice, magic, byDim, map, as, repeat, diagonal, antidiagonal;
@@ -4731,7 +4731,7 @@ auto stairs(string type, S)(S slice, size_t n)
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: iota, stairs;
 
@@ -4801,7 +4801,7 @@ auto stairs(string type, Iterator, SliceKind kind)(Slice!(Iterator, 2, kind) sli
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology: iota, as, stairs;
 
@@ -4888,7 +4888,7 @@ template alongDim(SDimensions...)
 
 /// 2-dimensional slice support
 @safe @nogc pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice;
 
@@ -4937,7 +4937,7 @@ version(mir_test) unittest
 
 /// 3-dimensional slice support, N-dimensional also supported
 @safe @nogc pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice;
 
@@ -5086,7 +5086,7 @@ version(mir_test) unittest
 }
 
 /// Use alongDim to calculate column mean/row mean of 2-dimensional slice
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure
 unittest
 {
@@ -5115,7 +5115,7 @@ unittest
 Use alongDim and map with a lambda, but may need to allocate result. This example
 uses fuse, which allocates. Note: fuse!1 will transpose the result. 
 +/
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure
 unittest {
     import mir.ndslice.topology: iota, alongDim, map;
@@ -5231,7 +5231,7 @@ template byDim(SDimensions...)
 
 /// 2-dimensional slice support
 @safe @nogc pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice;
 
@@ -5280,7 +5280,7 @@ version(mir_test) unittest
 
 /// 3-dimensional slice support, N-dimensional also supported
 @safe @nogc pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice;
 
@@ -5429,7 +5429,7 @@ version(mir_test) unittest
 }
 
 /// Use byDim to calculate column mean/row mean of 2-dimensional slice
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure
 unittest
 {
@@ -5458,7 +5458,7 @@ unittest
 Use byDim and map with a lambda, but may need to allocate result. This example
 uses fuse, which allocates. Note: fuse!1 will transpose the result. 
 +/
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure
 unittest {
     import mir.ndslice.topology: iota, byDim, map;
@@ -5478,7 +5478,7 @@ unittest {
 
 // Ensure works on canonical
 @safe @nogc pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota, canonical;
     //  ------------
@@ -5526,7 +5526,7 @@ version(mir_test) unittest
 
 // Ensure works on universal
 @safe @nogc pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota, universal;
     //  ------------
@@ -5574,7 +5574,7 @@ version(mir_test) unittest
 
 // 1-dimensional slice support
 @safe @nogc pure nothrow
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.topology : iota;
     //  -------
@@ -5776,7 +5776,7 @@ template unsqueeze(sizediff_t axis = 0)
 }
 
 ///
-version (mir_test) 
+version (mir_ndslice_test) 
 @safe pure nothrow @nogc
 unittest
 {
@@ -5842,7 +5842,7 @@ template member(string name)
 }
 
 ///
-version(mir_test)
+version(mir_ndslice_test)
 @safe pure unittest
 {
     // struct, union or class
@@ -5916,7 +5916,7 @@ template orthogonalReduceField(alias fun)
 }
 
 /// bit array operations
-version(mir_test)
+version(mir_ndslice_test)
 unittest
 {
     import mir.ndslice.slice: slicedField;
@@ -5990,7 +5990,7 @@ auto triplets(string type, S)(S slice, size_t n)
 }
 
 ///
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice: sliced;
     import mir.ndslice.topology: triplets, member, iota;
diff --git a/source/mir/ndslice/traits.d b/source/mir/ndslice/traits.d
index 85e18018..61d20b50 100644
--- a/source/mir/ndslice/traits.d
+++ b/source/mir/ndslice/traits.d
@@ -65,7 +65,7 @@ enum bool isUniversalMatrix(T) = is(T : Slice!(Iterator,  2, Universal), Iterato
 
 ///
 @safe pure nothrow @nogc 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     import mir.ndslice.slice : Slice;
 
@@ -86,7 +86,7 @@ version(mir_test) unittest
 }
 
 @safe pure nothrow @nogc 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     alias S2 = Slice!(float*, 1, Universal);
     static assert(!isContiguousVector!S2);
@@ -105,7 +105,7 @@ version(mir_test) unittest
 }
 
 @safe pure nothrow @nogc 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     alias S3 = Slice!(byte*, 2);
     static assert(!isContiguousVector!S3);
@@ -124,7 +124,7 @@ version(mir_test) unittest
 }
 
 @safe pure nothrow @nogc 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     alias S4 = Slice!(int*, 2, Canonical);
     static assert(!isContiguousVector!S4);
@@ -143,7 +143,7 @@ version(mir_test) unittest
 }
 
 @safe pure nothrow @nogc 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     alias S5 = Slice!(int*, 2, Universal);
     static assert(!isContiguousVector!S5);
@@ -162,7 +162,7 @@ version(mir_test) unittest
 }
 
 @safe pure nothrow @nogc 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     alias S6 = Slice!(int*, 3);
     
@@ -182,7 +182,7 @@ version(mir_test) unittest
 }
 
 @safe pure nothrow @nogc 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     alias S7 = Slice!(int*, 3, Canonical);
 
@@ -202,7 +202,7 @@ version(mir_test) unittest
 }
 
 @safe pure nothrow @nogc 
-version(mir_test) unittest
+version(mir_ndslice_test) unittest
 {
     alias S8 = Slice!(int*, 3, Universal);