diff --git a/commons/zenoh-shm/src/api/slice/mod.rs b/commons/zenoh-shm/src/api/buffer/mod.rs
similarity index 92%
rename from commons/zenoh-shm/src/api/slice/mod.rs
rename to commons/zenoh-shm/src/api/buffer/mod.rs
index 59c793f94a..8a3e040da9 100644
--- a/commons/zenoh-shm/src/api/slice/mod.rs
+++ b/commons/zenoh-shm/src/api/buffer/mod.rs
@@ -13,5 +13,5 @@
 //
 
 pub mod traits;
-pub mod zsliceshm;
-pub mod zsliceshmmut;
+pub mod zshm;
+pub mod zshmmut;
diff --git a/commons/zenoh-shm/src/api/slice/traits.rs b/commons/zenoh-shm/src/api/buffer/traits.rs
similarity index 100%
rename from commons/zenoh-shm/src/api/slice/traits.rs
rename to commons/zenoh-shm/src/api/buffer/traits.rs
diff --git a/commons/zenoh-shm/src/api/slice/zsliceshm.rs b/commons/zenoh-shm/src/api/buffer/zshm.rs
similarity index 59%
rename from commons/zenoh-shm/src/api/slice/zsliceshm.rs
rename to commons/zenoh-shm/src/api/buffer/zshm.rs
index 86f4395ebb..e7cf2a3197 100644
--- a/commons/zenoh-shm/src/api/slice/zsliceshm.rs
+++ b/commons/zenoh-shm/src/api/buffer/zshm.rs
@@ -22,43 +22,43 @@ use zenoh_buffers::{ZBuf, ZSlice};
 
 use crate::SharedMemoryBuf;
 
-use super::{traits::SHMBuf, zsliceshmmut::zsliceshmmut};
+use super::{traits::SHMBuf, zshmmut::zshmmut};
 
-/// An immutable SHM slice
+/// An immutable SHM buffer
 #[zenoh_macros::unstable_doc]
 #[repr(transparent)]
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct ZSliceShm(pub(crate) SharedMemoryBuf);
+pub struct ZShm(pub(crate) SharedMemoryBuf);
 
