diff --git a/examples/usage/allgather_example.cpp b/examples/usage/allgather_example.cpp
index eadb7a63..2c561292 100644
--- a/examples/usage/allgather_example.cpp
+++ b/examples/usage/allgather_example.cpp
@@ -20,7 +20,6 @@
 #include "helpers_for_examples.hpp"
 #include "kamping/checking_casts.hpp"
 #include "kamping/collectives/allgather.hpp"
-#include "kamping/collectives/alltoall.hpp"
 #include "kamping/communicator.hpp"
 #include "kamping/data_buffer.hpp"
 #include "kamping/environment.hpp"
@@ -30,21 +29,67 @@ int main() {
     using namespace kamping;
     kamping::Environment  e;
     kamping::Communicator comm;
-    std::vector<int>      input(comm.size(), comm.rank_signed());
+    // std::vector<int>      input(comm.size(), comm.rank_signed());
 
-    { // Basic form: Provide a send buffer and let KaMPIng allocate the receive buffer.
-        auto output = comm.allgather(send_buf(input));
-        print_result_on_root(output, comm);
-    }
+    //{ // Basic form: Provide a send buffer and let KaMPIng allocate the receive buffer.
+    //    auto output = comm.allgather(send_buf(input));
+    //    print_result_on_root(output, comm);
+    //}
+
+    // print_on_root("------", comm);
 
-    print_on_root("------", comm);
+    //{ // We can also send only parts of the input and specify an explicit receive buffer.
+    //    std::vector<int> output;
 
-    { // We can also send only parts of the input and specify an explicit receive buffer.
-        std::vector<int> output;
+    //    // this can also be achieved with `kamping::Span`
+    //    comm.allgather(send_buf(Span(input.begin(), 2)), recv_buf<resize_to_fit>(output));
+    //    print_result_on_root(output, comm);
+    //    return 0;
+    //}
 
-        // this can also be achieved with `kamping::Span`
-        comm.allgather(send_buf(Span(input.begin(), 2)), recv_buf<resize_to_fit>(output));
-        print_result_on_root(output, comm);
-        return 0;
+    MPI_Comm         mpi_graph_comm;
+    int              in_degree = -1, out_degree = -1;
+    std::vector<int> input{comm.rank_signed()};
+    std::vector<int> recv_buf(10, -1);
+    int              send_count = -1, recv_count = -1;
+    std::vector<int> in_ranks, out_ranks;
+    if (comm.rank() == 0) {
+        in_degree  = 0;
+        out_degree = 0;
+        send_count = 1;
+        recv_count = 1;
+    } else if (comm.rank() == 1) {
+        in_degree  = 0;
+        out_degree = 1;
+        out_ranks.push_back(2);
+        send_count = 1;
+        recv_count = 1;
+    } else if (comm.rank() == 2) {
+        in_degree  = 1;
+        out_degree = 1;
+        in_ranks.push_back(1);
+        out_ranks.push_back(3);
+        send_count = 1;
+        recv_count = 1;
+    } else if (comm.rank() == 3) {
+        in_degree  = 1;
+        out_degree = 0;
+        in_ranks.push_back(2);
+        send_count = 1;
+        recv_count = 1;
     }
+    MPI_Dist_graph_create_adjacent(
+        comm.mpi_communicator(),
+        in_degree,
+        in_ranks.data(),
+        MPI_UNWEIGHTED,
+        out_degree,
+        out_ranks.data(),
+        MPI_UNWEIGHTED,
+        MPI_INFO_NULL,
+        false,
+        &mpi_graph_comm
+    );
+
+    MPI_Neighbor_alltoall(input.data(), send_count, MPI_INT, recv_buf.data(), recv_count, MPI_INT, mpi_graph_comm);
 }
diff --git a/include/kamping/collectives/neighborhood/alltoall.hpp b/include/kamping/collectives/neighborhood/alltoall.hpp
index 15fb2202..b163c5db 100644
--- a/include/kamping/collectives/neighborhood/alltoall.hpp
+++ b/include/kamping/collectives/neighborhood/alltoall.hpp
@@ -43,14 +43,16 @@
 
 /// @brief Wrapper for \c MPI_Neighbor_alltoall.
 ///
-/// This wrapper for \c MPI_Neighbor_alltoall sends the same amount of data from a rank i to each of its neighbour j for
-/// which an edge (i,j) in the communication graph exists. The following buffers are required:
+/// @todo check again once the concrete semantics (potential differing number of send/recv counts) of
+/// MPI_Neighbor_alltoall has been clarified. This wrapper for \c MPI_Neighbor_alltoall sends the same amount of data
+/// from a rank i to each of its neighbour j for which an edge (i,j) in the communication graph exists. The following
+/// buffers are required:
 /// - \ref kamping::send_buf() containing the data that is sent to each neighbor. This buffer has to be divisible by the
-/// size of the communicator unless a send_count or a send_type is explicitly given as parameter.
+/// out degree unless a send_count or a send_type is explicitly given as parameter.
 ///
 /// The following parameters are optional:
 /// - \ref kamping::send_count() specifying how many elements are sent. If
-/// omitted, the size of send buffer divided by number of neighbors is used.
+/// omitted, the size of send buffer divided by number of outgoing neighbors is used.
 /// This has to be the same on all ranks.
 /// This parameter is mandatory if \ref kamping::send_type() is given.
 ///
@@ -59,7 +61,7 @@
 /// This parameter is mandatory if \ref kamping::recv_type() is given.
 ///
 /// - \ref kamping::recv_buf() specifying a buffer for the output. A buffer of at least
-/// `recv_count * communicator size` is required.
+/// `recv_count * in degree` is required.
 ///
 /// - \ref kamping::send_type() specifying the \c MPI datatype to use as send type. If omitted, the \c MPI datatype is
 /// derived automatically based on send_buf's underlying \c value_type.
@@ -67,9 +69,6 @@
 /// - \ref kamping::recv_type() specifying the \c MPI datatype to use as recv type. If omitted, the \c MPI datatype is
 /// derived automatically based on recv_buf's underlying \c value_type.
 ///
-/// Inplace alltoall is supported by passing send_recv_buf as parameter. This changes the requirements for the other
-/// parameters, see \ref Communicator::alltoall_inplace.
-///
 /// @tparam Args Automatically deduced template parameters.
 /// @param args All required and any number of the optional buffers described above.
 /// @return Result type wrapping the output parameters to be returned by value.
diff --git a/include/kamping/distributed_graph_communicator.hpp b/include/kamping/distributed_graph_communicator.hpp
index a28ea16c..e0b26c95 100644
--- a/include/kamping/distributed_graph_communicator.hpp
+++ b/include/kamping/distributed_graph_communicator.hpp
@@ -19,24 +19,25 @@
 
 namespace kamping {
 
-/// @brief View on a a distributed communication graph. Each vertex is a rank and the edge define possible communication
-/// links between the vertices. This view of a distributed communication graph contains views on the (potentially
-/// weighted) in- and outgoing edges which are basically a sequence of neighboring ranks. Note that MPI allow this to be
-/// a multi-graph.
-class CommunicationGraphView {
+/// @brief Local view on a a distributed communication graph. Each vertex is a rank and the edges define possible
+/// communication links between the vertices. This view of a distributed communication graph contains views on the
+/// (potentially weighted) in- and outgoing edges which are basically a sequence of neighboring ranks. Note that MPI
+/// allows this to be a multi-graph. This view is local as it only provides a view on the neighboring ranks of this
+/// process' rank.
+class CommunicationGraphLocalView {
 public:
     using SpanType = kamping::Span<int const>; ///< type to be used for views on ranks and weights
 
-    /// @brief Construct a view of an unweighted communication graph.
+    /// @brief Constructs a view of an unweighted communication graph.
     ///
     /// @tparam ContiguousRange Type of the input range for in and out ranks.
     /// @param in_ranks Neighboring in ranks, i.e., ranks i for which there is an edge (i,own_rank).
     /// @param out_ranks Neighboring out ranks, i.e., ranks i for which there is an edge (own_rank, i).
     template <typename ContiguousRange>
-    CommunicationGraphView(ContiguousRange const& in_ranks, ContiguousRange const& out_ranks)
+    CommunicationGraphLocalView(ContiguousRange const& in_ranks, ContiguousRange const& out_ranks)
         : _in_ranks{in_ranks.data(), in_ranks.size()},
           _out_ranks{out_ranks.data(), out_ranks.size()} {}
-    /// @brief Construct a view of an unweighted communication graph.
+    /// @brief Constructs a view of an unweighted communication graph.
     ///
     /// @tparam ContiguousRange Type of the input range for in and out ranks.
     /// @param in_ranks Neighboring in ranks, i.e., ranks i for which there is an edge (i,own_rank).
@@ -44,7 +45,7 @@ class CommunicationGraphView {
     /// @param in_weights Weights associcated to neighboring in ranks.
     /// @param out_weights Weights associcated to neighboring out ranks.
     template <typename ContiguousRange>
-    CommunicationGraphView(
+    CommunicationGraphLocalView(
         ContiguousRange const& in_ranks,
         ContiguousRange const& out_ranks,
         ContiguousRange const& in_weights,
@@ -126,7 +127,7 @@ class CommunicationGraphView {
             out_ranks().data(),
             out_weights,
             MPI_INFO_NULL,
-            false,
+            false, // do not reorder ranks
             &mpi_graph_comm
         );
         return mpi_graph_comm;
@@ -140,73 +141,80 @@ class CommunicationGraphView {
 };
 
 namespace internal {
-/// @brief Returns whether a given range of edges is weighted or not at compile time
-/// @tparam EdgeRange Range type to be checked.
-template <typename EdgeRange>
-constexpr bool are_edges_weighted() {
-    using EdgeType = typename EdgeRange::value_type;
-    return !std::is_integral_v<EdgeType>;
+/// @brief Returns whether a given range of neighbors is weighted or not at compile time
+/// @tparam NeighborhoodRange Range type to be checked.
+template <typename NeighborhoodRange>
+constexpr bool are_neighborhoods_weighted() {
+    using NeighborType = typename NeighborhoodRange::value_type;
+    static_assert(
+        kamping::internal::tuple_size<NeighborType> == 1 || kamping::internal::tuple_size<NeighborType> == 2,
+        "Neighbor type has to be a scalar (in the unweighted case) or pair-like (in the weighted case) type"
+    );
+    return kamping::internal::tuple_size<NeighborType> == 2;
 }
 } // namespace internal
 
-/// @brief A Distributed communication graph. Each vertex of the graph corresponds to a rank and each edge (i,j) connect
-/// two ranks i and j which can communicate with each other. Note that MPI allow multiple edges between the same ranks i
-/// and j, i.e. the distributed communication graph can be a multi-graph. Each rank holds its local view on the
-/// communication graph, i.e., it knows its neighboring vertices/ranks.
+/// @brief A (vertex-centric) distributed communication graph. Each vertex of the graph corresponds to a rank and each
+/// edge (i,j) connect two ranks i and j which can communicate with each other. The distributed communication graph is
+/// vertex-centric in the sense that on each rank the local graph only contains the corresponding vertex and its in and
+/// out neighborhood. Note that MPI allow multiple edges between the same ranks i and j, i.e. the distributed
+/// communication graph can be a multi-graph.
 template <template <typename...> typename DefaultContainer = std::vector>
-class CommunicationGraph {
+class DistributedCommunicationGraph {
 public:
     /// @brief Default constructor.
-    CommunicationGraph() = default;
+    DistributedCommunicationGraph() = default;
 
     /// @brief Constructs a communication graph based on a range of in-going and out-going edges which might be
     /// weighted. A unweighted edge is simply an integer, wherea a weighted edge is a pair-like object consisting of two
     /// integers which can be decomposed by a structured binding via `auto [rank, weight] = weighted_edge;`.
     ///
-    /// @tparam InEdgeRange Range type of in-going edges.
-    /// @tparam InEdgeRange Range type of out-going edges.
-    /// @param in_edges Range of in-going edges.
-    /// @param out_edges Range of out-going edges.
+    /// @tparam InNeighborsRange Range type of in-going neighbors.
+    /// @tparam OutNeighborsRange Range type of out-going neighbors.
+    /// @param in_neighbors Range of in-going neighbors.
+    /// @param out_neighbors Range of out-going neighbors.
     ///
-    template <typename InEdgeRange, typename OutEdgeRange>
-    CommunicationGraph(InEdgeRange const& in_edges, OutEdgeRange const& out_edges) {
-        constexpr bool are_in_edges_weighted  = internal::are_edges_weighted<InEdgeRange>();
-        constexpr bool are_out_edges_weighted = internal::are_edges_weighted<OutEdgeRange>();
+    template <typename InNeighborsRange, typename OutNeighborsRange>
+    DistributedCommunicationGraph(InNeighborsRange const& in_neighbors, OutNeighborsRange const& out_neighbors) {
+        constexpr bool are_in_neighbors_weighted  = internal::are_neighborhoods_weighted<InNeighborsRange>();
+        constexpr bool are_out_neighbors_weighted = internal::are_neighborhoods_weighted<OutNeighborsRange>();
         static_assert(
-            are_in_edges_weighted == are_out_edges_weighted,
-            "Weight status of in and out edges is different!"
+            are_in_neighbors_weighted == are_out_neighbors_weighted,
+            "If weighted neighborhoods are passed, they must be provided for both in and out neighbors!"
         );
-        if constexpr (are_in_edges_weighted) {
-            auto get_rank = [](auto const& edge) {
+        auto get_rank = [&](auto const& edge) {
+            if constexpr (are_in_neighbors_weighted) {
                 auto const& [rank, _] = edge;
                 return static_cast<int>(rank);
-            };
+            } else {
+                return static_cast<int>(edge);
+            }
+        };
+
+        transform_elems_to_integers(in_neighbors, _in_ranks, get_rank);
+        transform_elems_to_integers(out_neighbors, _out_ranks, get_rank);
+
+        if constexpr (are_in_neighbors_weighted) {
             auto get_weight = [](auto const& edge) {
                 auto const& [_, weight] = edge;
                 return static_cast<int>(weight);
             };
-            transform_elems_to_integers(in_edges, _in_ranks, get_rank);
-            transform_elems_to_integers(out_edges, _out_ranks, get_rank);
             _in_weights  = DefaultContainer<int>{};
             _out_weights = DefaultContainer<int>{};
-            transform_elems_to_integers(in_edges, _in_weights.value(), get_weight);
-            transform_elems_to_integers(out_edges, _out_weights.value(), get_weight);
-        } else {
-            auto get_rank = [](auto const& edge) {
-                return static_cast<int>(edge);
-            };
-            transform_elems_to_integers(in_edges, _in_ranks, get_rank);
-            transform_elems_to_integers(out_edges, _out_ranks, get_rank);
+            transform_elems_to_integers(in_neighbors, _in_weights.value(), get_weight);
+            transform_elems_to_integers(out_neighbors, _out_weights.value(), get_weight);
         }
     }
 
-    /// @brief Constructs a communication graph based on a range of unweighted in-going and out-going edges.
-    CommunicationGraph(DefaultContainer<int>&& in_ranks, DefaultContainer<int>&& out_ranks)
+    /// @brief Constructs a communication graph based on a range of unweighted in-going and out-going neighbors, i.e.,
+    /// ranks.
+    DistributedCommunicationGraph(DefaultContainer<int>&& in_ranks, DefaultContainer<int>&& out_ranks)
         : _in_ranks{std::move(in_ranks)},
           _out_ranks{std::move(out_ranks)} {}
 
-    /// @brief Constructs a communication graph based on a range of weighted in-going and out-going edges.
-    CommunicationGraph(
+    /// @brief Constructs a communication graph based on a range of weighted in-going and out-going neighbors.
+    /// The ownership of the underlying ranks/weights containers is transfered.
+    DistributedCommunicationGraph(
         DefaultContainer<int>&& in_ranks,
         DefaultContainer<int>&& out_ranks,
         DefaultContainer<int>&& in_weights,
@@ -217,27 +225,34 @@ class CommunicationGraph {
           _in_weights{std::move(in_weights)},
           _out_weights{std::move(out_weights)} {}
 
-    /// @brief Constructs a communication graph based on a range of potentially weighted symmetric edges.
-    template <typename EdgeRange>
-    CommunicationGraph(EdgeRange const& edges) : CommunicationGraph(edges, edges) {}
+    /// @brief Constructs a communication graph based where in and out neighbors are the same, i.e. a symmetric
+    /// neighborhood/graph.
+    template <typename NeighborRange>
+    DistributedCommunicationGraph(NeighborRange const& neighbors)
+        : DistributedCommunicationGraph(neighbors, neighbors) {}
 
     /// @brief Returns a view of the communication graph.
-    CommunicationGraphView get_view() const {
+    CommunicationGraphLocalView get_view() const {
         if (_in_weights.has_value()) {
-            return CommunicationGraphView(_in_ranks, _out_ranks, _in_weights.value(), _out_weights.value());
+            return CommunicationGraphLocalView(_in_ranks, _out_ranks, _in_weights.value(), _out_weights.value());
         } else {
-            return CommunicationGraphView(_in_ranks, _out_ranks);
+            return CommunicationGraphLocalView(_in_ranks, _out_ranks);
         }
     }
 
-    /// @brief For each rank n for which there is (at least one) outgoing edge (own_rank, r), returns a mapping
-    /// r -> index of an edge (own_rank, r). This may be useful for collective communication primitives like
-    /// `MPI_Neighbor_alltoall` when one wants to calculate the position within the send_buffer to send data to a rank
-    /// r.
+    /// @brief In neighborhood collectives the order of sent and received data depends on
+    /// the ordering of the underlying out and in neighbors (note that the MPI standard allows that a neighbor occurs
+    /// multiple times within the neighbors list). For example in \c MPI_Neighbor_alltoall the \c k-th block in the send
+    /// buffer is sent to the \c k-th negibhoring process. Hence, to exchange data to rank r via neighborhood
+    /// collectives it might be useful to know the index of rank r within the out neighbors (provided r is a neighbor at
+    /// all). Therefore, this function returns a mapping from the rank of each out neighbor r to its index within the
+    /// out neighbors. If r occurs multiple times, one of these positions is returned in the mapping.
     ///
-    /// @return Returns the mapping
+    /// @tparam Map Map type storing the mapping, uses std::unordered_map<size_t, size_t> as default.
+    ///
+    /// @return Returns the mapping.
     template <typename Map = std::unordered_map<size_t, size_t>>
-    auto get_rank_to_out_edge_idx_mapping() {
+    auto get_rank_to_out_neighbor_idx_mapping() {
         Map mapping;
         for (size_t i = 0; i < _out_ranks.size(); ++i) {
             size_t rank = static_cast<size_t>(_out_ranks.data()[i]);
@@ -260,9 +275,9 @@ class CommunicationGraph {
     std::optional<DefaultContainer<int>> _out_weights; ///< Weights of out-going edges if present.
 };
 
-/// @brief Wrapper for an MPI communicator with a (distributed) graph topology providing access to \c rank() and \c
-/// size() of the communicator. The \ref Communicator is also access point to all MPI communications provided by
-/// KaMPIng.
+/// @brief A \ref Communicator which possesses an additional virtual topology and supports neighborhood collectives (on
+/// the topology). The virtual topology is specified via a distributed communication graph (see \ref
+/// DistributedCommunicationGraph).
 /// @tparam DefaultContainerType The default container type to use for containers created by KaMPIng. Defaults to
 /// std::vector.
 /// @tparam Plugins Plugins adding functionality to KaMPIng. Plugins should be classes taking a ``Communicator``
@@ -288,7 +303,7 @@ class DistributedGraphCommunicator
     /// @param comm Communicator for which a graph topology shall be added.
     /// @param comm_graph_view View on the communication graph which will be added to the given communicator.
     template <typename Communicator>
-    DistributedGraphCommunicator(Communicator const& comm, CommunicationGraphView comm_graph_view)
+    DistributedGraphCommunicator(Communicator const& comm, CommunicationGraphLocalView comm_graph_view)
         : TopologyCommunicator<DefaultContainerType>(
             comm_graph_view.in_degree(),
             comm_graph_view.out_degree(),
@@ -302,7 +317,9 @@ class DistributedGraphCommunicator
     /// @param comm Communicator for which a graph topology shall be added.
     /// @param comm_graph Communication graph which will be added to the given communicator.
     template <typename Communicator>
-    DistributedGraphCommunicator(Communicator const& comm, CommunicationGraph<DefaultContainerType> const& comm_graph)
+    DistributedGraphCommunicator(
+        Communicator const& comm, DistributedCommunicationGraph<DefaultContainerType> const& comm_graph
+    )
         : DistributedGraphCommunicator(comm, comm_graph.get_view()) {}
 
     /// @brief Returns the communicators underlying communication graph by calling `MPI_Dist_graph_neighbors`.
@@ -328,14 +345,14 @@ class DistributedGraphCommunicator
             is_weighted() ? out_weights.data() : MPI_UNWEIGHTED
         );
         if (is_weighted()) {
-            return CommunicationGraph<DefaultContainerType>(
+            return DistributedCommunicationGraph<DefaultContainerType>(
                 std::move(in_ranks),
                 std::move(out_ranks),
                 std::move(in_weights),
                 std::move(out_weights)
             );
         } else {
-            return CommunicationGraph<DefaultContainerType>(std::move(in_ranks), std::move(out_ranks));
+            return DistributedCommunicationGraph<DefaultContainerType>(std::move(in_ranks), std::move(out_ranks));
         }
     }
 
diff --git a/include/kamping/topology_communicator.hpp b/include/kamping/topology_communicator.hpp
index 1d91a90b..36de8fc4 100644
--- a/include/kamping/topology_communicator.hpp
+++ b/include/kamping/topology_communicator.hpp
@@ -17,12 +17,11 @@
 #include <kamping/communicator.hpp>
 
 namespace kamping {
-/// @brief Wrapper for an MPI communicator with topology providing access to \c rank() and \c size() of the
-/// communicator. The \ref Communicator is also access point to all MPI communications provided by KaMPIng. A topolgy
-/// communicator possess an additional `virtual` topology, i.e., a graph which defines frequent communication patterns.
-/// Each MPI rank corresponds to a vertex in the graph and an edge (i,j) defines a (directed) communication link from
-/// rank i to rank j. Such a topolgy can be used to model frequent (sparse) communication patterns and there are
-/// specialized collective operations, e.g., MPI_Neighbor_alltoall etc., exploiting this structure.
+/// @brief  A \ref Communicator which possesses an additional virtual topology and supports neighborhood collectives (on
+/// the topology). A virtual topology can be defined by a communication graph: each MPI rank corresponds to a vertex in
+/// the graph and an edge (i,j) defines a (directed) communication link from rank i to rank j. Such a topolgy can be
+/// used to model frequent (sparse) communication patterns and there are specialized (neighborhood) collective
+/// operations, e.g., MPI_Neighbor_alltoall etc., exploiting this structure.
 ///
 /// @tparam DefaultContainerType The default container type to use for containers created by KaMPIng. Defaults to
 /// std::vector.
diff --git a/tests/collectives/neighborhood/mpi_alltoall_test.cpp b/tests/collectives/neighborhood/mpi_alltoall_test.cpp
index 87548b27..e411fd2e 100644
--- a/tests/collectives/neighborhood/mpi_alltoall_test.cpp
+++ b/tests/collectives/neighborhood/mpi_alltoall_test.cpp
@@ -28,10 +28,10 @@ using namespace ::kamping;
 using namespace ::testing;
 
 TEST(NeighborhoodAlltoallTest, single_element_no_receive_buffer_for_edges_to_predecessor_successor) {
-    Communicator                 comm;
-    std::vector<size_t>          edges{comm.rank_shifted_cyclic(-1), comm.rank_shifted_cyclic(1)};
-    CommunicationGraph<>         input_comm_graph(edges);
-    DistributedGraphCommunicator graph_comm(comm, input_comm_graph);
+    Communicator                    comm;
+    std::vector<size_t>             edges{comm.rank_shifted_cyclic(-1), comm.rank_shifted_cyclic(1)};
+    DistributedCommunicationGraph<> input_comm_graph(edges);
+    DistributedGraphCommunicator    graph_comm(comm, input_comm_graph);
 
     std::vector<size_t> const input = edges;
 
@@ -49,11 +49,11 @@ TEST(NeighborhoodAlltoallTest, single_element_no_receive_buffer_for_edges_to_pre
 }
 
 TEST(NeighborhoodAlltoallTest, single_element_no_receive_buffer_for_edges_to_successor) {
-    Communicator                 comm;
-    std::vector<size_t>          in_edges{comm.rank_shifted_cyclic(-1)};
-    std::vector<size_t>          out_edges{comm.rank_shifted_cyclic(1)};
-    CommunicationGraph<>         input_comm_graph(in_edges, out_edges);
-    DistributedGraphCommunicator graph_comm(comm, input_comm_graph);
+    Communicator                    comm;
+    std::vector<size_t>             in_edges{comm.rank_shifted_cyclic(-1)};
+    std::vector<size_t>             out_edges{comm.rank_shifted_cyclic(1)};
+    DistributedCommunicationGraph<> input_comm_graph(in_edges, out_edges);
+    DistributedGraphCommunicator    graph_comm(comm, input_comm_graph);
 
     std::vector<size_t> const input{comm.rank()};
 
@@ -71,12 +71,12 @@ TEST(NeighborhoodAlltoallTest, single_element_no_receive_buffer_for_edges_to_suc
 }
 
 TEST(NeighborhoodAlltoallTest, single_element_no_receive_buffer_for_multi_edges_to_successor) {
-    Communicator                 comm;
-    size_t const                 edge_multiplicity = 3;
-    std::vector<size_t> const    in_edges(edge_multiplicity, comm.rank_shifted_cyclic(-1));
-    std::vector<size_t> const    out_edges(edge_multiplicity, comm.rank_shifted_cyclic(1));
-    CommunicationGraph<>         input_comm_graph(in_edges, out_edges);
-    DistributedGraphCommunicator graph_comm(comm, input_comm_graph);
+    Communicator                    comm;
+    size_t const                    edge_multiplicity = 3;
+    std::vector<size_t> const       in_edges(edge_multiplicity, comm.rank_shifted_cyclic(-1));
+    std::vector<size_t> const       out_edges(edge_multiplicity, comm.rank_shifted_cyclic(1));
+    DistributedCommunicationGraph<> input_comm_graph(in_edges, out_edges);
+    DistributedGraphCommunicator    graph_comm(comm, input_comm_graph);
 
     std::vector<size_t> const input(edge_multiplicity, comm.rank());
 
@@ -113,7 +113,7 @@ TEST(NeighborhoodAlltoallTest, single_element_no_receive_buffer_for_multi_edges_
 //     if (is_succ_of_root) {
 //         in_edges.clear();
 //     }
-//     CommunicationGraph<>         input_comm_graph(in_edges, out_edges);
+//     DistributedCommunicationGraph<>         input_comm_graph(in_edges, out_edges);
 //     DistributedGraphCommunicator graph_comm(comm, input_comm_graph);
 //
 //     std::vector<size_t> input{comm.rank()};
diff --git a/tests/communication_graph_test.cpp b/tests/communication_graph_test.cpp
index a950b0e8..79d69a30 100644
--- a/tests/communication_graph_test.cpp
+++ b/tests/communication_graph_test.cpp
@@ -31,8 +31,8 @@ using namespace ::kamping;
 using namespace ::testing;
 
 TEST(CommunicationGraphTest, empty) {
-    CommunicationGraph<> comm_graph{};
-    auto                 comm_graph_view = comm_graph.get_view();
+    DistributedCommunicationGraph<> comm_graph{};
+    auto                            comm_graph_view = comm_graph.get_view();
     EXPECT_EQ(comm_graph_view.in_degree(), 0);
     EXPECT_EQ(comm_graph_view.in_ranks().size(), 0);
     EXPECT_EQ(comm_graph_view.in_weights(), std::nullopt);
@@ -43,9 +43,9 @@ TEST(CommunicationGraphTest, empty) {
 }
 
 TEST(CommunicationGraphTest, unweighted_symmetric_edges) {
-    std::vector<size_t>  edges{1, 2, 3};
-    CommunicationGraph<> comm_graph{edges};
-    auto                 comm_graph_view = comm_graph.get_view();
+    std::vector<size_t>             edges{1, 2, 3};
+    DistributedCommunicationGraph<> comm_graph{edges};
+    auto                            comm_graph_view = comm_graph.get_view();
     EXPECT_EQ(comm_graph_view.in_degree(), 3);
     EXPECT_THAT(comm_graph_view.in_ranks(), ElementsAre(1, 2, 3));
     EXPECT_EQ(comm_graph_view.in_weights(), std::nullopt);
@@ -56,10 +56,10 @@ TEST(CommunicationGraphTest, unweighted_symmetric_edges) {
 }
 
 TEST(CommunicationGraphTest, unweighted_asymmetric_edges) {
-    std::vector<size_t>  in_edges{1, 2, 3, 4};
-    std::vector<size_t>  out_edges{5, 6, 7};
-    CommunicationGraph<> comm_graph{in_edges, out_edges};
-    auto                 comm_graph_view = comm_graph.get_view();
+    std::vector<size_t>             in_edges{1, 2, 3, 4};
+    std::vector<size_t>             out_edges{5, 6, 7};
+    DistributedCommunicationGraph<> comm_graph{in_edges, out_edges};
+    auto                            comm_graph_view = comm_graph.get_view();
     EXPECT_EQ(comm_graph_view.in_degree(), 4);
     EXPECT_THAT(comm_graph_view.in_ranks(), ElementsAre(1, 2, 3, 4));
     EXPECT_EQ(comm_graph_view.in_weights(), std::nullopt);
@@ -72,7 +72,7 @@ TEST(CommunicationGraphTest, unweighted_asymmetric_edges) {
 TEST(CommunicationGraphTest, weighted_asymmetric_edges) {
     std::vector<std::pair<size_t, int>> in_edges{{1, 4}, {2, 3}, {3, 2}, {4, 1}};
     std::vector<std::pair<size_t, int>> out_edges{{5, 7}, {6, 6}, {7, 5}};
-    CommunicationGraph<>                comm_graph{in_edges, out_edges};
+    DistributedCommunicationGraph<>     comm_graph{in_edges, out_edges};
     auto                                comm_graph_view = comm_graph.get_view();
     EXPECT_EQ(comm_graph_view.in_degree(), 4);
     EXPECT_THAT(comm_graph_view.in_ranks(), ElementsAre(1, 2, 3, 4));
@@ -89,10 +89,10 @@ struct OwnEdge {
 };
 
 TEST(CommunicationGraphTest, weighted_asymmetric_edges_with_custom_edge_type) {
-    std::vector<OwnEdge> in_edges{{1, 4}, {2, 3}, {3, 2}, {4, 1}};
-    std::vector<OwnEdge> out_edges{{5, 7}, {6, 6}, {7, 5}};
-    CommunicationGraph<> comm_graph{in_edges, out_edges};
-    auto                 comm_graph_view = comm_graph.get_view();
+    std::vector<OwnEdge>            in_edges{{1, 4}, {2, 3}, {3, 2}, {4, 1}};
+    std::vector<OwnEdge>            out_edges{{5, 7}, {6, 6}, {7, 5}};
+    DistributedCommunicationGraph<> comm_graph{in_edges, out_edges};
+    auto                            comm_graph_view = comm_graph.get_view();
     EXPECT_EQ(comm_graph_view.in_degree(), 4);
     EXPECT_THAT(comm_graph_view.in_ranks(), ElementsAre(1, 2, 3, 4));
     EXPECT_THAT(comm_graph_view.in_weights().value(), ElementsAre(4, 3, 2, 1));
@@ -103,10 +103,10 @@ TEST(CommunicationGraphTest, weighted_asymmetric_edges_with_custom_edge_type) {
 }
 
 TEST(CommunicationGraphTest, unweighted_asymmetric_edges_with_move_construction) {
-    std::vector<int>     in_edges{1, 2, 3, 4};
-    std::vector<int>     out_edges{5, 6, 7};
-    CommunicationGraph<> comm_graph{std::move(in_edges), std::move(out_edges)};
-    auto                 comm_graph_view = comm_graph.get_view();
+    std::vector<int>                in_edges{1, 2, 3, 4};
+    std::vector<int>                out_edges{5, 6, 7};
+    DistributedCommunicationGraph<> comm_graph{std::move(in_edges), std::move(out_edges)};
+    auto                            comm_graph_view = comm_graph.get_view();
     EXPECT_EQ(comm_graph_view.in_degree(), 4);
     EXPECT_THAT(comm_graph_view.in_ranks(), ElementsAre(1, 2, 3, 4));
     EXPECT_EQ(comm_graph_view.in_weights(), std::nullopt);
@@ -117,11 +117,11 @@ TEST(CommunicationGraphTest, unweighted_asymmetric_edges_with_move_construction)
 }
 
 TEST(CommunicationGraphTest, weighted_asymmetric_edges_with_move_construction) {
-    std::vector<int>     in_edges{1, 2, 3, 4};
-    std::vector<int>     in_weights{4, 3, 2, 1};
-    std::vector<int>     out_edges{5, 6, 7};
-    std::vector<int>     out_weights{7, 6, 5};
-    CommunicationGraph<> comm_graph{
+    std::vector<int>                in_edges{1, 2, 3, 4};
+    std::vector<int>                in_weights{4, 3, 2, 1};
+    std::vector<int>                out_edges{5, 6, 7};
+    std::vector<int>                out_weights{7, 6, 5};
+    DistributedCommunicationGraph<> comm_graph{
         std::move(in_edges),
         std::move(out_edges),
         std::move(in_weights),
@@ -137,10 +137,10 @@ TEST(CommunicationGraphTest, weighted_asymmetric_edges_with_move_construction) {
 }
 
 TEST(CommunicationGraphTest, rank_to_out_edge_mapping_for_unweighted_asymmetric_edges) {
-    std::vector<int>     in_edges{1, 2, 3, 4};
-    std::vector<int>     out_edges{5, 6, 7};
-    CommunicationGraph<> comm_graph{std::move(in_edges), std::move(out_edges)};
-    auto                 mapping = comm_graph.get_rank_to_out_edge_idx_mapping();
+    std::vector<int>                in_edges{1, 2, 3, 4};
+    std::vector<int>                out_edges{5, 6, 7};
+    DistributedCommunicationGraph<> comm_graph{std::move(in_edges), std::move(out_edges)};
+    auto                            mapping = comm_graph.get_rank_to_out_neighbor_idx_mapping();
     EXPECT_EQ(mapping.size(), 3);
     auto it1 = mapping.find(5);
     EXPECT_NE(it1, mapping.end());
diff --git a/tests/distributed_graph_communicator_test.cpp b/tests/distributed_graph_communicator_test.cpp
index 4d25ac8f..24e2cdf6 100644
--- a/tests/distributed_graph_communicator_test.cpp
+++ b/tests/distributed_graph_communicator_test.cpp
@@ -49,8 +49,8 @@ struct DistributedGraphCommunicatorTest : Test {
 TEST_F(DistributedGraphCommunicatorTest, empty_communication_graph) {
     Communicator comm;
 
-    CommunicationGraph<>         comm_graph{};
-    DistributedGraphCommunicator graph_comm(comm, comm_graph);
+    DistributedCommunicationGraph<> comm_graph{};
+    DistributedGraphCommunicator    graph_comm(comm, comm_graph);
 
     EXPECT_EQ(graph_comm.compare(kamping::comm_world()), CommunicatorComparisonResult::congruent);
     EXPECT_EQ(graph_comm.rank(), rank);
@@ -67,10 +67,10 @@ TEST_F(DistributedGraphCommunicatorTest, empty_communication_graph) {
 }
 
 TEST_F(DistributedGraphCommunicatorTest, basics_for_edge_to_predecessor_and_successor_rank) {
-    Communicator                 comm;
-    std::vector<size_t>          edges{comm.rank_shifted_cyclic(-1), comm.rank_shifted_cyclic(1)};
-    CommunicationGraph<>         input_comm_graph(edges);
-    DistributedGraphCommunicator graph_comm(comm, input_comm_graph);
+    Communicator                    comm;
+    std::vector<size_t>             edges{comm.rank_shifted_cyclic(-1), comm.rank_shifted_cyclic(1)};
+    DistributedCommunicationGraph<> input_comm_graph(edges);
+    DistributedGraphCommunicator    graph_comm(comm, input_comm_graph);
 
     EXPECT_EQ(graph_comm.compare(kamping::comm_world()), CommunicatorComparisonResult::congruent);
     EXPECT_EQ(graph_comm.rank(), rank);
@@ -87,10 +87,10 @@ TEST_F(DistributedGraphCommunicatorTest, basics_for_edge_to_predecessor_and_succ
 }
 
 TEST_F(DistributedGraphCommunicatorTest, get_communication_graph_for_edge_to_predecessor_and_successor_rank) {
-    Communicator                 comm;
-    std::vector<size_t>          edges{comm.rank_shifted_cyclic(-1), comm.rank_shifted_cyclic(1)};
-    CommunicationGraph<>         input_comm_graph(edges);
-    DistributedGraphCommunicator graph_comm(comm, input_comm_graph);
+    Communicator                    comm;
+    std::vector<size_t>             edges{comm.rank_shifted_cyclic(-1), comm.rank_shifted_cyclic(1)};
+    DistributedCommunicationGraph<> input_comm_graph(edges);
+    DistributedGraphCommunicator    graph_comm(comm, input_comm_graph);
 
     auto const comm_graph      = graph_comm.get_communication_graph();
     auto const comm_graph_view = comm_graph.get_view();
@@ -103,11 +103,11 @@ TEST_F(DistributedGraphCommunicatorTest, get_communication_graph_for_edge_to_pre
 }
 
 TEST_F(DistributedGraphCommunicatorTest, out_edge_to_successor_rank) {
-    Communicator                 comm;
-    std::vector<size_t>          out_edges{comm.rank_shifted_cyclic(1)};
-    std::vector<size_t>          in_edges{comm.rank_shifted_cyclic(-1)};
-    CommunicationGraph<>         input_comm_graph(out_edges, in_edges);
-    DistributedGraphCommunicator graph_comm(comm, input_comm_graph);
+    Communicator                    comm;
+    std::vector<size_t>             out_edges{comm.rank_shifted_cyclic(1)};
+    std::vector<size_t>             in_edges{comm.rank_shifted_cyclic(-1)};
+    DistributedCommunicationGraph<> input_comm_graph(out_edges, in_edges);
+    DistributedGraphCommunicator    graph_comm(comm, input_comm_graph);
 
     EXPECT_EQ(graph_comm.compare(kamping::comm_world()), CommunicatorComparisonResult::congruent);
     EXPECT_EQ(graph_comm.rank(), rank);
@@ -124,11 +124,11 @@ TEST_F(DistributedGraphCommunicatorTest, out_edge_to_successor_rank) {
 }
 
 TEST_F(DistributedGraphCommunicatorTest, get_communication_graph_for_edge_to_successor_rank_and_oneself) {
-    Communicator                 comm;
-    std::vector<size_t>          in_edges{comm.rank_shifted_cyclic(-1), comm.rank()};
-    std::vector<size_t>          out_edges{comm.rank_shifted_cyclic(1), comm.rank()};
-    CommunicationGraph<>         input_comm_graph(in_edges, out_edges);
-    DistributedGraphCommunicator graph_comm(comm, input_comm_graph);
+    Communicator                    comm;
+    std::vector<size_t>             in_edges{comm.rank_shifted_cyclic(-1), comm.rank()};
+    std::vector<size_t>             out_edges{comm.rank_shifted_cyclic(1), comm.rank()};
+    DistributedCommunicationGraph<> input_comm_graph(in_edges, out_edges);
+    DistributedGraphCommunicator    graph_comm(comm, input_comm_graph);
 
     auto const comm_graph      = graph_comm.get_communication_graph();
     auto const comm_graph_view = comm_graph.get_view();
@@ -144,7 +144,7 @@ TEST_F(DistributedGraphCommunicatorTest, basics_for_edge_to_successor_rank_and_o
     Communicator                        comm;
     std::vector<std::pair<size_t, int>> in_edges{{comm.rank_shifted_cyclic(-1), 42}, {comm.rank(), 0}};
     std::vector<std::pair<size_t, int>> out_edges{{comm.rank_shifted_cyclic(1), 42}, {comm.rank(), 0}};
-    CommunicationGraph<>                input_comm_graph(in_edges, out_edges);
+    DistributedCommunicationGraph<>     input_comm_graph(in_edges, out_edges);
     DistributedGraphCommunicator        graph_comm(comm, input_comm_graph);
 
     EXPECT_EQ(graph_comm.compare(kamping::comm_world()), CommunicatorComparisonResult::congruent);
@@ -166,8 +166,8 @@ TEST_F(DistributedGraphCommunicatorTest, get_communication_graph_for_edge_to_suc
     std::vector<std::pair<size_t, int>> in_edges{{comm.rank_shifted_cyclic(-1), 42}, {comm.rank(), 0}};
     std::vector<std::pair<size_t, int>> out_edges{{comm.rank_shifted_cyclic(1), 42}, {comm.rank(), 0}};
 
-    CommunicationGraph<>         input_comm_graph(in_edges, out_edges);
-    DistributedGraphCommunicator graph_comm(comm, input_comm_graph);
+    DistributedCommunicationGraph<> input_comm_graph(in_edges, out_edges);
+    DistributedGraphCommunicator    graph_comm(comm, input_comm_graph);
 
     auto const comm_graph      = graph_comm.get_communication_graph();
     auto const comm_graph_view = comm_graph.get_view();
@@ -191,8 +191,8 @@ TEST_F(DistributedGraphCommunicatorTest, root_to_all_others_from_graph_view) {
     }
     auto const expected_out_edges = out_edges;
 
-    CommunicationGraph<>         input_comm_graph(in_edges, out_edges);
-    DistributedGraphCommunicator graph_comm(comm, input_comm_graph);
+    DistributedCommunicationGraph<> input_comm_graph(in_edges, out_edges);
+    DistributedGraphCommunicator    graph_comm(comm, input_comm_graph);
 
     auto const comm_graph      = graph_comm.get_communication_graph();
     auto const comm_graph_view = comm_graph.get_view();
diff --git a/tests/helpers_for_testing.hpp b/tests/helpers_for_testing.hpp
index b859c1ed..4b60c12d 100644
--- a/tests/helpers_for_testing.hpp
+++ b/tests/helpers_for_testing.hpp
@@ -452,7 +452,8 @@ std::vector<MPI_Datatype> possible_mpi_datatypes() noexcept {
 }
 
 /// @brief Compares two CommunicationGraphViews objects for equality
-inline bool are_equal(kamping::CommunicationGraphView const& lhs, kamping::CommunicationGraphView const& rhs) {
+inline bool
+are_equal(kamping::CommunicationGraphLocalView const& lhs, kamping::CommunicationGraphLocalView const& rhs) {
     auto compare_span = [](auto const& lhs_, auto const& rhs_) {
         if (lhs_.size() != rhs_.size()) {
             return false;