diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0711823d..15486979 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,136 +1,273 @@
+# jetson-utils -- CMakeLists.txt
+cmake_minimum_required(VERSION 3.5)
 
-cmake_minimum_required(VERSION 2.8)
+# CMP0048: The project() command manages VERSION variables
+# @ref https://cmake.org/cmake/help/latest/policy/CMP0048.html
+cmake_policy(SET CMP0048 NEW)
 
-# determine if jetson-utils is being built as a submodule inside another repo,
-# or if it's being build standalone (if the later, we need to do some configuration)
-get_directory_property(hasParent PARENT_DIRECTORY)
+# CMP0028: Double colon in target name means ALIAS or IMPORTED target
+# @ref https://cmake.org/cmake/help/latest/policy/CMP0028.html
+cmake_policy(SET CMP0028 NEW)
 
-if(hasParent)
-	message("-- jetson-utils:  building as submodule, ${hasParent}")
-else()
-	message("-- jetson-utils:  building as standalone")
-	
-	# standalone project
-	project(jetson-utils)
-  
-	# -std=gnu++11
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wno-write-strings")	
-  
-	# setup CUDA
-	set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cuda")
-	find_package(CUDA)
-	message("-- CUDA version: ${CUDA_VERSION}")
-
-	set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS}; -O3)
-
-	if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
-		message("-- CUDA ${CUDA_VERSION} detected (${CMAKE_SYSTEM_PROCESSOR}), enabling SM_53 SM_62")
-		set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS}; -gencode arch=compute_53,code=sm_53 -gencode arch=compute_62,code=sm_62)
-
-		if(CUDA_VERSION_MAJOR GREATER 9)
-			message("-- CUDA ${CUDA_VERSION} detected (${CMAKE_SYSTEM_PROCESSOR}), enabling SM_72")
-			set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS}; -gencode arch=compute_72,code=sm_72)
-		endif()
-
-		if(CUDA_VERSION_MAJOR GREATER 10)
-			message("-- CUDA ${CUDA_VERSION} detected (${CMAKE_SYSTEM_PROCESSOR}), enabling SM_87")
-			set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS}; -gencode arch=compute_87,code=sm_87)
-		endif()
-	endif()
-	
-	# setup project output paths
-	set(PROJECT_OUTPUT_DIR  ${PROJECT_BINARY_DIR}/${CMAKE_SYSTEM_PROCESSOR})
-	set(PROJECT_INCLUDE_DIR ${PROJECT_OUTPUT_DIR}/include)
-
-	file(MAKE_DIRECTORY ${PROJECT_INCLUDE_DIR})
-	file(MAKE_DIRECTORY ${PROJECT_OUTPUT_DIR}/bin)
-
-	message("-- system arch:  ${CMAKE_SYSTEM_PROCESSOR}")
-	message("-- output path:  ${PROJECT_OUTPUT_DIR}")
-
-	set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_OUTPUT_DIR}/bin)
-	set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_OUTPUT_DIR}/lib)
-	set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_OUTPUT_DIR}/lib)
-	
-	# detect distro version
-	find_program(LSB_RELEASE_EXEC lsb_release)
-
-	execute_process(COMMAND "${LSB_RELEASE_EXEC}" --short --id OUTPUT_VARIABLE LSB_RELEASE_ID OUTPUT_STRIP_TRAILING_WHITESPACE)
-	execute_process(COMMAND "${LSB_RELEASE_EXEC}" --short --release OUTPUT_VARIABLE LSB_RELEASE_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE)
-	execute_process(COMMAND "${LSB_RELEASE_EXEC}" --short --codename OUTPUT_VARIABLE LSB_RELEASE_CODENAME OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-	message("-- distro ID:       ${LSB_RELEASE_ID}")
-	message("-- distro version:  ${LSB_RELEASE_VERSION}")
-	message("-- distro codename: ${LSB_RELEASE_CODENAME}")
-
-	# build C/C++ interface
-	include_directories(${PROJECT_INCLUDE_DIR})
-	#include_directories(/usr/include/gstreamer-1.0 /usr/lib/aarch64-linux-gnu/gstreamer-1.0/include /usr/include/glib-2.0 /usr/include/libxml2 /usr/lib/aarch64-linux-gnu/glib-2.0/include/)
-
-endif()
-
-# option for enabling/disabling NVMM memory in multimedia stack
-find_library(NVBUF_UTILS NAMES nvbuf_utils PATHS /usr/lib/aarch64-linux-gnu/tegra)
-message("-- nvbuf_utils:  ${NVBUF_UTILS}")
-
-if(NVBUF_UTILS)
-	set(ENABLE_NVMM_DEFAULT ON)
+# Set name of the project
+# @ref https://cmake.org/cmake/help/latest/command/project.html
+project(jetson-utils LANGUAGES CXX VERSION 1.0.0)
+
+# Include "GNUInstallDirs" module which defines GNU standard installation directories
+# @ref https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html
+include(GNUInstallDirs)
+
+# Include "CMakePackageConfigHelpers" module which creates package config files for "find_package" command
+# @ref https://cmake.org/cmake/help/latest/module/CMakePackageConfigHelpers.html
+include(CMakePackageConfigHelpers)
+
+# Include "CheckCXXCompilerFlag" module which checks if the CXX compiler supports a given flag
+# @ref https://cmake.org/cmake/help/latest/module/CheckCXXCompilerFlag.html
+include(CheckCXXCompilerFlag)
+
+# Disable "ISO C++ forbids converting a string constant to ‘char*’" warnings
+# @ref https://stackoverflow.com/a/67299165
+check_cxx_compiler_flag(-Wwrite-strings HAVE_WRITE_STRINGS)
+
+# Define PROJECT_IS_TOP_LEVEL variable if necessary
+# @ref https://www.scivision.dev/cmake-project-is-top-level/
+if(CMAKE_VERSION VERSION_LESS 3.21)
+  get_property(not_top DIRECTORY PROPERTY PARENT_DIRECTORY)
+  if(NOT not_top)
+    set(PROJECT_IS_TOP_LEVEL true)
+  endif()
+endif()
+
+# Set CMake module path
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_LIST_DIR}/cmake)
+
+# Set install directory
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX /usr/local)
+endif()
+message(STATUS "jetson-utils: install directory  ${CMAKE_INSTALL_PREFIX}")
+
+# Detect distro version
+find_program(LSB_RELEASE_EXEC lsb_release /usr/bin)
+
+if(NOT DEFINED LSB_RELEASE_EXEC)
+  message(FATAL_ERROR "-- jetson-utils: Cannot find 'lsb_release' executable. Please install it via 'apt install lsb_release'.")
+endif()
+
+execute_process(COMMAND "${LSB_RELEASE_EXEC}" --short --id OUTPUT_VARIABLE LSB_RELEASE_ID OUTPUT_STRIP_TRAILING_WHITESPACE)
+execute_process(COMMAND "${LSB_RELEASE_EXEC}" --short --release OUTPUT_VARIABLE LSB_RELEASE_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE)
+execute_process(COMMAND "${LSB_RELEASE_EXEC}" --short --codename OUTPUT_VARIABLE LSB_RELEASE_CODENAME OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+message(STATUS "jetson-utils: distro ID       ${LSB_RELEASE_ID}")
+message(STATUS "jetson-utils: distro version  ${LSB_RELEASE_VERSION}")
+message(STATUS "jetson-utils: distro codename ${LSB_RELEASE_CODENAME}")
+
+# Use C++11 standard if no standard defined
+if(NOT DEFINED CMAKE_CXX_STANDARD)
+  set(CMAKE_CXX_STANDARD 11)
+  set(CMAKE_CXX_STANDARD_REQUIRED ON)
+  set(CMAKE_CXX_EXTENSIONS OFF)
+endif()
+message(STATUS "jetson-utils: using C++ standard ${CMAKE_CXX_STANDARD}")
+
+# CMP0072: FindOpenGL prefers GLVND by default when available
+# @ref https://cmake.org/cmake/help/latest/policy/CMP0072.html
+if(POLICY CMP0072)
+  # TODO: test it with "NEW"
+  cmake_policy(SET CMP0072 OLD)
+endif()
+
+# Setup CUDA
+find_package(CUDA)
+message(STATUS "jetson-utils: CUDA version  ${CUDA_VERSION}")
+
+set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS}; -O3)
+
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
+    message(STATUS "jetson-utils: CUDA ${CUDA_VERSION} detected (${CMAKE_SYSTEM_PROCESSOR}), enabling SM_53 SM_62")
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS}; -gencode arch=compute_53,code=sm_53 -gencode arch=compute_62,code=sm_62)
+
+    if(CUDA_VERSION_MAJOR GREATER 9)
+      message(STATUS "jetson-utils: CUDA ${CUDA_VERSION} detected (${CMAKE_SYSTEM_PROCESSOR}), enabling SM_72")
+      set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS}; -gencode arch=compute_72,code=sm_72)
+    endif()
+
+    if(CUDA_VERSION_MAJOR GREATER 10)
+      message(STATUS "jetson-utils: CUDA ${CUDA_VERSION} detected (${CMAKE_SYSTEM_PROCESSOR}), enabling SM_87")
+      set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS}; -gencode arch=compute_87,code=sm_87)
+    endif()
+endif()
+
+# Option for enabling/disabling NVMM memory in multimedia stack
+find_package(NVBUF_UTILS REQUIRED)
+if(NVBUF_UTILS_FOUND)
+  set(ENABLE_NVMM_DEFAULT ON)
 else()
