diff --git a/projects/roctracer/CMakeLists.txt b/projects/roctracer/CMakeLists.txt
index c40fd95ad5..f1ad1982cc 100644
--- a/projects/roctracer/CMakeLists.txt
+++ b/projects/roctracer/CMakeLists.txt
@@ -85,7 +85,9 @@ set_property ( TARGET ${TARGET_NAME} PROPERTY SOVERSION "${LIB_VERSION_MAJOR}" )
 #endif ()
 
 ## Build tests
+if ( ${LIBRARY_TYPE} STREQUAL SHARED )
 add_subdirectory ( ${TEST_DIR} ${PROJECT_BINARY_DIR}/test )
+endif()
 
 ## pbulic headers
 set ( PUBLIC_HEADERS
@@ -106,6 +108,8 @@ set ( PUBLIC_HEADERS
   ext/hsa_rt_utils.hpp
 )
 
+if ( ${LIBRARY_TYPE} STREQUAL SHARED )
+
 ## Installation and packaging
 set ( DEST_NAME ${ROCTRACER_NAME} )
 if ( DEFINED CPACK_PACKAGING_INSTALL_PREFIX )
@@ -181,3 +185,5 @@ set ( CPACK_RPM_POST_INSTALL_SCRIPT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/RPM/rpm_po
 set ( CPACK_RPM_POST_UNINSTALL_SCRIPT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/RPM/rpm_postun" )
 
 include ( CPack )
+
+endif()
diff --git a/projects/roctracer/build_static.sh b/projects/roctracer/build_static.sh
new file mode 100755
index 0000000000..938df3ce99
--- /dev/null
+++ b/projects/roctracer/build_static.sh
@@ -0,0 +1,48 @@
+#!/bin/bash -x
+SRC_DIR=`dirname $0`
+COMPONENT="roctracer"
+ROCM_PATH="${ROCM_PATH:=/opt/rocm}"
+LD_RUNPATH_FLAG=" -Wl,--enable-new-dtags -Wl,--rpath,$ROCM_PATH/lib:$ROCM_PATH/lib64"
+DEFAULTS=defaults.sh
+
+fatal() {
+  echo "$1"
+  exit 1
+}
+
+umask 022
+
+if [ -e "$DEFAULTS" ] ; then source "$DEFAULTS"; fi
+
+if [ -z "$ROCTRACER_ROOT" ]; then ROCTRACER_ROOT=$SRC_DIR; fi
+if [ -z "$BUILD_DIR" ] ; then BUILD_DIR=$PWD; fi
+if [ -z "$HIP_PATH" ] ; then export HIP_PATH="$ROCM_PATH/hip"; fi
+if [ -z "$HCC_HOME" ] ; then export HCC_HOME="$ROCM_PATH/hcc"; fi
+if [ -z "$BUILD_TYPE" ] ; then BUILD_TYPE="release"; fi
+if [ -z "$PACKAGE_ROOT" ] ; then PACKAGE_ROOT=$ROCM_PATH; fi
+if [ -z "$PACKAGE_PREFIX" ] ; then PACKAGE_PREFIX="$ROCM_PATH/$COMPONENT"; fi
+if [ -z "$PREFIX_PATH" ] ; then PREFIX_PATH=$PACKAGE_ROOT; fi
+if [ -z "$HIP_VDI" ] ; then HIP_VDI=0; fi
+if [ -z "$HIP_API_STRING" ] ; then HIP_API_STRING=1; fi
+if [ -n "$ROCM_RPATH" ] ; then LD_RUNPATH_FLAG=" -Wl,--enable-new-dtags -Wl,--rpath,${ROCM_RPATH}"; fi
+
+ROCTRACER_ROOT=$(cd $ROCTRACER_ROOT && echo $PWD)
+
+if [ "$TO_CLEAN" = "yes" ] ; then rm -rf $BUILD_DIR; fi
+mkdir -p $BUILD_DIR
+pushd $BUILD_DIR
+
+cmake \
+    -DCMAKE_MODULE_PATH=$ROCTRACER_ROOT/cmake_modules \
+    -DCMAKE_BUILD_TYPE=$BUILD_TYPE \
+    -DCMAKE_PREFIX_PATH="$PREFIX_PATH" \
+    -DCMAKE_INSTALL_PREFIX=$PACKAGE_ROOT \
+    -DCMAKE_SHARED_LINKER_FLAGS="$LD_RUNPATH_FLAG" \
+    -DHIP_VDI="$HIP_VDI" \
+    -DHIP_API_STRING="$HIP_API_STRING" \
+    -DLIBRARY_TYPE=STATIC \
+    $ROCTRACER_ROOT
+
+make
+
+exit 0
diff --git a/projects/roctracer/cmake_modules/env.cmake b/projects/roctracer/cmake_modules/env.cmake
index edeb17f069..8dbf2c9ccf 100644
--- a/projects/roctracer/cmake_modules/env.cmake
+++ b/projects/roctracer/cmake_modules/env.cmake
@@ -65,6 +65,13 @@ if ( DEFINED ENV{CMAKE_DEBUG_TRACE} )
   add_definitions ( -DDEBUG_TRACE=1 )
 endif()
 
+if ( NOT DEFINED LIBRARY_TYPE )
+  set ( LIBRARY_TYPE SHARED )
+endif()
+if ( ${LIBRARY_TYPE} STREQUAL STATIC )
+  add_definitions ( -DSTATIC_BUILD=1 )
+endif()
+
 if ( NOT DEFINED HIP_API_STRING )
   set ( HIP_API_STRING 1 )
 endif()
@@ -169,6 +176,7 @@ message ( "-------------HIP-VDI: ${HIP_VDI}" )
 message ( "-----CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS}" )
 message ( "---CMAKE_PREFIX_PATH: ${CMAKE_PREFIX_PATH}" )
 message ( "---------GPU_TARGETS: ${GPU_TARGETS}" )
+message ( "--------LIBRARY_TYPE: ${LIBRARY_TYPE}" )
 
 ## Check the ROCm pathes
 if ( "${HSA_RUNTIME_INC_PATH}" STREQUAL "" )
diff --git a/projects/roctracer/src/CMakeLists.txt b/projects/roctracer/src/CMakeLists.txt
index a14ecebc3d..ceb33c7497 100644
--- a/projects/roctracer/src/CMakeLists.txt
+++ b/projects/roctracer/src/CMakeLists.txt
@@ -9,7 +9,7 @@ set ( LIB_SRC
   ${LIB_DIR}/proxy/intercept_queue.cpp
   ${LIB_DIR}/util/hsa_rsrc_factory.cpp
 )
-add_library ( ${TARGET_LIB} SHARED ${LIB_SRC} )
+add_library ( ${TARGET_LIB} ${LIBRARY_TYPE} ${LIB_SRC} )
 target_include_directories ( ${TARGET_LIB} PRIVATE ${LIB_DIR} ${ROOT_DIR} ${ROOT_DIR}/inc ${HSA_RUNTIME_INC_PATH} ${HSA_RUNTIME_HSA_INC_PATH} ${HIP_INC_DIR} ${HCC_INC_DIR} ${HSA_KMT_INC_PATH} )
 target_link_libraries( ${TARGET_LIB} PRIVATE ${HSA_RUNTIME_LIB} c stdc++ )
 
diff --git a/projects/roctracer/src/core/loader.h b/projects/roctracer/src/core/loader.h
index d73bc383a6..5d6e0d6cf2 100644
--- a/projects/roctracer/src/core/loader.h
+++ b/projects/roctracer/src/core/loader.h
@@ -105,6 +105,70 @@ class RocpApi {
 };
 
 // HIP runtime library loader class
+#if STATIC_BUILD
+__attribute__((weak)) hipError_t hipRegisterApiCallback(uint32_t id, void* fun, void* arg) { return hipErrorUnknown; }
+__attribute__((weak)) hipError_t hipRemoveApiCallback(uint32_t id) { return hipErrorUnknown; }
+__attribute__((weak)) hipError_t hipRegisterActivityCallback(uint32_t id, void* fun, void* arg) { return hipErrorUnknown; }
+__attribute__((weak)) hipError_t hipRemoveActivityCallback(uint32_t id) { return hipErrorUnknown; }
+__attribute__((weak)) const char* hipKernelNameRef(const hipFunction_t f) { return NULL; }
+__attribute__((weak)) const char* hipKernelNameRefByPtr(const void* hostFunction, hipStream_t stream) { return NULL; }
+__attribute__((weak)) int hipGetStreamDeviceId(hipStream_t stream) { return 0; }
+__attribute__((weak)) const char* hipApiName(uint32_t id) { return NULL; }
+
+class HipLoaderStatic {
+  public:
+  typedef std::mutex mutex_t;
+  typedef HipLoaderStatic loader_t;
+  typedef std::atomic<loader_t*> instance_t;
+
+  typedef hipError_t (RegisterApiCallback_t)(uint32_t id, void* fun, void* arg);
+  typedef hipError_t (RemoveApiCallback_t)(uint32_t id);
+  typedef hipError_t (RegisterActivityCallback_t)(uint32_t id, void* fun, void* arg);
+  typedef hipError_t (RemoveActivityCallback_t)(uint32_t id);
+  typedef const char* (KernelNameRef_t)(const hipFunction_t f);
+  typedef const char* (KernelNameRefByPtr_t)(const void* hostFunction, hipStream_t stream);
+  typedef int (GetStreamDeviceId_t)(hipStream_t stream);
+  typedef const char* (ApiName_t)(uint32_t id);
+
+  RegisterApiCallback_t* RegisterApiCallback;
+  RemoveApiCallback_t* RemoveApiCallback;
+  RegisterActivityCallback_t* RegisterActivityCallback;
+  RemoveActivityCallback_t* RemoveActivityCallback;
+  KernelNameRef_t* KernelNameRef;
+  KernelNameRefByPtr_t* KernelNameRefByPtr;
+  GetStreamDeviceId_t* GetStreamDeviceId;
+  ApiName_t* ApiName;
+
+  static inline loader_t& Instance() {
+    loader_t* obj = instance_.load(std::memory_order_acquire);
+    if (obj == NULL) {
+      std::lock_guard<mutex_t> lck(mutex_);
+      if (instance_.load(std::memory_order_relaxed) == NULL) {
+        obj = new loader_t();
+        instance_.store(obj, std::memory_order_release);
+      }
+    }
+    return *instance_;
+  }
+
+  bool Enabled() const { return true; }
+
+  private:
+  HipLoaderStatic() {
+    RegisterApiCallback = hipRegisterApiCallback;
+    RemoveApiCallback = hipRemoveApiCallback;
+    RegisterActivityCallback = hipRegisterActivityCallback;
+    RemoveActivityCallback = hipRemoveActivityCallback;
+    KernelNameRef = hipKernelNameRef;
+    KernelNameRefByPtr = hipKernelNameRefByPtr;
+    GetStreamDeviceId =  hipGetStreamDeviceId;
+    ApiName = hipApiName;
+  }
+
+  static mutex_t mutex_;
+  static instance_t instance_;
+};
+#else
 class HipApi {
   public:
   typedef BaseLoader<HipApi> Loader;
@@ -139,6 +203,7 @@ class HipApi {
     ApiName = loader->GetFun<ApiName_t>("hipApiName");
   }
 };
+#endif
 
 // HCC runtime library loader class
 #include "inc/roctracer_hcc.h"
@@ -205,32 +270,48 @@ class RocTxApi {
 };
 
 typedef BaseLoader<RocpApi> RocpLoader;
-typedef BaseLoader<HipApi> HipLoader;
 typedef BaseLoader<HccApi> HccLoader;
 typedef BaseLoader<KfdApi> KfdLoader;
 typedef BaseLoader<RocTxApi> RocTxLoader;
 
+#if STATIC_BUILD
+typedef HipLoaderStatic HipLoader;
+#else
+typedef BaseLoader<HipApi> HipLoaderShared;
+typedef HipLoaderShared HipLoader;
+#endif
+
 } // namespace roctracer
 
-#define LOADER_INSTANTIATE2(HIP_LIB, HCC_LIB) \
+#define LOADER_INSTANTIATE_2() \
   template<class T> typename roctracer::BaseLoader<T>::mutex_t roctracer::BaseLoader<T>::mutex_; \
   template<class T> std::atomic<roctracer::BaseLoader<T>*> roctracer::BaseLoader<T>::instance_{}; \
   template<class T> bool roctracer::BaseLoader<T>::to_load_ = false; \
   template<class T> bool roctracer::BaseLoader<T>::to_check_open_ = true; \
   template<class T> bool roctracer::BaseLoader<T>::to_check_symb_ = true; \
   template<> const char* roctracer::RocpLoader::lib_name_ = "librocprofiler64.so"; \
-  template<> const char* roctracer::HipLoader::lib_name_ = HIP_LIB; \
-  template<> bool roctracer::HipLoader::to_check_open_ = false; \
-  template<> const char* roctracer::HccLoader::lib_name_ = HCC_LIB; \
+  template<> const char* roctracer::HccLoader::lib_name_ = "libamdhip64.so"; \
   template<> bool roctracer::HccLoader::to_check_open_ = false; \
   template<> const char* roctracer::KfdLoader::lib_name_ = "libkfdwrapper64.so"; \
   template<> const char* roctracer::RocTxLoader::lib_name_ = "libroctx64.so"; \
   template<> bool roctracer::RocTxLoader::to_load_ = true;
 
-#if HIP_VDI
-#define LOADER_INSTANTIATE() LOADER_INSTANTIATE2("libamdhip64.so", "libamdhip64.so");
+#if STATIC_BUILD
+#define LOADER_INSTANTIATE_HIP() \
+  roctracer::HipLoaderStatic::mutex_t roctracer::HipLoaderStatic::mutex_; \
+  roctracer::HipLoaderStatic::instance_t roctracer::HipLoaderStatic::instance_{};
 #else
-#define LOADER_INSTANTIATE() LOADER_INSTANTIATE2("libhip_hcc.so", "libmcwamp.so");
+#define LOADER_INSTANTIATE_HIP() \
+  template<> const char* roctracer::HipLoaderShared::lib_name_ = "libamdhip64.so"; \
+  template<> bool roctracer::HipLoaderShared::to_check_open_ = false;
+#endif
+
+#if HIP_VDI
+#define LOADER_INSTANTIATE() \
+  LOADER_INSTANTIATE_2(); \
+  LOADER_INSTANTIATE_HIP();
+#else
+#error HCC support dropped
 #endif
 
 #endif // SRC_CORE_LOADER_H_