diff --git a/core/include/aare/Frame.hpp b/core/include/aare/Frame.hpp
index 27e1709..af7b111 100644
--- a/core/include/aare/Frame.hpp
+++ b/core/include/aare/Frame.hpp
@@ -1,5 +1,5 @@
 #pragma once
-#include "aare/View.hpp"
+#include "aare/NDView.hpp"
 #include "aare/defs.hpp"
 #include <cstddef>
 #include <cstdint>
@@ -40,10 +40,10 @@ class Frame {
     }
 
     template <typename T> 
-    View<T> view() {
+    NDView<T> view() {
         std::vector<ssize_t> shape = {m_rows, m_cols};
         T* data = reinterpret_cast<T *>(m_data);
-        return View<T>(data, shape);
+        return NDView<T>(data, shape);
     }
 
     ~Frame() { delete[] m_data; }
diff --git a/core/include/aare/View.hpp b/core/include/aare/NDView.hpp
similarity index 74%
rename from core/include/aare/View.hpp
rename to core/include/aare/NDView.hpp
index 7f32302..a08396d 100644
--- a/core/include/aare/View.hpp
+++ b/core/include/aare/NDView.hpp
@@ -30,18 +30,18 @@ template <ssize_t Ndim> std::array<ssize_t, Ndim> make_array(const std::vector<s
     return arr;
 }
 
-template <typename T, ssize_t Ndim=2> class View {
+template <typename T, ssize_t Ndim=2> class NDView {
   public:
-    View(){};
+    NDView(){};
 
-    View(T* buffer, std::array<ssize_t, Ndim> shape) {
+    NDView(T* buffer, std::array<ssize_t, Ndim> shape) {
         buffer_ = buffer;
         strides_ = c_strides<Ndim>(shape);
         shape_ = shape;
         size_ = std::accumulate(std::begin(shape), std::end(shape), 1, std::multiplies<ssize_t>());
     }
 
-    View(T *buffer, const std::vector<ssize_t> &shape) {
+    NDView(T *buffer, const std::vector<ssize_t> &shape) {
         buffer_ = buffer;
         strides_ = c_strides<Ndim>(make_array<Ndim>(shape));
         shape_ = make_array<Ndim>(shape);
@@ -59,28 +59,28 @@ template <typename T, ssize_t Ndim=2> class View {
 
     ssize_t size() const { return size_; }
 
-    View(const View &) = default;
-    View(View &&) = default;
+    NDView(const NDView &) = default;
+    NDView(NDView &&) = default;
 
     T *begin() { return buffer_; }
     T *end() { return buffer_ + size_; }
     T &operator()(ssize_t i) { return buffer_[i]; }
     T &operator[](ssize_t i) { return buffer_[i]; }
 
-    View &operator+=(const T val) { return elemenwise(val, std::plus<T>()); }
-    View &operator-=(const T val) { return elemenwise(val, std::minus<T>()); }
-    View &operator*=(const T val) { return elemenwise(val, std::multiplies<T>()); }
-    View &operator/=(const T val) { return elemenwise(val, std::divides<T>()); }
+    NDView &operator+=(const T val) { return elemenwise(val, std::plus<T>()); }
+    NDView &operator-=(const T val) { return elemenwise(val, std::minus<T>()); }
+    NDView &operator*=(const T val) { return elemenwise(val, std::multiplies<T>()); }
+    NDView &operator/=(const T val) { return elemenwise(val, std::divides<T>()); }
 
-    View &operator/=(const View &other) { return elemenwise(other, std::divides<T>()); }
+    NDView &operator/=(const NDView &other) { return elemenwise(other, std::divides<T>()); }
 
-    View &operator=(const T val) {
+    NDView &operator=(const T val) {
         for (auto it = begin(); it != end(); ++it)
             *it = val;
         return *this;
     }
 
-    View &operator=(const View &other) {
+    NDView &operator=(const NDView &other) {
         shape_ = other.shape_;
         strides_ = other.strides_;
         size_ = other.size_;
@@ -98,13 +98,13 @@ template <typename T, ssize_t Ndim=2> class View {
     std::array<ssize_t, Ndim> shape_{};
     ssize_t size_{};
 
-    template <class BinaryOperation> View &elemenwise(T val, BinaryOperation op) {
+    template <class BinaryOperation> NDView &elemenwise(T val, BinaryOperation op) {
         for (ssize_t i = 0; i != size_; ++i) {
             buffer_[i] = op(buffer_[i], val);
         }
         return *this;
     }
-    template <class BinaryOperation> View &elemenwise(const View &other, BinaryOperation op) {
+    template <class BinaryOperation> NDView &elemenwise(const NDView &other, BinaryOperation op) {
         for (ssize_t i = 0; i != size_; ++i) {
             buffer_[i] = op(buffer_[i], other.buffer_[i]);
         }
@@ -112,5 +112,5 @@ template <typename T, ssize_t Ndim=2> class View {
     }
 };
 
-template class View<uint16_t, 2>;
+template class NDView<uint16_t, 2>;
 
diff --git a/core/include/aare/VariableSizeClusterFinder.hpp b/core/include/aare/VariableSizeClusterFinder.hpp
index af3fd7a..fcd2fc5 100644
--- a/core/include/aare/VariableSizeClusterFinder.hpp
+++ b/core/include/aare/VariableSizeClusterFinder.hpp
@@ -30,12 +30,12 @@ template <typename T> class ClusterFinder {
 
   private:
     const std::array<ssize_t, 2> shape_;
-    View<T, 2> original_;
+    NDView<T, 2> original_;
     ImageData<int, 2> labeled_;
     ImageData<int, 2> peripheral_labeled_;
     ImageData<bool, 2> binary_; // over threshold flag
     T threshold_;
-    View<T, 2> noiseMap;
+    NDView<T, 2> noiseMap;
     bool use_noise_map = false;
     int peripheralThresholdFactor_ = 5;
     int current_label;
@@ -58,12 +58,12 @@ template <typename T> class ClusterFinder {
 
     ImageData<int, 2> labeled() { return labeled_; }
 
-    void set_noiseMap(View<T, 2> noise_map) { noiseMap = noise_map; use_noise_map = true; }
+    void set_noiseMap(NDView<T, 2> noise_map) { noiseMap = noise_map; use_noise_map = true; }
     void set_peripheralThresholdFactor(int factor) { peripheralThresholdFactor_ = factor; }
-    void find_clusters(View<T, 2> img);
-    void find_clusters_X(View<T, 2> img);
+    void find_clusters(NDView<T, 2> img);
+    void find_clusters_X(NDView<T, 2> img);
     void rec_FillHit(int clusterIndex, int i, int j);
-    void single_pass(View<T, 2> img);
+    void single_pass(NDView<T, 2> img);
     void first_pass();
     void second_pass();
     void store_clusters();
@@ -144,7 +144,7 @@ template <typename T> int ClusterFinder<T>::check_neighbours(int i, int j) {
     }
 }
 
-template <typename T> void ClusterFinder<T>::find_clusters(View<T, 2> img) {
+template <typename T> void ClusterFinder<T>::find_clusters(NDView<T, 2> img) {
     original_ = img;
     labeled_ = 0;
     peripheral_labeled_ = 0;
@@ -156,7 +156,7 @@ template <typename T> void ClusterFinder<T>::find_clusters(View<T, 2> img) {
     store_clusters();
 }
 
-template <typename T> void ClusterFinder<T>::find_clusters_X(View<T, 2> img) {
+template <typename T> void ClusterFinder<T>::find_clusters_X(NDView<T, 2> img) {
     original_ = img;
     int clusterIndex = 0;
     for (int i = 0; i < shape_[0]; ++i) {
@@ -214,7 +214,7 @@ template <typename T> void ClusterFinder<T>::rec_FillHit(int clusterIndex, int i
     }
 }
 
-template <typename T> void ClusterFinder<T>::single_pass(View<T, 2> img) {
+template <typename T> void ClusterFinder<T>::single_pass(NDView<T, 2> img) {
     original_ = img;
     labeled_ = 0;
     current_label = 0;
diff --git a/core/test/wrappers.test.cpp b/core/test/wrappers.test.cpp
index e2983c3..32f3046 100644
--- a/core/test/wrappers.test.cpp
+++ b/core/test/wrappers.test.cpp
@@ -1,4 +1,4 @@
-#include <aare/View.hpp>
+#include <aare/NDView.hpp>
 #include <aare/Frame.hpp>
 #include <catch2/catch_test_macros.hpp>
 #include <cstdint>
@@ -22,20 +22,20 @@ TEST_CASE("Frame") {
     delete[] data;
 }
 
-TEST_CASE("View") {
+TEST_CASE("NDView") {
     auto data = new uint16_t[100];
     for (int i = 0; i < 100; i++) {
         data[i] = i;
     }
     SECTION("constructors") {
-        View<uint16_t, 2> ds(data, std::vector<ssize_t>({10, 10}));
+        NDView<uint16_t, 2> ds(data, std::vector<ssize_t>({10, 10}));
         for (int i = 0; i < 100; i++) {
             REQUIRE(ds(i / 10, i % 10) == data[i]);
         }
     }
     SECTION("from Frame") {
         Frame f(reinterpret_cast<std::byte *>(data), 10, 10, 16);
-        View<uint16_t> ds = f.view<uint16_t>();
+        NDView<uint16_t> ds = f.view<uint16_t>();
         for (int i = 0; i < 100; i++) {
             REQUIRE(ds(i / 10, i % 10) == data[i]);
         }