diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7b7f7a1f30eb015b23d23c7f299ab585726ee54f..a8581dc0cc15c63d41f292415ef75ebc89bad657 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,6 +7,7 @@ option(CXX23_STACKTRACE "Enable C++23 stacktrace" OFF)
 enable_language(CXX)
 if(CXX23_STACKTRACE)
     set(CMAKE_CXX_STANDARD 23)
+    add_definitions(-DINCLUDE_CXX23_STACKTRACE)
 else(CXX23_STACKTRACE)
     set(CMAKE_CXX_STANDARD 11)
 endif(CXX23_STACKTRACE)
@@ -36,10 +37,18 @@ if(INCLUDE_CUDA)
     )
 endif(INCLUDE_CUDA)
 
+if(CXX23_STACKTRACE)
+    set(STACKTRACE_HEADERS
+        include/stacktrace.h
+        )
+endif(CXX23_STACKTRACE)
+
 set(SOURCES ${SOURCES_CU} ${SOURCES_CXX})
-set(HEADERS ${HEADERS_CU} ${HEADERS_CXX})
+set(HEADERS ${HEADERS_CU} ${HEADERS_CXX} ${STACKTRACE_HEADERS})
 
 add_library(memproc STATIC ${HEADERS} ${SOURCES})
+target_include_directories(memproc PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
 if(CXX23_STACKTRACE)
     target_link_libraries(memproc PUBLIC -lstdc++_libbacktrace)
 endif(CXX23_STACKTRACE)
\ No newline at end of file
diff --git a/include/stacktrace.h b/include/stacktrace.h
new file mode 100644
index 0000000000000000000000000000000000000000..d8a186388f757399c5c8ad5de3195c1105c53e30
--- /dev/null
+++ b/include/stacktrace.h
@@ -0,0 +1,9 @@
+#pragma once 
+
+#include <iostream>
+#include <stacktrace>
+
+void print_stacktrace() 
+{
+    std::cout << std::stacktrace::current() << '\n';
+}
\ No newline at end of file
diff --git a/src/MemoryProcessing.cpp b/src/MemoryProcessing.cpp
index 4a6dcd83301fc5ecc912a4c9387e6aa0dc517bc1..9bce5f4412d53d3a62ae5c4c3215f72dcfd1d300 100644
--- a/src/MemoryProcessing.cpp
+++ b/src/MemoryProcessing.cpp
@@ -1,12 +1,20 @@
-#include "../include/MemoryProcessing.h"
+#include "MemoryProcessing.h"
 #include <cstdlib>
 #include <cstring>
 
+#ifdef INCLUDE_CXX23_STACKTRACE
+    #include "stacktrace.h"
+#endif
+
 namespace memproc
 {
     template<>
     bool dealloc<MemType::CPU>(void *&array, size_t &allocated_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         if(allocated_size > 0)
         {
             free(array);
@@ -19,6 +27,10 @@ namespace memproc
     template<>
     bool dealloc<MemType::CPU>(void *&array)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         free(array);
         return true;
     }
@@ -26,6 +38,10 @@ namespace memproc
     template <>
     bool alloc<MemType::CPU>(void *&array, const size_t new_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         array = malloc(new_size);
         memset(array, 0, new_size);
 
@@ -36,6 +52,10 @@ namespace memproc
     template <>
     bool realloc<MemType::CPU>(void *&array, size_t &allocated_size, const size_t new_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         if(new_size > allocated_size)
         {
             if(allocated_size > 0) dealloc<MemType::CPU>(array, allocated_size);
@@ -50,6 +70,10 @@ namespace memproc
     template <>
     bool memcopy<MemType::CPU, MemType::CPU>(void *dst, const void* src, const size_t copy_elem_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         memcpy(dst, src, copy_elem_size);
 
         return true;
diff --git a/src/MemoryProcessing.cu b/src/MemoryProcessing.cu
index 4c866edff474f039eca1ef2ddd4c535ee0574ac2..69254fd2d6e28f5e95642996c45e55c11d20d423 100644
--- a/src/MemoryProcessing.cu
+++ b/src/MemoryProcessing.cu
@@ -1,12 +1,20 @@
-#include "../include/MemoryProcessing.cuh"
+#include "MemoryProcessing.cuh"
 #include <cuda.h>
 #include <cuda_runtime_api.h>
 
+#ifdef INCLUDE_CXX23_STACKTRACE
+    #include "stacktrace.h"
+#endif
+
 namespace memproc
 {
     template<>
     bool dealloc<MemType::GPU>(void *&array, size_t &allocated_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         if(allocated_size > 0)
         {
             cudaFree(array);
@@ -19,6 +27,10 @@ namespace memproc
     template<>
     bool dealloc<MemType::GPU>(void *&array)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         cudaFree(array);
         return true;
     }
@@ -26,6 +38,10 @@ namespace memproc
     template <>
     bool alloc<MemType::GPU>(void *&array, const size_t new_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         cudaMalloc ( (void **)&array, new_size);
         cudaMemset(array, 0, new_size);
 
@@ -35,6 +51,10 @@ namespace memproc
     template <>
     bool realloc<MemType::GPU>(void *&array, size_t &allocated_size, const size_t new_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         if(new_size > allocated_size)
         {
             if(allocated_size > 0) dealloc<MemType::GPU>(array, allocated_size);
@@ -49,6 +69,10 @@ namespace memproc
     template <>
     bool memcopy<MemType::GPU, MemType::CPU>(void *dst, const void* src, const size_t copy_elem_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         cudaMemcpy ( dst, src, copy_elem_size, cudaMemcpyHostToDevice);
 
         return true;
@@ -57,6 +81,10 @@ namespace memproc
     template <>
     bool memcopy<MemType::CPU, MemType::GPU>(void *dst, const void* src, const size_t copy_elem_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         cudaMemcpy ( dst, src, copy_elem_size, cudaMemcpyDeviceToHost);
         return true;
     }
@@ -64,6 +92,10 @@ namespace memproc
     template <>
     bool memcopy<MemType::GPU, MemType::GPU>(void *dst, const void* src, const size_t copy_elem_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         cudaMemcpy ( dst, src, copy_elem_size, cudaMemcpyDeviceToDevice);
         return true;
     }