-impl SHMBuf for ZSliceShm {
+impl SHMBuf for ZShm {
     fn is_valid(&self) -> bool {
         self.0.is_valid()
     }
 }
 
-impl PartialEq<&zsliceshm> for ZSliceShm {
-    fn eq(&self, other: &&zsliceshm) -> bool {
+impl PartialEq<&zshm> for ZShm {
+    fn eq(&self, other: &&zshm) -> bool {
         self.0 == other.0 .0
     }
 }
 
-impl Borrow<zsliceshm> for ZSliceShm {
-    fn borrow(&self) -> &zsliceshm {
-        // SAFETY: ZSliceShm, ZSliceShmMut, zsliceshm and zsliceshmmut are #[repr(transparent)]
+impl Borrow<zshm> for ZShm {
+    fn borrow(&self) -> &zshm {
+        // SAFETY: ZShm, ZShmMut, zshm and zshmmut are #[repr(transparent)]
         // to SharedMemoryBuf type, so it is safe to transmute them in any direction
         unsafe { core::mem::transmute(self) }
     }
 }
 
-impl BorrowMut<zsliceshm> for ZSliceShm {
-    fn borrow_mut(&mut self) -> &mut zsliceshm {
-        // SAFETY: ZSliceShm, ZSliceShmMut, zsliceshm and zsliceshmmut are #[repr(transparent)]
+impl BorrowMut<zshm> for ZShm {
+    fn borrow_mut(&mut self) -> &mut zshm {
+        // SAFETY: ZShm, ZShmMut, zshm and zshmmut are #[repr(transparent)]
         // to SharedMemoryBuf type, so it is safe to transmute them in any direction
         unsafe { core::mem::transmute(self) }
     }
 }
 
-impl Deref for ZSliceShm {
+impl Deref for ZShm {
     type Target = [u8];
 
     fn deref(&self) -> &Self::Target {
@@ -66,37 +66,37 @@ impl Deref for ZSliceShm {
     }
 }
 
-impl AsRef<[u8]> for ZSliceShm {
+impl AsRef<[u8]> for ZShm {
     fn as_ref(&self) -> &[u8] {
         self
     }
 }
 
-impl From<SharedMemoryBuf> for ZSliceShm {
+impl From<SharedMemoryBuf> for ZShm {
     fn from(value: SharedMemoryBuf) -> Self {
         Self(value)
     }
 }
 
-impl From<ZSliceShm> for ZSlice {
-    fn from(value: ZSliceShm) -> Self {
+impl From<ZShm> for ZSlice {
+    fn from(value: ZShm) -> Self {
         value.0.into()
     }
 }
 
-impl From<ZSliceShm> for ZBuf {
-    fn from(value: ZSliceShm) -> Self {
+impl From<ZShm> for ZBuf {
+    fn from(value: ZShm) -> Self {
         value.0.into()
     }
 }
 
-impl TryFrom<&mut ZSliceShm> for &mut zsliceshmmut {
+impl TryFrom<&mut ZShm> for &mut zshmmut {
     type Error = ();
 
-    fn try_from(value: &mut ZSliceShm) -> Result<Self, Self::Error> {
+    fn try_from(value: &mut ZShm) -> Result<Self, Self::Error> {
         match value.0.is_unique() && value.0.is_valid() {
             true => {
-                // SAFETY: ZSliceShm, ZSliceShmMut, zsliceshm and zsliceshmmut are #[repr(transparent)]
+                // SAFETY: ZShm, ZShmMut, zshm and zshmmut are #[repr(transparent)]
                 // to SharedMemoryBuf type, so it is safe to transmute them in any direction
                 Ok(unsafe { core::mem::transmute(value) })
             }
@@ -105,64 +105,64 @@ impl TryFrom<&mut ZSliceShm> for &mut zsliceshmmut {
     }
 }
 
-/// A borrowed immutable SHM slice
+/// A borrowed immutable SHM buffer
 #[zenoh_macros::unstable_doc]
 #[derive(Debug, PartialEq, Eq)]
 #[allow(non_camel_case_types)]
 #[repr(transparent)]
-pub struct zsliceshm(ZSliceShm);
+pub struct zshm(ZShm);
 
-impl ToOwned for zsliceshm {
-    type Owned = ZSliceShm;
+impl ToOwned for zshm {
+    type Owned = ZShm;
 
     fn to_owned(&self) -> Self::Owned {
         self.0.clone()
     }
 }
 
-impl PartialEq<ZSliceShm> for &zsliceshm {
-    fn eq(&self, other: &ZSliceShm) -> bool {
+impl PartialEq<ZShm> for &zshm {
+    fn eq(&self, other: &ZShm) -> bool {
         self.0 .0 == other.0
     }
 }
 
-impl Deref for zsliceshm {
-    type Target = ZSliceShm;
+impl Deref for zshm {
+    type Target = ZShm;
 
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
-impl DerefMut for zsliceshm {
+impl DerefMut for zshm {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.0
     }
 }
 
-impl From<&SharedMemoryBuf> for &zsliceshm {
+impl From<&SharedMemoryBuf> for &zshm {
     fn from(value: &SharedMemoryBuf) -> Self {
-        // SAFETY: ZSliceShm, ZSliceShmMut, zsliceshm and zsliceshmmut are #[repr(transparent)]
+        // SAFETY: ZShm, ZShmMut, zshm and zshmmut are #[repr(transparent)]
         // to SharedMemoryBuf type, so it is safe to transmute them in any direction
         unsafe { core::mem::transmute(value) }
     }
 }
 
-impl From<&mut SharedMemoryBuf> for &mut zsliceshm {
+impl From<&mut SharedMemoryBuf> for &mut zshm {
     fn from(value: &mut SharedMemoryBuf) -> Self {
-        // SAFETY: ZSliceShm, ZSliceShmMut, zsliceshm and zsliceshmmut are #[repr(transparent)]
+        // SAFETY: ZShm, ZShmMut, zshm and zshmmut are #[repr(transparent)]
         // to SharedMemoryBuf type, so it is safe to transmute them in any direction
         unsafe { core::mem::transmute(value) }
     }
 }
 
-impl TryFrom<&mut zsliceshm> for &mut zsliceshmmut {
+impl TryFrom<&mut zshm> for &mut zshmmut {
     type Error = ();
 
-    fn try_from(value: &mut zsliceshm) -> Result<Self, Self::Error> {
+    fn try_from(value: &mut zshm) -> Result<Self, Self::Error> {
         match value.0 .0.is_unique() && value.0 .0.is_valid() {
             true => {
-                // SAFETY: ZSliceShm, ZSliceShmMut, zsliceshm and zsliceshmmut are #[repr(transparent)]
+                // SAFETY: ZShm, ZShmMut, zshm and zshmmut are #[repr(transparent)]
                 // to SharedMemoryBuf type, so it is safe to transmute them in any direction
                 Ok(unsafe { core::mem::transmute(value) })
             }
diff --git a/commons/zenoh-shm/src/api/slice/zsliceshmmut.rs b/commons/zenoh-shm/src/api/buffer/zshmmut.rs
similarity index 59%
rename from commons/zenoh-shm/src/api/slice/zsliceshmmut.rs
rename to commons/zenoh-shm/src/api/buffer/zshmmut.rs
index 62823785da..e40c9c77f1 100644
--- a/commons/zenoh-shm/src/api/slice/zsliceshmmut.rs
+++ b/commons/zenoh-shm/src/api/buffer/zshmmut.rs
@@ -21,36 +21,36 @@ use crate::SharedMemoryBuf;
 
 use super::{
     traits::{SHMBuf, SHMBufMut},
-    zsliceshm::{zsliceshm, ZSliceShm},
+    zshm::{zshm, ZShm},
 };
 
-/// A mutable SHM slice
+/// A mutable SHM buffer
 #[zenoh_macros::unstable_doc]
 #[derive(Debug, PartialEq, Eq)]
 #[repr(transparent)]
-pub struct ZSliceShmMut(SharedMemoryBuf);
+pub struct ZShmMut(SharedMemoryBuf);
 
-impl SHMBuf for ZSliceShmMut {
+impl SHMBuf for ZShmMut {
     fn is_valid(&self) -> bool {
         self.0.is_valid()
     }
 }
 
-impl SHMBufMut for ZSliceShmMut {}
+impl SHMBufMut for ZShmMut {}
 
-impl ZSliceShmMut {
+impl ZShmMut {
     pub(crate) unsafe fn new_unchecked(data: SharedMemoryBuf) -> Self {
         Self(data)
     }
 }
 
-impl PartialEq<zsliceshmmut> for &ZSliceShmMut {
-    fn eq(&self, other: &zsliceshmmut) -> bool {
+impl PartialEq<zshmmut> for &ZShmMut {
+    fn eq(&self, other: &zshmmut) -> bool {
         self.0 == other.0 .0
     }
 }
 
-impl TryFrom<SharedMemoryBuf> for ZSliceShmMut {
+impl TryFrom<SharedMemoryBuf> for ZShmMut {
     type Error = SharedMemoryBuf;
 
     fn try_from(value: SharedMemoryBuf) -> Result<Self, Self::Error> {
@@ -61,10 +61,10 @@ impl TryFrom<SharedMemoryBuf> for ZSliceShmMut {
     }
 }
 
-impl TryFrom<ZSliceShm> for ZSliceShmMut {
-    type Error = ZSliceShm;
+impl TryFrom<ZShm> for ZShmMut {
+    type Error = ZShm;
 
-    fn try_from(value: ZSliceShm) -> Result<Self, Self::Error> {
+    fn try_from(value: ZShm) -> Result<Self, Self::Error> {
         match value.0.is_unique() && value.0.is_valid() {
             true => Ok(Self(value.0)),
             false => Err(value),
@@ -72,39 +72,39 @@ impl TryFrom<ZSliceShm> for ZSliceShmMut {
     }
 }
 
-impl Borrow<zsliceshm> for ZSliceShmMut {
-    fn borrow(&self) -> &zsliceshm {
-        // SAFETY: ZSliceShm, ZSliceShmMut, zsliceshm and zsliceshmmut are #[repr(transparent)]
+impl Borrow<zshm> for ZShmMut {
+    fn borrow(&self) -> &zshm {
+        // SAFETY: ZShm, ZShmMut, zshm and zshmmut are #[repr(transparent)]
         // to SharedMemoryBuf type, so it is safe to transmute them in any direction
         unsafe { core::mem::transmute(self) }
     }
 }
 
-impl BorrowMut<zsliceshm> for ZSliceShmMut {
-    fn borrow_mut(&mut self) -> &mut zsliceshm {
-        // SAFETY: ZSliceShm, ZSliceShmMut, zsliceshm and zsliceshmmut are #[repr(transparent)]
+impl BorrowMut<zshm> for ZShmMut {
+    fn borrow_mut(&mut self) -> &mut zshm {
+        // SAFETY: ZShm, ZShmMut, zshm and zshmmut are #[repr(transparent)]
         // to SharedMemoryBuf type, so it is safe to transmute them in any direction
         unsafe { core::mem::transmute(self) }
     }
 }
 
-impl Borrow<zsliceshmmut> for ZSliceShmMut {
-    fn borrow(&self) -> &zsliceshmmut {
-        // SAFETY: ZSliceShm, ZSliceShmMut, zsliceshm and zsliceshmmut are #[repr(transparent)]
+impl Borrow<zshmmut> for ZShmMut {
+    fn borrow(&self) -> &zshmmut {
+        // SAFETY: ZShm, ZShmMut, zshm and zshmmut are #[repr(transparent)]
         // to SharedMemoryBuf type, so it is safe to transmute them in any direction
         unsafe { core::mem::transmute(self) }
     }
 }
 
-impl BorrowMut<zsliceshmmut> for ZSliceShmMut {
-    fn borrow_mut(&mut self) -> &mut zsliceshmmut {
-        // SAFETY: ZSliceShm, ZSliceShmMut, zsliceshm and zsliceshmmut are #[repr(transparent)]
+impl BorrowMut<zshmmut> for ZShmMut {
+    fn borrow_mut(&mut self) -> &mut zshmmut {
+        // SAFETY: ZShm, ZShmMut, zshm and zshmmut are #[repr(transparent)]
         // to SharedMemoryBuf type, so it is safe to transmute them in any direction
         unsafe { core::mem::transmute(self) }
     }
 }
 
-impl Deref for ZSliceShmMut {
+impl Deref for ZShmMut {
     type Target = [u8];
 
     fn deref(&self) -> &Self::Target {
@@ -112,75 +112,75 @@ impl Deref for ZSliceShmMut {
     }
 }
 
-impl DerefMut for ZSliceShmMut {
+impl DerefMut for ZShmMut {
     fn deref_mut(&mut self) -> &mut Self::Target {
         self.0.as_mut()
     }
 }
 
-impl AsRef<[u8]> for ZSliceShmMut {
+impl AsRef<[u8]> for ZShmMut {
     fn as_ref(&self) -> &[u8] {
         self
     }
 }
 
-impl AsMut<[u8]> for ZSliceShmMut {
+impl AsMut<[u8]> for ZShmMut {
     fn as_mut(&mut self) -> &mut [u8] {
         self
     }
 }
 
-impl From<ZSliceShmMut> for ZSliceShm {
-    fn from(value: ZSliceShmMut) -> Self {
+impl From<ZShmMut> for ZShm {
+    fn from(value: ZShmMut) -> Self {
         value.0.into()
     }
 }
 
-impl From<ZSliceShmMut> for ZSlice {
-    fn from(value: ZSliceShmMut) -> Self {
+impl From<ZShmMut> for ZSlice {
+    fn from(value: ZShmMut) -> Self {
         value.0.into()
     }
 }
 
-impl From<ZSliceShmMut> for ZBuf {
-    fn from(value: ZSliceShmMut) -> Self {
+impl From<ZShmMut> for ZBuf {
+    fn from(value: ZShmMut) -> Self {
         value.0.into()
     }
 }
 
-/// A borrowed mutable SHM slice
+/// A borrowed mutable SHM buffer
 #[zenoh_macros::unstable_doc]
 #[derive(Debug, PartialEq, Eq)]
 #[allow(non_camel_case_types)]
 #[repr(transparent)]
-pub struct zsliceshmmut(ZSliceShmMut);
+pub struct zshmmut(ZShmMut);
 
-impl PartialEq<ZSliceShmMut> for &zsliceshmmut {
-    fn eq(&self, other: &ZSliceShmMut) -> bool {
+impl PartialEq<ZShmMut> for &zshmmut {
+    fn eq(&self, other: &ZShmMut) -> bool {
         self.0 .0 == other.0
     }
 }
 
-impl Deref for zsliceshmmut {
-    type Target = ZSliceShmMut;
+impl Deref for zshmmut {
+    type Target = ZShmMut;
 
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
-impl DerefMut for zsliceshmmut {
+impl DerefMut for zshmmut {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.0
     }
 }
 
-impl TryFrom<&mut SharedMemoryBuf> for &mut zsliceshmmut {
+impl TryFrom<&mut SharedMemoryBuf> for &mut zshmmut {
     type Error = ();
 
     fn try_from(value: &mut SharedMemoryBuf) -> Result<Self, Self::Error> {
         match value.is_unique() && value.is_valid() {
-            // SAFETY: ZSliceShm, ZSliceShmMut, zsliceshm and zsliceshmmut are #[repr(transparent)]
+            // SAFETY: ZShm, ZShmMut, zshm and zshmmut are #[repr(transparent)]
             // to SharedMemoryBuf type, so it is safe to transmute them in any direction
             true => Ok(unsafe { core::mem::transmute(value) }),
             false => Err(()),
diff --git a/commons/zenoh-shm/src/api/mod.rs b/commons/zenoh-shm/src/api/mod.rs
index 08a5678fa8..a87188da29 100644
--- a/commons/zenoh-shm/src/api/mod.rs
+++ b/commons/zenoh-shm/src/api/mod.rs
@@ -12,9 +12,9 @@
 //   ZettaScale Zenoh Team, <zenoh@zettascale.tech>
 //
 
+pub mod buffer;
 pub mod client;
 pub mod client_storage;
 pub mod common;
 pub mod protocol_implementations;
 pub mod provider;
-pub mod slice;
diff --git a/commons/zenoh-shm/src/api/provider/shared_memory_provider.rs b/commons/zenoh-shm/src/api/provider/shared_memory_provider.rs
index c3b8128300..82a4789738 100644
--- a/commons/zenoh-shm/src/api/provider/shared_memory_provider.rs
+++ b/commons/zenoh-shm/src/api/provider/shared_memory_provider.rs
@@ -23,7 +23,7 @@ use async_trait::async_trait;
 use zenoh_result::ZResult;
 
 use crate::{
-    api::{common::types::ProtocolID, slice::zsliceshmmut::ZSliceShmMut},
+    api::{buffer::zshmmut::ZShmMut, common::types::ProtocolID},
     header::{
         allocated_descriptor::AllocatedHeaderDescriptor, descriptor::HeaderDescriptor,
         storage::GLOBAL_HEADER_STORAGE,
@@ -713,11 +713,11 @@ where
         self.backend.defragment()
     }
 
-    /// Map externally-allocated chunk into ZSliceShmMut.
+    /// Map externally-allocated chunk into ZShmMut.
     /// This method is designed to be used with push data sources.
     /// Remember that chunk's len may be >= len!
     #[zenoh_macros::unstable_doc]
-    pub fn map(&self, chunk: AllocatedChunk, len: usize) -> ZResult<ZSliceShmMut> {
+    pub fn map(&self, chunk: AllocatedChunk, len: usize) -> ZResult<ZShmMut> {
         // allocate resources for SHM buffer
         let (allocated_header, allocated_watchdog, confirmed_watchdog) = Self::alloc_resources()?;
 
@@ -729,7 +729,7 @@ where
             allocated_watchdog,
             confirmed_watchdog,
         );
-        Ok(unsafe { ZSliceShmMut::new_unchecked(wrapped) })
+        Ok(unsafe { ZShmMut::new_unchecked(wrapped) })
     }
 
     /// Try to collect free chunks.
@@ -806,7 +806,7 @@ where
             allocated_watchdog,
             confirmed_watchdog,
         );
-        Ok(unsafe { ZSliceShmMut::new_unchecked(wrapped) })
+        Ok(unsafe { ZShmMut::new_unchecked(wrapped) })
     }
 
     fn alloc_resources() -> ZResult<(
@@ -911,6 +911,6 @@ where
             allocated_watchdog,
             confirmed_watchdog,
         );
-        Ok(unsafe { ZSliceShmMut::new_unchecked(wrapped) })
+        Ok(unsafe { ZShmMut::new_unchecked(wrapped) })
     }
 }
diff --git a/commons/zenoh-shm/src/api/provider/types.rs b/commons/zenoh-shm/src/api/provider/types.rs
index 662482f567..b7f1ad2de6 100644
--- a/commons/zenoh-shm/src/api/provider/types.rs
+++ b/commons/zenoh-shm/src/api/provider/types.rs
@@ -16,7 +16,7 @@ use std::fmt::Display;
 
 use zenoh_result::{bail, ZResult};
 
-use crate::api::slice::zsliceshmmut::ZSliceShmMut;
+use crate::api::buffer::zshmmut::ZShmMut;
 
 use super::chunk::AllocatedChunk;
 
@@ -170,4 +170,4 @@ pub type ChunkAllocResult = Result<AllocatedChunk, ZAllocError>;
 
 /// SHM buffer allocation result
 #[zenoh_macros::unstable_doc]
-pub type BufAllocResult = Result<ZSliceShmMut, ZAllocError>;
+pub type BufAllocResult = Result<ZShmMut, ZAllocError>;
diff --git a/examples/examples/z_get_shm.rs b/examples/examples/z_get_shm.rs
index 60015829aa..2773348fd0 100644
--- a/examples/examples/z_get_shm.rs
+++ b/examples/examples/z_get_shm.rs
@@ -94,7 +94,7 @@ async fn main() {
         match reply.result() {
             Ok(sample) => {
                 print!(">> Received ('{}': ", sample.key_expr().as_str());
-                match sample.payload().deserialize::<&zsliceshm>() {
+                match sample.payload().deserialize::<&zshm>() {
                     Ok(payload) => println!("'{}')", String::from_utf8_lossy(payload),),
                     Err(e) => println!("'Not a SharedMemoryBuf: {:?}')", e),
                 }
diff --git a/examples/examples/z_payload_shm.rs b/examples/examples/z_payload_shm.rs
index 4bf45381de..d9ab4e1f82 100644
--- a/examples/examples/z_payload_shm.rs
+++ b/examples/examples/z_payload_shm.rs
@@ -14,8 +14,8 @@
 use zenoh::{
     bytes::ZBytes,
     shm::{
-        zsliceshm, zsliceshmmut, PosixSharedMemoryProviderBackend, SharedMemoryProviderBuilder,
-        ZSliceShm, ZSliceShmMut, POSIX_PROTOCOL_ID,
+        zshm, zshmmut, PosixSharedMemoryProviderBackend, SharedMemoryProviderBuilder, ZShm,
+        ZShmMut, POSIX_PROTOCOL_ID,
     },
 };
 
@@ -35,59 +35,59 @@ fn main() {
     // Prepare a layout for allocations
     let layout = provider.alloc_layout().size(1024).res().unwrap();
 
-    // allocate an SHM buffer (ZSliceShmMut)
+    // allocate an SHM buffer (ZShmMut)
     let mut owned_shm_buf_mut = layout.alloc().res().unwrap();
 
     // mutable and immutable API
     let _data: &[u8] = &owned_shm_buf_mut;
     let _data_mut: &mut [u8] = &mut owned_shm_buf_mut;
 
-    // convert into immutable owned buffer (ZSliceShmMut -> ZSlceShm)
-    let owned_shm_buf: ZSliceShm = owned_shm_buf_mut.into();
+    // convert into immutable owned buffer (ZShmMut -> ZSlceShm)
+    let owned_shm_buf: ZShm = owned_shm_buf_mut.into();
 
     // immutable API
     let _data: &[u8] = &owned_shm_buf;
 
-    // convert again into mutable owned buffer (ZSliceShm -> ZSlceShmMut)
-    let mut owned_shm_buf_mut: ZSliceShmMut = owned_shm_buf.try_into().unwrap();
+    // convert again into mutable owned buffer (ZShm -> ZSlceShmMut)
+    let mut owned_shm_buf_mut: ZShmMut = owned_shm_buf.try_into().unwrap();
 
     // mutable and immutable API
     let _data: &[u8] = &owned_shm_buf_mut;
     let _data_mut: &mut [u8] = &mut owned_shm_buf_mut;
 
-    // build a ZBytes from an SHM buffer (ZSliceShmMut -> ZBytes)
+    // build a ZBytes from an SHM buffer (ZShmMut -> ZBytes)
     let mut payload: ZBytes = owned_shm_buf_mut.into();
 
     // branch to illustrate immutable access to SHM data
     {
-        // deserialize ZBytes as an immutably borrowed zsliceshm (ZBytes -> &zsliceshm)
-        let borrowed_shm_buf: &zsliceshm = payload.deserialize().unwrap();
+        // deserialize ZBytes as an immutably borrowed zshm (ZBytes -> &zshm)
+        let borrowed_shm_buf: &zshm = payload.deserialize().unwrap();
 
         // immutable API
         let _data: &[u8] = borrowed_shm_buf;
 
-        // construct owned buffer from borrowed type (&zsliceshm -> ZSliceShm)
+        // construct owned buffer from borrowed type (&zshm -> ZShm)
         let owned = borrowed_shm_buf.to_owned();
 
         // immutable API
         let _data: &[u8] = &owned;
 
-        // try to construct mutable ZSliceShmMut (ZSliceShm -> ZSliceShmMut)
-        let owned_mut: Result<ZSliceShmMut, _> = owned.try_into();
-        // the attempt fails because ZSliceShm has two existing references ('owned' and inside 'payload')
+        // try to construct mutable ZShmMut (ZShm -> ZShmMut)
+        let owned_mut: Result<ZShmMut, _> = owned.try_into();
+        // the attempt fails because ZShm has two existing references ('owned' and inside 'payload')
         assert!(owned_mut.is_err())
     }
 
     // branch to illustrate mutable access to SHM data
     {
-        // deserialize ZBytes as mutably borrowed zsliceshm (ZBytes -> &mut zsliceshm)
-        let borrowed_shm_buf: &mut zsliceshm = payload.deserialize_mut().unwrap();
+        // deserialize ZBytes as mutably borrowed zshm (ZBytes -> &mut zshm)
+        let borrowed_shm_buf: &mut zshm = payload.deserialize_mut().unwrap();
 
         // immutable API
         let _data: &[u8] = borrowed_shm_buf;
 
-        // convert zsliceshm to zsliceshmmut (&mut zsliceshm -> &mut zsliceshmmut)
-        let borrowed_shm_buf_mut: &mut zsliceshmmut = borrowed_shm_buf.try_into().unwrap();
+        // convert zshm to zshmmut (&mut zshm -> &mut zshmmut)
+        let borrowed_shm_buf_mut: &mut zshmmut = borrowed_shm_buf.try_into().unwrap();
 
         // mutable and immutable API
         let _data: &[u8] = borrowed_shm_buf_mut;
diff --git a/examples/examples/z_ping_shm.rs b/examples/examples/z_ping_shm.rs
index 7a7bd61580..372967f6e8 100644
--- a/examples/examples/z_ping_shm.rs
+++ b/examples/examples/z_ping_shm.rs
@@ -80,7 +80,7 @@ fn main() {
         .res()
         .unwrap();
 
-    // convert ZSliceShmMut into ZSlice as ZSliceShmMut does not support Clone
+    // convert ZShmMut into ZSlice as ZShmMut does not support Clone
     let buf: ZSlice = buf.into();
 
     // -- warmup --
diff --git a/examples/examples/z_queryable_shm.rs b/examples/examples/z_queryable_shm.rs
index 62fa7571d5..49939dcb0a 100644
--- a/examples/examples/z_queryable_shm.rs
+++ b/examples/examples/z_queryable_shm.rs
@@ -76,7 +76,7 @@ async fn main() {
             query.key_expr().as_str(),
         );
         if let Some(payload) = query.payload() {
-            match payload.deserialize::<&zsliceshm>() {
+            match payload.deserialize::<&zshm>() {
                 Ok(payload) => print!(": '{}'", String::from_utf8_lossy(payload)),
                 Err(e) => print!(": 'Not a SharedMemoryBuf: {:?}'", e),
             }
diff --git a/examples/examples/z_sub_shm.rs b/examples/examples/z_sub_shm.rs
index a43b5c6cd0..a7e96c2b75 100644
--- a/examples/examples/z_sub_shm.rs
+++ b/examples/examples/z_sub_shm.rs
@@ -41,7 +41,7 @@ async fn main() {
             sample.kind(),
             sample.key_expr().as_str(),
         );
-        match sample.payload().deserialize::<&zsliceshm>() {
+        match sample.payload().deserialize::<&zshm>() {
             Ok(payload) => print!("'{}'", String::from_utf8_lossy(payload)),
             Err(e) => print!("'Not a SharedMemoryBuf: {:?}'", e),
         }
@@ -52,12 +52,12 @@ async fn main() {
     // // holding a reference to the SHM buffer, then it will be able to get a mutable reference to it.
     // // With the mutable reference at hand, it's possible to mutate in place the SHM buffer content.
     //
-    // use zenoh::shm::zsliceshmmut;
+    // use zenoh::shm::zshmmut;
 
     // while let Ok(mut sample) = subscriber.recv_async().await {
     //     let kind = sample.kind();
     //     let key_expr = sample.key_expr().to_string();
-    //     match sample.payload_mut().deserialize_mut::<&mut zsliceshmmut>() {
+    //     match sample.payload_mut().deserialize_mut::<&mut zshmmut>() {
     //         Ok(payload) => println!(
     //             ">> [Subscriber] Received {} ('{}': '{:02x?}')",
     //             kind, key_expr, payload
diff --git a/zenoh/src/api/bytes.rs b/zenoh/src/api/bytes.rs
index c36136ef81..ce88b2bdbe 100644
--- a/zenoh/src/api/bytes.rs
+++ b/zenoh/src/api/bytes.rs
@@ -30,9 +30,9 @@ use zenoh_protocol::{core::Properties, zenoh::ext::AttachmentType};
 use zenoh_result::{ZError, ZResult};
 #[cfg(all(feature = "shared-memory", feature = "unstable"))]
 use zenoh_shm::{
-    api::slice::{
-        zsliceshm::{zsliceshm, ZSliceShm},
-        zsliceshmmut::{zsliceshmmut, ZSliceShmMut},
+    api::buffer::{
+        zshm::{zshm, ZShm},
+        zshmmut::{zshmmut, ZShmMut},
     },
     SharedMemoryBuf,
 };
@@ -1524,47 +1524,47 @@ impl TryFrom<&mut ZBytes> for serde_pickle::Value {
 
 // Shared memory conversion
 #[cfg(all(feature = "shared-memory", feature = "unstable"))]
-impl Serialize<ZSliceShm> for ZSerde {
+impl Serialize<ZShm> for ZSerde {
     type Output = ZBytes;
 
-    fn serialize(self, t: ZSliceShm) -> Self::Output {
+    fn serialize(self, t: ZShm) -> Self::Output {
         let slice: ZSlice = t.into();
         ZBytes::new(slice)
     }
 }
 
 #[cfg(all(feature = "shared-memory", feature = "unstable"))]
-impl From<ZSliceShm> for ZBytes {
-    fn from(t: ZSliceShm) -> Self {
+impl From<ZShm> for ZBytes {
+    fn from(t: ZShm) -> Self {
         ZSerde.serialize(t)
     }
 }
 
 // Shared memory conversion
 #[cfg(all(feature = "shared-memory", feature = "unstable"))]
-impl Serialize<ZSliceShmMut> for ZSerde {
+impl Serialize<ZShmMut> for ZSerde {
     type Output = ZBytes;
 
-    fn serialize(self, t: ZSliceShmMut) -> Self::Output {
+    fn serialize(self, t: ZShmMut) -> Self::Output {
         let slice: ZSlice = t.into();
         ZBytes::new(slice)
     }
 }
 
 #[cfg(all(feature = "shared-memory", feature = "unstable"))]
-impl From<ZSliceShmMut> for ZBytes {
-    fn from(t: ZSliceShmMut) -> Self {
+impl From<ZShmMut> for ZBytes {
+    fn from(t: ZShmMut) -> Self {
         ZSerde.serialize(t)
     }
 }
 
 #[cfg(all(feature = "shared-memory", feature = "unstable"))]
-impl<'a> Deserialize<'a, &'a zsliceshm> for ZSerde {
+impl<'a> Deserialize<'a, &'a zshm> for ZSerde {
     type Input = &'a ZBytes;
     type Error = ZDeserializeError;
 
-    fn deserialize(self, v: Self::Input) -> Result<&'a zsliceshm, Self::Error> {
-        // A ZSliceShm is expected to have only one slice
+    fn deserialize(self, v: Self::Input) -> Result<&'a zshm, Self::Error> {
+        // A ZShm is expected to have only one slice
         let mut zslices = v.0.zslices();
         if let Some(zs) = zslices.next() {
             if let Some(shmb) = zs.downcast_ref::<SharedMemoryBuf>() {
@@ -1576,7 +1576,7 @@ impl<'a> Deserialize<'a, &'a zsliceshm> for ZSerde {
 }
 
 #[cfg(all(feature = "shared-memory", feature = "unstable"))]
-impl<'a> TryFrom<&'a ZBytes> for &'a zsliceshm {
+impl<'a> TryFrom<&'a ZBytes> for &'a zshm {
     type Error = ZDeserializeError;
 
     fn try_from(value: &'a ZBytes) -> Result<Self, Self::Error> {
@@ -1585,7 +1585,7 @@ impl<'a> TryFrom<&'a ZBytes> for &'a zsliceshm {
 }
 
 #[cfg(all(feature = "shared-memory", feature = "unstable"))]
-impl<'a> TryFrom<&'a mut ZBytes> for &'a mut zsliceshm {
+impl<'a> TryFrom<&'a mut ZBytes> for &'a mut zshm {
     type Error = ZDeserializeError;
 
     fn try_from(value: &'a mut ZBytes) -> Result<Self, Self::Error> {
@@ -1594,11 +1594,11 @@ impl<'a> TryFrom<&'a mut ZBytes> for &'a mut zsliceshm {
 }
 
 #[cfg(all(feature = "shared-memory", feature = "unstable"))]
-impl<'a> Deserialize<'a, &'a mut zsliceshm> for ZSerde {
+impl<'a> Deserialize<'a, &'a mut zshm> for ZSerde {
     type Input = &'a mut ZBytes;
     type Error = ZDeserializeError;
 
-    fn deserialize(self, v: Self::Input) -> Result<&'a mut zsliceshm, Self::Error> {
+    fn deserialize(self, v: Self::Input) -> Result<&'a mut zshm, Self::Error> {
         // A ZSliceShmBorrowMut is expected to have only one slice
         let mut zslices = v.0.zslices_mut();
         if let Some(zs) = zslices.next() {
@@ -1611,11 +1611,11 @@ impl<'a> Deserialize<'a, &'a mut zsliceshm> for ZSerde {
 }
 
 #[cfg(all(feature = "shared-memory", feature = "unstable"))]
-impl<'a> Deserialize<'a, &'a mut zsliceshmmut> for ZSerde {
+impl<'a> Deserialize<'a, &'a mut zshmmut> for ZSerde {
     type Input = &'a mut ZBytes;
     type Error = ZDeserializeError;
 
-    fn deserialize(self, v: Self::Input) -> Result<&'a mut zsliceshmmut, Self::Error> {
+    fn deserialize(self, v: Self::Input) -> Result<&'a mut zshmmut, Self::Error> {
         // A ZSliceShmBorrowMut is expected to have only one slice
         let mut zslices = v.0.zslices_mut();
         if let Some(zs) = zslices.next() {
@@ -1628,7 +1628,7 @@ impl<'a> Deserialize<'a, &'a mut zsliceshmmut> for ZSerde {
 }
 
 #[cfg(all(feature = "shared-memory", feature = "unstable"))]
-impl<'a> TryFrom<&'a mut ZBytes> for &'a mut zsliceshmmut {
+impl<'a> TryFrom<&'a mut ZBytes> for &'a mut zshmmut {
     type Error = ZDeserializeError;
 
     fn try_from(value: &'a mut ZBytes) -> Result<Self, Self::Error> {
@@ -1838,7 +1838,7 @@ mod tests {
                 protocol_id::POSIX_PROTOCOL_ID,
             },
             provider::shared_memory_provider::SharedMemoryProviderBuilder,
-            slice::zsliceshm::{zsliceshm, ZSliceShm},
+            slice::zshm::{zshm, ZShm},
         };
 
         const NUM: usize = 1_000;
@@ -1964,9 +1964,9 @@ mod tests {
             let mutable_shm_buf = layout.alloc().res().unwrap();
 
             // convert to immutable SHM buffer
-            let immutable_shm_buf: ZSliceShm = mutable_shm_buf.into();
+            let immutable_shm_buf: ZShm = mutable_shm_buf.into();
 
-            serialize_deserialize!(&zsliceshm, immutable_shm_buf);
+            serialize_deserialize!(&zshm, immutable_shm_buf);
         }
 
         // Properties
diff --git a/zenoh/src/api/encoding.rs b/zenoh/src/api/encoding.rs
index 6c08303612..791bdbd3ea 100644
--- a/zenoh/src/api/encoding.rs
+++ b/zenoh/src/api/encoding.rs
@@ -17,7 +17,7 @@ use std::{borrow::Cow, convert::Infallible, fmt, str::FromStr};
 use zenoh_buffers::{ZBuf, ZSlice};
 use zenoh_protocol::core::EncodingId;
 #[cfg(feature = "shared-memory")]
-use zenoh_shm::api::slice::{zsliceshm::ZSliceShm, zsliceshmmut::ZSliceShmMut};
+use zenoh_shm::api::buffer::{zshm::ZShm, zshmmut::ZShmMut};
 
 /// Default encoding values used by Zenoh.
 ///
@@ -835,10 +835,10 @@ impl EncodingMapping for serde_pickle::Value {
 
 // - Zenoh SHM
 #[cfg(feature = "shared-memory")]
-impl EncodingMapping for ZSliceShm {
+impl EncodingMapping for ZShm {
     const ENCODING: Encoding = Encoding::ZENOH_BYTES;
 }
 #[cfg(feature = "shared-memory")]
-impl EncodingMapping for ZSliceShmMut {
+impl EncodingMapping for ZShmMut {
     const ENCODING: Encoding = Encoding::ZENOH_BYTES;
 }
diff --git a/zenoh/src/lib.rs b/zenoh/src/lib.rs
index 92901c54b3..6e6f7bae64 100644
--- a/zenoh/src/lib.rs
+++ b/zenoh/src/lib.rs
@@ -417,6 +417,10 @@ pub mod internal {
 
 #[cfg(all(feature = "unstable", feature = "shared-memory"))]
 pub mod shm {
+    pub use zenoh_shm::api::buffer::{
+        zshm::{zshm, ZShm},
+        zshmmut::{zshmmut, ZShmMut},
+    };
     pub use zenoh_shm::api::client::{
         shared_memory_client::SharedMemoryClient, shared_memory_segment::SharedMemorySegment,
     };
@@ -441,8 +445,4 @@ pub mod shm {
     pub use zenoh_shm::api::provider::types::{
         AllocAlignment, BufAllocResult, ChunkAllocResult, MemoryLayout, ZAllocError,
     };
-    pub use zenoh_shm::api::slice::{
-        zsliceshm::{zsliceshm, ZSliceShm},
-        zsliceshmmut::{zsliceshmmut, ZSliceShmMut},
-    };
 }
diff --git a/zenoh/tests/bytes.rs b/zenoh/tests/bytes.rs
index 41e6d14c6e..f8eb11bf63 100644
--- a/zenoh/tests/bytes.rs
+++ b/zenoh/tests/bytes.rs
@@ -32,38 +32,38 @@ fn shm_bytes_single_buf() {
     // Prepare a layout for allocations
     let layout = provider.alloc_layout().size(1024).res().unwrap();
 
-    // allocate an SHM buffer (ZSliceShmMut)
+    // allocate an SHM buffer (ZShmMut)
     let owned_shm_buf_mut = layout.alloc().res().unwrap();
 
-    // convert into immutable owned buffer (ZSliceShmMut -> ZSlceShm)
-    let owned_shm_buf: ZSliceShm = owned_shm_buf_mut.into();
+    // convert into immutable owned buffer (ZShmMut -> ZSlceShm)
+    let owned_shm_buf: ZShm = owned_shm_buf_mut.into();
 
-    // convert again into mutable owned buffer (ZSliceShm -> ZSlceShmMut)
-    let owned_shm_buf_mut: ZSliceShmMut = owned_shm_buf.try_into().unwrap();
+    // convert again into mutable owned buffer (ZShm -> ZSlceShmMut)
+    let owned_shm_buf_mut: ZShmMut = owned_shm_buf.try_into().unwrap();
 
-    // build a ZBytes from an SHM buffer (ZSliceShmMut -> ZBytes)
+    // build a ZBytes from an SHM buffer (ZShmMut -> ZBytes)
     let mut payload: ZBytes = owned_shm_buf_mut.into();
 
     // branch to illustrate immutable access to SHM data
     {
-        // deserialize ZBytes as an immutably borrowed zsliceshm (ZBytes -> &zsliceshm)
-        let borrowed_shm_buf: &zsliceshm = payload.deserialize().unwrap();
+        // deserialize ZBytes as an immutably borrowed zshm (ZBytes -> &zshm)
+        let borrowed_shm_buf: &zshm = payload.deserialize().unwrap();
 
-        // construct owned buffer from borrowed type (&zsliceshm -> ZSliceShm)
+        // construct owned buffer from borrowed type (&zshm -> ZShm)
         let owned = borrowed_shm_buf.to_owned();
 
-        // try to construct mutable ZSliceShmMut (ZSliceShm -> ZSliceShmMut)
-        let owned_mut: Result<ZSliceShmMut, _> = owned.try_into();
-        // the attempt fails because ZSliceShm has two existing references ('owned' and inside 'payload')
+        // try to construct mutable ZShmMut (ZShm -> ZShmMut)
+        let owned_mut: Result<ZShmMut, _> = owned.try_into();
+        // the attempt fails because ZShm has two existing references ('owned' and inside 'payload')
         assert!(owned_mut.is_err())
     }
 
     // branch to illustrate mutable access to SHM data
     {
-        // deserialize ZBytes as mutably borrowed zsliceshm (ZBytes -> &mut zsliceshm)
-        let borrowed_shm_buf: &mut zsliceshm = payload.deserialize_mut().unwrap();
+        // deserialize ZBytes as mutably borrowed zshm (ZBytes -> &mut zshm)
+        let borrowed_shm_buf: &mut zshm = payload.deserialize_mut().unwrap();
 
-        // convert zsliceshm to zsliceshmmut (&mut zsliceshm -> &mut zsliceshmmut)
-        let _borrowed_shm_buf_mut: &mut zsliceshmmut = borrowed_shm_buf.try_into().unwrap();
+        // convert zshm to zshmmut (&mut zshm -> &mut zshmmut)
+        let _borrowed_shm_buf_mut: &mut zshmmut = borrowed_shm_buf.try_into().unwrap();
     }
 }