-	set(ENABLE_NVMM_DEFAULT OFF)
+  set(ENABLE_NVMM_DEFAULT OFF)
 endif()
 
 option(ENABLE_NVMM "Enable use of NVMM zero-copy memory in video and camera streaming" ${ENABLE_NVMM_DEFAULT})
-message("-- NVMM zero-copy memory:  ENABLE_NVMM=${ENABLE_NVMM}")
+message(STATUS "jetson-utils: Enable NVMM zero-copy memory (ENABLE_NVMM): ${ENABLE_NVMM}")
 
 if(ENABLE_NVMM)
-	add_definitions(-DENABLE_NVMM)
+  add_definitions(-DENABLE_NVMM)
 endif()
 
-# additional paths for includes and libraries
-include_directories(${PROJECT_INCLUDE_DIR}/jetson-utils)
-include_directories(/usr/include/gstreamer-1.0 /usr/include/glib-2.0 /usr/include/libxml2 /usr/include/json-glib-1.0 /usr/include/libsoup-2.4 /usr/lib/${CMAKE_SYSTEM_PROCESSOR}-linux-gnu/gstreamer-1.0/include /usr/lib/${CMAKE_SYSTEM_PROCESSOR}-linux-gnu/glib-2.0/include/)
+# Find OpenGL and related packages
+find_package(OpenGL REQUIRED)
+find_package(GLEW REQUIRED)
 
-if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
-	include_directories(/usr/src/jetson_multimedia_api/include)
-	link_directories(/usr/lib/aarch64-linux-gnu/tegra)
-endif()
+# Find other dependent packages
+find_package(PkgConfig REQUIRED)
+pkg_search_module(GLIB REQUIRED IMPORTED_TARGET glib-2.0)
+pkg_check_modules(GSTREAMER REQUIRED IMPORTED_TARGET gstreamer-1.0)
+pkg_check_modules(GSTREAMER_APP REQUIRED IMPORTED_TARGET gstreamer-app-1.0)
+pkg_check_modules(GSTREAMER_VIDEO REQUIRED IMPORTED_TARGET gstreamer-video-1.0)
+pkg_check_modules(GSTREAMER_PBUTILS REQUIRED IMPORTED_TARGET gstreamer-pbutils-1.0)
+pkg_check_modules(GSTREAMER_WEBRTC REQUIRED IMPORTED_TARGET gstreamer-webrtc-1.0)
+pkg_check_modules(GSTREAMER_SDP REQUIRED IMPORTED_TARGET gstreamer-sdp-1.0)
+pkg_check_modules(GSTREAMER_RTSP_SERVER REQUIRED IMPORTED_TARGET gstreamer-rtsp-server-1.0)
+pkg_check_modules(JSON_GLIB REQUIRED IMPORTED_TARGET json-glib-1.0)
+pkg_check_modules(SOUP REQUIRED IMPORTED_TARGET libsoup-2.4)
 
-# build library
+# Setup source and header files
 file(GLOB jetsonUtilitySources *.cpp camera/*.cpp codec/*.cpp cuda/*.cu cuda/*.cpp display/*.cpp image/*.cpp input/*.cpp network/*.cpp threads/*.cpp video/*.cpp)
 file(GLOB jetsonUtilityIncludes *.h *.hpp camera/*.h codec/*.h cuda/*.h cuda/*.cuh display/*.h image/*.h image/*.inl input/*.h network/*.h threads/*.h threads/*.inl video/*.h)
 
-cuda_add_library(jetson-utils SHARED ${jetsonUtilitySources})
-target_link_libraries(jetson-utils GL GLU GLEW gstreamer-1.0 gstapp-1.0 gstpbutils-1.0 gstwebrtc-1.0 gstsdp-1.0 gstrtspserver-1.0 json-glib-1.0 soup-2.4 ${CUDA_nppicc_LIBRARY})	
+# Copy all headers to the include directory
+file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/include/${PROJECT_NAME})
+foreach(include ${jetsonUtilityIncludes})
+    message(STATUS "Copying ${include}")
+    configure_file(${include} ${PROJECT_BINARY_DIR}/include/jetson-utils COPYONLY)
+endforeach()
 
-if(NVBUF_UTILS)
-	target_link_libraries(jetson-utils nvbuf_utils)
+# Create the library
+cuda_add_library(${PROJECT_NAME} SHARED ${jetsonUtilitySources} ${jetsonUtilityIncludes})
+target_link_libraries(${PROJECT_NAME}
+  GLEW::GLEW
+  OpenGL::GL
+  OpenGL::GLU
+  PkgConfig::GLIB
+  PkgConfig::GSTREAMER
+  PkgConfig::GSTREAMER_APP
+  PkgConfig::GSTREAMER_PBUTILS
+  PkgConfig::GSTREAMER_WEBRTC
+  PkgConfig::GSTREAMER_SDP
+  PkgConfig::GSTREAMER_RTSP_SERVER
+  PkgConfig::JSON_GLIB
+  PkgConfig::SOUP
+  ${CUDA_nppicc_LIBRARY}
+)
+
+if(NVBUF_UTILS_FOUND)
+    target_link_libraries(${PROJECT_NAME} ${NVBUF_UTILS_LIBRARY})
 endif()
 
-# transfer all headers to the include directory 
-file(MAKE_DIRECTORY ${PROJECT_INCLUDE_DIR}/jetson-utils)
+target_include_directories(${PROJECT_NAME}
+  PUBLIC
+    $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include/${PROJECT_NAME}>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}>
+)
+set_target_properties(${PROJECT_NAME}
+  PROPERTIES
+    PUBLIC_HEADER "${jetsonUtilityIncludes}"
+)
 
-foreach(include ${jetsonUtilityIncludes})
-	message("-- Copying ${include}")
-	configure_file(${include} ${PROJECT_INCLUDE_DIR}/jetson-utils COPYONLY)
-endforeach()
-	
-# install headers
-foreach(include ${jetsonUtilityIncludes})
-	install(FILES "${include}" DESTINATION include/jetson-utils)
-endforeach()
+# Install the library and headers while exporting the targets
+install(TARGETS ${PROJECT_NAME}
+  EXPORT ${PROJECT_NAME}Targets
+  PUBLIC_HEADER
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}
+  LIBRARY
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}
+)
 
-# install the shared library
-install(TARGETS jetson-utils DESTINATION lib EXPORT jetson-utilsConfig)
+# Install exported targets with a namespace
+install(EXPORT ${PROJECT_NAME}Targets
+  FILE ${PROJECT_NAME}Targets.cmake
+  NAMESPACE "JetsonUtils::"
+  DESTINATION
+    ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}-${PROJECT_VERSION}
+)
 
-# install the cmake project, for importing
-install(EXPORT jetson-utilsConfig DESTINATION share/jetson-utils/cmake)
+# Configure package config files using a template
+configure_package_config_file(
+  ${CMAKE_CURRENT_LIST_DIR}/cmake/${PROJECT_NAME}Config.cmake.in
+  ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
+  INSTALL_DESTINATION
+    ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}-${PROJECT_VERSION}
+)
 
-# build python bindings + samples
-add_subdirectory(python)
-add_subdirectory(video/video-viewer)
+# Generate package config files
+write_basic_package_version_file(
+  ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
+  VERSION ${PROJECT_VERSION}
+  COMPATIBILITY SameMajorVersion
+)
 
-#add_subdirectory(camera/camera-viewer)
-#add_subdirectory(display/gl-display-test)
-#add_subdirectory(network/webrtc-server)
-#add_subdirectory(network/rtsp-server)
+# Install package config files
+install(
+  FILES
+    ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
+  DESTINATION
+    ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}-${PROJECT_VERSION}
+)
+
+# Enable/disable python bindings
+set(JU_ENABLE_PYTHON_BINDINGS ON CACHE BOOL "Enable jetson-utils python bindings")
+if(${JU_ENABLE_PYTHON_BINDINGS})
+  add_subdirectory(python)
+endif()
 
+# Enable/disable apps
+set(JU_ENABLE_CAMERA_VIEWER OFF CACHE BOOL "Enable jetson-utils camera viewer app")
+if(${JU_ENABLE_CAMERA_VIEWER})
+  add_subdirectory(camera/camera-viewer)
+endif()
+
+set(JU_ENABLE_V4L2_DISPLAY OFF CACHE BOOL "Enable jetson-utils v4l2 display app")
+if(${JU_ENABLE_V4L2_DISPLAY})
+  add_subdirectory(camera/v4l2-display)
+endif()
+
+set(JU_ENABLE_V4L2_CONSOLE OFF CACHE BOOL "Enable jetson-utils v4l2 console app")
+if(${JU_ENABLE_V4L2_CONSOLE})
+  add_subdirectory(camera/v4l2-console)
+endif()
+
+set(JU_ENABLE_VIDEO_VIEWER OFF CACHE BOOL "Enable jetson-utils video viewer app")
+if(${JU_ENABLE_VIDEO_VIEWER})
+  add_subdirectory(video/video-viewer)
+endif()
+
+set(JU_ENABLE_GL_DISPLAY_TEST OFF CACHE BOOL "Enable jetson-utils gl display test app")
+if(${JU_ENABLE_GL_DISPLAY_TEST})
+  add_subdirectory(display/gl-display-test)
+endif()
+
+set(JU_ENABLE_WEBRTC_SERVER OFF CACHE BOOL "Enable jetson-utils webrtc server app")
+if(${JU_ENABLE_WEBRTC_SERVER})
+  add_subdirectory(network/webrtc-server)
+endif()
+
+set(JU_ENABLE_RTSP_SERVER OFF CACHE BOOL "Enable jetson-utils rtsp server app")
+if(${JU_ENABLE_RTSP_SERVER})
+  add_subdirectory(network/rtsp-server)
+endif()
+
+# Add uninstall target only if this project is the topmost level
+# @ref https://gitlab.kitware.com/cmake/community/-/wikis/FAQ#can-i-do-make-uninstall-with-cmake
+if(PROJECT_IS_TOP_LEVEL)
+  if(NOT TARGET uninstall)
+    configure_file(
+      "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
+      "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
+      IMMEDIATE @ONLY
+    )
+
+    add_custom_target(uninstall
+      COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
+    )
+  endif()
+endif()
diff --git a/camera/camera-viewer/CMakeLists.txt b/camera/camera-viewer/CMakeLists.txt
index aa644360..685af923 100644
--- a/camera/camera-viewer/CMakeLists.txt
+++ b/camera/camera-viewer/CMakeLists.txt
@@ -1,8 +1,32 @@
+# jetson-utils::camera-viewer -- CMakeLists.txt
+cmake_minimum_required(VERSION 3.5)
 
+# CMP0048: The project() command manages VERSION variables
+cmake_policy(SET CMP0048 NEW)
+
+# CMP0028: Double colon in target name means ALIAS or IMPORTED target
+cmake_policy(SET CMP0028 NEW)
+
+# Set name of the project
+project(camera-viewer LANGUAGES CXX VERSION 1.0.0)
+
+# Find source and header files
 file(GLOB gstCameraSources *.cpp)
 file(GLOB gstCameraIncludes *.h )
 
-add_executable(camera-viewer ${gstCameraSources})
-target_link_libraries(camera-viewer jetson-utils)
+# Create the executable
+add_executable(${PROJECT_NAME} ${gstCameraSources} ${gstCameraIncludes})
+target_link_libraries(${PROJECT_NAME}
+  jetson-utils
+)
+set_target_properties(${PROJECT_NAME}
+  PROPERTIES
+    INSTALL_RPATH_USE_LINK_PATH TRUE
+    INSTALL_RPATH "$ORIGIN:$ORIGIN/../:$ORIGIN/../lib"
+)
 
-install(TARGETS camera-viewer DESTINATION bin)
+# Install the executable
+install(TARGETS ${PROJECT_NAME}
+  DESTINATION
+    ${CMAKE_INSTALL_BINDIR}
+)
diff --git a/camera/v4l2-console/CMakeLists.txt b/camera/v4l2-console/CMakeLists.txt
index c9601897..82921ef0 100644
--- a/camera/v4l2-console/CMakeLists.txt
+++ b/camera/v4l2-console/CMakeLists.txt
@@ -1,6 +1,32 @@
+# jetson-utils::v4l2-console -- CMakeLists.txt
+cmake_minimum_required(VERSION 3.5)
 
+# CMP0048: The project() command manages VERSION variables
+cmake_policy(SET CMP0048 NEW)
+
+# CMP0028: Double colon in target name means ALIAS or IMPORTED target
+cmake_policy(SET CMP0028 NEW)
+
+# Set name of the project
+project(v4l2-console LANGUAGES CXX VERSION 1.0.0)
+
+# Find source and header files
 file(GLOB v4l2ConsoleSources *.cpp)
 file(GLOB v4l2ConsoleIncludes *.h )
 
-add_executable(v4l2-console ${v4l2ConsoleSources})
-target_link_libraries(v4l2-console jetson-utils)
+# Create the executable
+add_executable(${PROJECT_NAME} ${v4l2ConsoleSources} ${v4l2ConsoleIncludes})
+target_link_libraries(${PROJECT_NAME}
+  jetson-utils
+)
+set_target_properties(${PROJECT_NAME}
+  PROPERTIES
+    INSTALL_RPATH_USE_LINK_PATH TRUE
+    INSTALL_RPATH "$ORIGIN:$ORIGIN/../:$ORIGIN/../lib"
+)
+
+# Install the executable
+install(TARGETS ${PROJECT_NAME}
+  DESTINATION
+    ${CMAKE_INSTALL_BINDIR}
+)
diff --git a/camera/v4l2-display/CMakeLists.txt b/camera/v4l2-display/CMakeLists.txt
index edc9492f..05f33ee5 100644
--- a/camera/v4l2-display/CMakeLists.txt
+++ b/camera/v4l2-display/CMakeLists.txt
@@ -1,6 +1,32 @@
+# jetson-utils::v4l2-display -- CMakeLists.txt
+cmake_minimum_required(VERSION 3.5)
 
+# CMP0048: The project() command manages VERSION variables
+cmake_policy(SET CMP0048 NEW)
+
+# CMP0028: Double colon in target name means ALIAS or IMPORTED target
+cmake_policy(SET CMP0028 NEW)
+
+# Set name of the project
+project(v4l2-display LANGUAGES CXX VERSION 1.0.0)
+
+# Find source and header files
 file(GLOB v4l2DisplaySources *.cpp)
 file(GLOB v4l2DisplayIncludes *.h )
 
-add_executable(v4l2-display ${v4l2DisplaySources})
-target_link_libraries(v4l2-display jetson-utils)
+# Create the executable
+add_executable(${PROJECT_NAME} ${v4l2DisplaySources} ${v4l2DisplayIncludes})
+target_link_libraries(${PROJECT_NAME}
+  jetson-utils
+)
+set_target_properties(${PROJECT_NAME}
+  PROPERTIES
+    INSTALL_RPATH_USE_LINK_PATH TRUE
+    INSTALL_RPATH "$ORIGIN:$ORIGIN/../:$ORIGIN/../lib"
+)
+
+# Install the executable
+install(TARGETS ${PROJECT_NAME}
+  DESTINATION
+    ${CMAKE_INSTALL_BINDIR}
+)
diff --git a/cuda/FindCUDA.cmake b/cmake/FindCUDA.cmake
similarity index 99%
rename from cuda/FindCUDA.cmake
rename to cmake/FindCUDA.cmake
index a1c5795f..15ed5acc 100644
--- a/cuda/FindCUDA.cmake
+++ b/cmake/FindCUDA.cmake
@@ -405,7 +405,7 @@
 ###############################################################################
 
 # FindCUDA.cmake
-message("-- using patched FindCUDA.cmake")
+message(STATUS "jetson-utils: using patched FindCUDA.cmake")
 
 # This macro helps us find the location of helper files we will need the full path to
 macro(CUDA_FIND_HELPER_FILE _name _extension)
diff --git a/cuda/FindCUDA/make2cmake.cmake b/cmake/FindCUDA/make2cmake.cmake
similarity index 100%
rename from cuda/FindCUDA/make2cmake.cmake
rename to cmake/FindCUDA/make2cmake.cmake
diff --git a/cuda/FindCUDA/parse_cubin.cmake b/cmake/FindCUDA/parse_cubin.cmake
similarity index 100%
rename from cuda/FindCUDA/parse_cubin.cmake
rename to cmake/FindCUDA/parse_cubin.cmake
diff --git a/cuda/FindCUDA/run_nvcc.cmake b/cmake/FindCUDA/run_nvcc.cmake
similarity index 100%
rename from cuda/FindCUDA/run_nvcc.cmake
rename to cmake/FindCUDA/run_nvcc.cmake
diff --git a/cuda/FindCUDA/select_compute_arch.cmake b/cmake/FindCUDA/select_compute_arch.cmake
similarity index 100%
rename from cuda/FindCUDA/select_compute_arch.cmake
rename to cmake/FindCUDA/select_compute_arch.cmake
diff --git a/cmake/FindNVBUF_UTILS.cmake b/cmake/FindNVBUF_UTILS.cmake
new file mode 100644
index 00000000..c968d9e2
--- /dev/null
+++ b/cmake/FindNVBUF_UTILS.cmake
@@ -0,0 +1,34 @@
+# FindNVBUF_UTILS.cmake
+
+find_library(NVBUF_UTILS_LIBRARY
+  NAMES
+    nvbuf_utils
+  PATHS
+    /usr/lib/aarch64-linux-gnu/tegra
+)
+
+find_path(
+  NVBUF_UTILS_INCLUDE_DIR
+  NAMES
+    nvbuf_utils.h
+  PATHS
+    /usr/src/jetson_multimedia_api/include
+    ${PROJECT_SOURCE_DIR}/codec
+)
+
+if(NVBUF_UTILS_FOUND)
+  mark_as_advanced(NVBUF_UTILS_INCLUDE_DIR)
+  mark_as_advanced(NVBUF_UTILS_LIBRARY)
+endif()
+
+if(NVBUF_UTILS_FOUND AND NOT TARGET JetsonUtils::NVBUF_UTILS)
+  add_library(JetsonUtils::NVBUF_UTILS IMPORTED)
+  set_property(TARGET JetsonUtils::NVBUF_UTILS PROPERTY IMPORTED_LOCATION ${NVBUF_UTILS_LIBRARY})
+  target_include_directories(JetsonUtils::NVBUF_UTILS INTERFACE ${NVBUF_UTILS_INCLUDE_DIR})
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(NVBUF_UTILS
+  REQUIRED_VARS
+    NVBUF_UTILS_LIBRARY NVBUF_UTILS_INCLUDE_DIR
+)
diff --git a/python/bindings/FindNumPy.cmake b/cmake/FindNumPy.cmake
similarity index 100%
rename from python/bindings/FindNumPy.cmake
rename to cmake/FindNumPy.cmake
diff --git a/cmake/jetson-utilsConfig.cmake.in b/cmake/jetson-utilsConfig.cmake.in
new file mode 100644
index 00000000..318f9684
--- /dev/null
+++ b/cmake/jetson-utilsConfig.cmake.in
@@ -0,0 +1,12 @@
+# jetson-utils -- jetson-utilsConfig.cmake.in
+@PACKAGE_INIT@
+
+# Find dependencies
+include(CMakeFindDependencyMacro)
+#find_dependency(XYZ)
+
+# Include targets
+include(${CMAKE_CURRENT_LIST_DIR}/jetson-utilsTargets.cmake)
+
+# Check required components
+check_required_components(jetson-utils)
diff --git a/cmake_uninstall.cmake.in b/cmake_uninstall.cmake.in
new file mode 100644
index 00000000..929d65e0
--- /dev/null
+++ b/cmake_uninstall.cmake.in
@@ -0,0 +1,22 @@
+# @ref https://gitlab.kitware.com/cmake/community/-/wikis/FAQ#can-i-do-make-uninstall-with-cmake
+if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
+  message(FATAL_ERROR "Cannot find install manifest: @CMAKE_BINARY_DIR@/install_manifest.txt")
+endif()
+
+file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files)
+string(REGEX REPLACE "\n" ";" files "${files}")
+foreach(file ${files})
+  message(STATUS "Uninstalling $ENV{DESTDIR}${file}")
+  if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+    exec_program(
+      "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
+      OUTPUT_VARIABLE rm_out
+      RETURN_VALUE rm_retval
+      )
+    if(NOT "${rm_retval}" STREQUAL 0)
+      message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}")
+    endif()
+  else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+    message(STATUS "File $ENV{DESTDIR}${file} does not exist.")
+  endif()
+endforeach()
diff --git a/display/gl-display-test/CMakeLists.txt b/display/gl-display-test/CMakeLists.txt
index 46d4163d..7dc201fb 100644
--- a/display/gl-display-test/CMakeLists.txt
+++ b/display/gl-display-test/CMakeLists.txt
@@ -1,8 +1,32 @@
+# jetson-utils::gl-display-test -- CMakeLists.txt
+cmake_minimum_required(VERSION 3.5)
 
+# CMP0048: The project() command manages VERSION variables
+cmake_policy(SET CMP0048 NEW)
+
+# CMP0028: Double colon in target name means ALIAS or IMPORTED target
+cmake_policy(SET CMP0028 NEW)
+
+# Set name of the project
+project(gl-display-test LANGUAGES CXX VERSION 1.0.0)
+
+# Find source and header files
 file(GLOB glDisplayTestSources *.cpp *.cu)
 file(GLOB glDisplayTestIncludes *.h )
 
-cuda_add_executable(gl-display-test ${glDisplayTestSources})
-target_link_libraries(gl-display-test jetson-utils)
+# Create the executable
+cuda_add_executable(${PROJECT_NAME} ${glDisplayTestSources} ${glDisplayTestIncludes})
+target_link_libraries(${PROJECT_NAME}
+  jetson-utils
+)
+set_target_properties(${PROJECT_NAME}
+  PROPERTIES
+    INSTALL_RPATH_USE_LINK_PATH TRUE
+    INSTALL_RPATH "$ORIGIN:$ORIGIN/../:$ORIGIN/../lib"
+)
 
-install(TARGETS gl-display-test DESTINATION bin)
+# Install the executable
+install(TARGETS ${PROJECT_NAME}
+  DESTINATION
+    ${CMAKE_INSTALL_BINDIR}
+)
diff --git a/network/rtsp-server/CMakeLists.txt b/network/rtsp-server/CMakeLists.txt
index ec13aad4..d8114345 100644
--- a/network/rtsp-server/CMakeLists.txt
+++ b/network/rtsp-server/CMakeLists.txt
@@ -1,8 +1,32 @@
+# jetson-utils::rtsp-server -- CMakeLists.txt
+cmake_minimum_required(VERSION 3.5)
 
+# CMP0048: The project() command manages VERSION variables
+cmake_policy(SET CMP0048 NEW)
+
+# CMP0028: Double colon in target name means ALIAS or IMPORTED target
+cmake_policy(SET CMP0028 NEW)
+
+# Set name of the project
+project(rtsp-server LANGUAGES CXX VERSION 1.0.0)
+
+# Find source and header files
 file(GLOB rtspServerSources *.cpp)
 file(GLOB rtspServerIncludes *.h )
 
-add_executable(rtsp-server ${rtspServerSources})
-target_link_libraries(rtsp-server jetson-utils)
+# Create the executable
+add_executable(${PROJECT_NAME} ${rtspServerSources} ${rtspServerIncludes})
+target_link_libraries(${PROJECT_NAME}
+  jetson-utils
+)
+set_target_properties(${PROJECT_NAME}
+  PROPERTIES
+    INSTALL_RPATH_USE_LINK_PATH TRUE
+    INSTALL_RPATH "$ORIGIN:$ORIGIN/../:$ORIGIN/../lib"
+)
 
-install(TARGETS rtsp-server DESTINATION bin)
+# Install the executable
+install(TARGETS ${PROJECT_NAME}
+  DESTINATION
+    ${CMAKE_INSTALL_BINDIR}
+)
diff --git a/network/webrtc-server/CMakeLists.txt b/network/webrtc-server/CMakeLists.txt
index 4f3f3632..88792c2e 100644
--- a/network/webrtc-server/CMakeLists.txt
+++ b/network/webrtc-server/CMakeLists.txt
@@ -1,8 +1,32 @@
+# jetson-utils::webrtc-server -- CMakeLists.txt
+cmake_minimum_required(VERSION 3.5)
 
+# CMP0048: The project() command manages VERSION variables
+cmake_policy(SET CMP0048 NEW)
+
+# CMP0028: Double colon in target name means ALIAS or IMPORTED target
+cmake_policy(SET CMP0028 NEW)
+
+# Set name of the project
+project(webrtc-server LANGUAGES CXX VERSION 1.0.0)
+
+# Find source and header files
 file(GLOB WebRTCServerSources *.cpp)
 file(GLOB WebRTCServerIncludes *.h )
 
-add_executable(webrtc-server ${WebRTCServerSources})
-target_link_libraries(webrtc-server jetson-utils)
+# Create the executable
+add_executable(${PROJECT_NAME} ${WebRTCServerSources} ${WebRTCServerIncludes})
+target_link_libraries(${PROJECT_NAME}
+  jetson-utils
+)
+set_target_properties(${PROJECT_NAME}
+  PROPERTIES
+    INSTALL_RPATH_USE_LINK_PATH TRUE
+    INSTALL_RPATH "$ORIGIN:$ORIGIN/../:$ORIGIN/../lib"
+)
 
-install(TARGETS webrtc-server DESTINATION bin)
+# Install the executable
+install(TARGETS ${PROJECT_NAME}
+  DESTINATION
+    ${CMAKE_INSTALL_BINDIR}
+)
diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt
index 7c5ebb74..41d7d1b3 100644
--- a/python/CMakeLists.txt
+++ b/python/CMakeLists.txt
@@ -1,30 +1,49 @@
+# jetson-utils::python -- CMakeLists.txt
+cmake_minimum_required(VERSION 3.5)
 
-#
-# This list contains the versions of Python that will be detected 
-# and the bindings built against (if that version is installed).
-#
-# If you want to support another version of Python, add it here.
-#
-if(LSB_RELEASE_CODENAME MATCHES "focal")
-	set(PYTHON_BINDING_VERSIONS 3.8)
+# CMP0048: The project() command manages VERSION variables
+cmake_policy(SET CMP0048 NEW)
+
+# CMP0028: Double colon in target name means ALIAS or IMPORTED target
+cmake_policy(SET CMP0028 NEW)
+
+# Set name of the project
+project(jetson-utils-python LANGUAGES CXX VERSION 1.0.0)
+
+# Find Python versions or use the user-defined version
+if(NOT DEFINED JU_PYTHON_BINDING_VERSION)
+  if(DEFINED LSB_RELEASE_CODENAME)
+    if(LSB_RELEASE_CODENAME MATCHES "focal")
+      set(PYTHON_BINDING_VERSIONS 3.8)
+    else()
+      set(PYTHON_BINDING_VERSIONS 2.7 3.6 3.7)
+    endif()
+  endif()
+
+  if(NOT DEFINED PYTHON_BINDING_VERSIONS)
+    message(WARNING "jetson-utils: LSB_RELEASE_CODENAME is not defined. Identifying Python versions from OS default CMake version")
+    if(CMAKE_VERSION VERSION_GREATER "3.10.3")
+      set(PYTHON_BINDING_VERSIONS 3.8)
+    else()
+      set(PYTHON_BINDING_VERSIONS 2.7 3.6 3.7)
+    endif()
+  endif()
 else()
-	set(PYTHON_BINDING_VERSIONS 2.7 3.6 3.7)
+  set(PYTHON_BINDING_VERSIONS ${JU_PYTHON_BINDING_VERSION})
 endif()
 
-message("-- trying to build Python bindings for Python versions:  ${PYTHON_BINDING_VERSIONS}")
-
+# Build Python bindings
+message(STATUS "jetson-utils: Building jetson-utils bindings for Python versions:  ${PYTHON_BINDING_VERSIONS}")
 foreach(PYTHON_BINDING_VERSION ${PYTHON_BINDING_VERSIONS})
-	add_subdirectory(bindings bindings_python_${PYTHON_BINDING_VERSION})
+    add_subdirectory(bindings ${CMAKE_CURRENT_BINARY_DIR}/bindings_python_${PYTHON_BINDING_VERSION})
 endforeach()
 
+# Install Python examples
+install(DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/examples
+  DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/examples
+)
 
-#
-# install Python examples
-#
-file(GLOB pyUtilExamples examples/*.py examples/*.sh)
-
-foreach(pyExample ${pyUtilExamples})
-	message("-- Copying ${pyExample}")
-	file(COPY ${pyExample} DESTINATION ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
-	install(FILES "${pyExample}" DESTINATION bin PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
-endforeach()
+# Configure Python module __init__.py files
+configure_file(${CMAKE_CURRENT_LIST_DIR}/init_empty.py.in ${CMAKE_CURRENT_BINARY_DIR}/module/__init__.py COPYONLY)
+configure_file(${CMAKE_CURRENT_LIST_DIR}/init_deprecated.py.in ${CMAKE_CURRENT_BINARY_DIR}/module/deprecated/__init__.py COPYONLY)
+configure_file(${CMAKE_CURRENT_LIST_DIR}/init.py.in ${CMAKE_CURRENT_BINARY_DIR}/module/utils/__init__.py COPYONLY)
diff --git a/python/bindings/CMakeLists.txt b/python/bindings/CMakeLists.txt
index b37ffa85..f9906b8d 100644
--- a/python/bindings/CMakeLists.txt
+++ b/python/bindings/CMakeLists.txt
@@ -1,83 +1,115 @@
-# clear CMakeCache of Python version
+# Clear CMakeCache of Python version
 unset(PYTHONINTERP_FOUND CACHE)
 unset(PYTHON_EXECUTABLE CACHE)
 unset(PYTHON_VERSION_STRING CACHE)
 unset(PYTHON_VERSION_MAJOR CACHE)
 unset(PYTHON_VERSION_MINOR CACHE)
 unset(PYTHON_VERSION_PATCH CACHE)
-
-unset(PYTHON_INCLUDE_PATH CACHE)
-unset(PYTHON_INCLUDE_DIRS CACHE)
-unset(PYTHON_INCLUDE_DIR CACHE)
+# @ref https://github.com/opencv/opencv/blob/master/cmake/OpenCVDetectPython.cmake
+unset(PYTHONLIBS_FOUND)
+unset(PYTHON_LIBRARIES)
+unset(PYTHON_INCLUDE_PATH)
+unset(PYTHON_INCLUDE_DIRS)
+unset(PYTHON_DEBUG_LIBRARIES)
+unset(PYTHONLIBS_VERSION_STRING)
+unset(PYTHON_DEBUG_LIBRARY CACHE)
+unset(PYTHON_LIBRARY)
+unset(PYTHON_LIBRARY_DEBUG)
+unset(PYTHON_LIBRARY_RELEASE)
 unset(PYTHON_LIBRARY CACHE)
-unset(PYTHON_LIBRARIES CACHE)
-unset(PYTHON_DEBUG_LIBRARIES CACHE)
-unset(PYTHON_MODULE_PREFIX CACHE)
-unset(PYTHON_MODULE_EXTENSION CACHE)
-
-unset(PYTHONLIBS_FOUND CACHE)
-unset(PYTHONLIBS_VERSION_STRING CACHE)
+unset(PYTHON_LIBRARY_DEBUG CACHE)
+unset(PYTHON_LIBRARY_RELEASE CACHE)
+unset(PYTHON_INCLUDE_DIR CACHE)
+unset(PYTHON_INCLUDE_DIR2 CACHE)
 
-# locate requested python version
-message("-- detecting Python ${PYTHON_BINDING_VERSION}...")
+# Locate requested python version
+message(STATUS "jetson-utils: detecting Python v${PYTHON_BINDING_VERSION}...")
 
 find_package(PythonInterp ${PYTHON_BINDING_VERSION} QUIET)
 find_package(PythonLibs ${PYTHON_BINDING_VERSION} QUIET)
 
 if(NOT ${PYTHONLIBS_FOUND})
-	message("-- Python ${PYTHON_BINDING_VERSION} wasn't found")
-	return()
+    message(WARNING "jetson-utils: Python v${PYTHON_BINDING_VERSION} NOT found")
+    return()
 endif()
 
-message("-- found Python version:  ${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR} (${PYTHONLIBS_VERSION_STRING})")
-message("-- found Python include:  ${PYTHON_INCLUDE_DIRS}")
-message("-- found Python library:  ${PYTHON_LIBRARIES}") 
+message(STATUS "jetson-utils: found Python version:  ${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR} (${PYTHONLIBS_VERSION_STRING})")
+message(STATUS "jetson-utils: found Python include:  ${PYTHON_INCLUDE_DIRS}")
+message(STATUS "jetson-utils: found Python library:  ${PYTHON_LIBRARIES}")
 
 include_directories(${PYTHON_INCLUDE_DIRS})
 
-# attempt to find numpy
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}")
-message("-- CMake module path:  ${CMAKE_MODULE_PATH}")
+# Attempt to find numpy
 find_package(NumPy QUIET)
 
 if(${NUMPY_FOUND})
-	message("-- found NumPy version:  ${NUMPY_VERSION}")
-	message("-- found NumPy include:  ${NUMPY_INCLUDE_DIR}")
+  message(STATUS "jetson-utils: found NumPy version:  ${NUMPY_VERSION}")
+  message(STATUS "jetson-utils: found NumPy include:  ${NUMPY_INCLUDE_DIR}")
 
-	add_definitions(-DHAS_NUMPY)
-	include_directories(${NUMPY_INCLUDE_DIR})
-	link_directories(${NUMPY_INCLUDE_DIR}/../lib)
+  add_definitions(-DHAS_NUMPY)
+  include_directories(${NUMPY_INCLUDE_DIR})
+  link_directories(${NUMPY_INCLUDE_DIR}/../lib)
 else()
-	message("-- NumPy not found")
+  message(WARNING "jetson-utils: NumPy NOT found")
 endif()
 
-# build the bindings
+# Find source and header files
 file(GLOB pythonUtilsSources *.cpp)
+file(GLOB pythonUtilsIncludes *.h)
 
-cuda_add_library(jetson-utils-python-${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR} SHARED ${pythonUtilsSources})
+# Build Python bindings
+python_add_module(${PROJECT_NAME}-${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR} ${pythonUtilsSources} ${pythonUtilsIncludes})
 
-target_link_libraries(jetson-utils-python-${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR} jetson-utils ${PYTHON_LIBRARIES})
+if(HAVE_WRITE_STRINGS)
+  target_compile_options(${PROJECT_NAME}-${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR} PRIVATE -Wno-write-strings)
+endif()
+
+target_link_libraries(${PROJECT_NAME}-${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR}
+  jetson-utils
+  ${PYTHON_LIBRARIES}
+)
 
 if(${NUMPY_FOUND})
-	target_link_libraries(jetson-utils-python-${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR} npymath)
+  target_link_libraries(${PROJECT_NAME}-${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR}
+    npymath
+  )
 endif()
 
-set_target_properties(jetson-utils-python-${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR}
-				  PROPERTIES
-					PREFIX ""
-					OUTPUT_NAME "jetson_utils_python"
-					LIBRARY_OUTPUT_DIRECTORY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/python/${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}")
+set_target_properties(${PROJECT_NAME}-${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR}
+  PROPERTIES
+    PREFIX ""
+    OUTPUT_NAME "jetson_utils_python"
+    LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/python/${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}
+    INSTALL_RPATH_USE_LINK_PATH TRUE
+    INSTALL_RPATH "$ORIGIN:$ORIGIN/../../"
+)
 
 # on x86, install under /opt/conda/lib/pythonX.X/site-packages
-# otherwise, install under /usr/lib/pythonX.X/dist-packages
+# otherwise, install under /usr/local/lib/pythonX.X/dist-packages
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
-	set(PYTHON_BINDING_INSTALL_DIR /opt/conda/lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/site-packages)
+  set(PYTHON_BINDING_INSTALL_DIR /opt/conda/lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/site-packages)
 else()
-	set(PYTHON_BINDING_INSTALL_DIR /usr/lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/dist-packages)
+  set(PYTHON_BINDING_INSTALL_DIR ${CMAKE_INSTALL_LIBDIR}/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/dist-packages)
 endif()
 
-install(TARGETS jetson-utils-python-${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR} DESTINATION ${PYTHON_BINDING_INSTALL_DIR})
-
-install(DIRECTORY ../python/Jetson DESTINATION ${PYTHON_BINDING_INSTALL_DIR})
-install(DIRECTORY ../python/jetson DESTINATION ${PYTHON_BINDING_INSTALL_DIR})
-install(DIRECTORY ../python/jetson_utils DESTINATION ${PYTHON_BINDING_INSTALL_DIR})
+# Install the bindings as a Python package
+install(TARGETS ${PROJECT_NAME}-${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR}
+  DESTINATION ${PYTHON_BINDING_INSTALL_DIR}
+)
+
+# Install Python packaging files
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/../module/__init__.py
+  DESTINATION ${PYTHON_BINDING_INSTALL_DIR}/Jetson
+)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/../module/deprecated/__init__.py
+  DESTINATION ${PYTHON_BINDING_INSTALL_DIR}/Jetson/Utils
+)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/../module/__init__.py
+  DESTINATION ${PYTHON_BINDING_INSTALL_DIR}/jetson
+)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/../module/deprecated/__init__.py
+  DESTINATION ${PYTHON_BINDING_INSTALL_DIR}/jetson/utils
+)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/../module/utils/__init__.py
+  DESTINATION ${PYTHON_BINDING_INSTALL_DIR}/jetson_utils
+)
diff --git a/python/python/jetson_utils/__init__.py b/python/init.py.in
similarity index 58%
rename from python/python/jetson_utils/__init__.py
rename to python/init.py.in
index c5d9b124..b5af016c 100644
--- a/python/python/jetson_utils/__init__.py
+++ b/python/init.py.in
@@ -1,6 +1,3 @@
-
-#print("jetson.utils.__init__.py")
-
 from jetson_utils_python import *
 
 VERSION = '1.0.0'
diff --git a/python/python/Jetson/Utils/__init__.py b/python/init_deprecated.py.in
similarity index 80%
rename from python/python/Jetson/Utils/__init__.py
rename to python/init_deprecated.py.in
index a9fc23c3..145ecd6f 100644
--- a/python/python/Jetson/Utils/__init__.py
+++ b/python/init_deprecated.py.in
@@ -1,6 +1,3 @@
-
-#print("Jetson.Utils.__init__.py")
-
 from jetson_utils_python import *
 
 VERSION = '1.0.0'
diff --git a/python/python/Jetson/__init__.py b/python/init_empty.py.in
similarity index 100%
rename from python/python/Jetson/__init__.py
rename to python/init_empty.py.in
diff --git a/python/python/jetson/__init__.py b/python/python/jetson/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/python/python/jetson/utils/__init__.py b/python/python/jetson/utils/__init__.py
deleted file mode 100644
index baa596e9..00000000
--- a/python/python/jetson/utils/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-
-#print("jetson.utils.__init__.py")
-
-from jetson_utils_python import *
-
-VERSION = '1.0.0'
-
-print("warning:  importing jetson.utils is deprecated.  please 'import jetson_utils' instead.")
diff --git a/video/video-viewer/CMakeLists.txt b/video/video-viewer/CMakeLists.txt
index a414fb2d..297490ef 100644
--- a/video/video-viewer/CMakeLists.txt
+++ b/video/video-viewer/CMakeLists.txt
@@ -1,8 +1,32 @@
+# jetson-utils::v4l2-display -- CMakeLists.txt
+cmake_minimum_required(VERSION 3.5)
 
+# CMP0048: The project() command manages VERSION variables
+cmake_policy(SET CMP0048 NEW)
+
+# CMP0028: Double colon in target name means ALIAS or IMPORTED target
+cmake_policy(SET CMP0028 NEW)
+
+# Set name of the project
+project(video-viewer LANGUAGES CXX VERSION 1.0.0)
+
+# Find source and header files
 file(GLOB videoViewerSources *.cpp)
 file(GLOB videoViewerIncludes *.h )
 
-add_executable(video-viewer ${videoViewerSources})
-target_link_libraries(video-viewer jetson-utils)
+# Create the executable
+add_executable(${PROJECT_NAME} ${videoViewerSources} ${videoViewerIncludes})
+target_link_libraries(${PROJECT_NAME}
+  jetson-utils
+)
+set_target_properties(${PROJECT_NAME}
+  PROPERTIES
+    INSTALL_RPATH_USE_LINK_PATH TRUE
+    INSTALL_RPATH "$ORIGIN:$ORIGIN/../:$ORIGIN/../lib"
+)
 
-install(TARGETS video-viewer DESTINATION bin)
+# Install the executable
+install(TARGETS ${PROJECT_NAME}
+  DESTINATION
+    ${CMAKE_INSTALL_BINDIR}
+)