diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7c80293..4de3a3b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,101 +1,35 @@
-IF (APPLE)
-    cmake_minimum_required(VERSION 3.4)
-ELSE()
-    cmake_minimum_required(VERSION 2.8)
-ENDIF()
+cmake_minimum_required(VERSION 3.15)
 
 project(ctc_release)
 
-include_directories(include)
-
-FIND_PACKAGE(CUDA 6.5)
-FIND_PACKAGE(Torch)
-
-MESSAGE(STATUS "cuda found ${CUDA_FOUND}")
-MESSAGE(STATUS "Torch found ${Torch_DIR}")
+find_package(CUDA 6.5)
+find_package(OpenMP)
+find_package(Torch)
 
 option(WITH_GPU     "compile warp-ctc with CUDA."     ${CUDA_FOUND})
+option(WITH_OMP     "compile warp-ctc with OpenMP."   ${OpenMP_FOUND})
 option(WITH_TORCH   "compile warp-ctc with Torch."    ${Torch_FOUND})
-option(WITH_OMP     "compile warp-ctc with OpenMP."   ON)
 option(BUILD_TESTS  "build warp-ctc unit tests."      ON)
 option(BUILD_SHARED "build warp-ctc shared library."  ON)
 
-if(BUILD_SHARED)
-    set(WARPCTC_SHARED "SHARED")
-else(BUILD_SHARED)
-    set(WARPCTC_SHARED "STATIC")
-endif(BUILD_SHARED)
+set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING "Build Type of the project.")
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CUDA_STANDARD 11)
+
 
 if(WIN32)
     set(CMAKE_STATIC_LIBRARY_PREFIX lib)
-    set(CMAKE_C_FLAGS_DEBUG   "${CMAKE_C_FLAGS_DEBUG} /bigobj /MTd")
-    set(CMAKE_C_FLAGS_RELEASE  "${CMAKE_C_FLAGS_RELEASE} /bigobj /MT")
-    set(CMAKE_CXX_FLAGS_DEBUG  "${CMAKE_CXX_FLAGS_DEBUG} /bigobj /MTd")
-    set(CMAKE_CXX_FLAGS_RELEASE   "${CMAKE_CXX_FLAGS_RELEASE} /bigobj /MT")
-    foreach(flag_var
-            CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE)
-        if(${flag_var} MATCHES "/MD")
-            string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
-        endif(${flag_var} MATCHES "/MD")
-    endforeach(flag_var)
-else(WIN32)
-    # Set c++ flags
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2")
-    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -O2")
 endif(WIN32)
 
-if(APPLE)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-    add_definitions(-DAPPLE)
-endif()
-
-if(WITH_OMP AND NOT APPLE)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fopenmp")
-else()
-    add_definitions(-DCTC_DISABLE_OMP)
-endif()
-
-# need to be at least 30 or __shfl_down in reduce wont compile
-IF (CUDA_VERSION VERSION_LESS "11.0")
-    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_30,code=sm_30")
-ENDIF()
-set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_35,code=sm_35")
-
-set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_50,code=sm_50")
-set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_52,code=sm_52")
-
-IF (CUDA_VERSION VERSION_GREATER "7.6")
-    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_60,code=sm_60")
-    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_61,code=sm_61")
-    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_62,code=sm_62")
-ENDIF()
-
-IF ((CUDA_VERSION VERSION_GREATER "9.0") OR (CUDA_VERSION VERSION_EQUAL "9.0"))
-    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_70,code=sm_70")
-ENDIF()
-
-IF ((CUDA_VERSION VERSION_GREATER "10.0") OR (CUDA_VERSION VERSION_EQUAL "10.0"))
-    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_75,code=sm_75")
-ENDIF()
-
-IF ((CUDA_VERSION VERSION_GREATER "11.0") OR (CUDA_VERSION VERSION_EQUAL "11.0"))
-    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_80,code=sm_80")
-ENDIF()
-
-IF(NOT APPLE AND NOT WIN32)
-    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} --std=c++11")
-    if(WITH_OMP)
-        set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -Xcompiler -fopenmp")
-    endif()
-ENDIF()
-
+# Apple specifics
 IF (APPLE)
     EXEC_PROGRAM(uname ARGS -v  OUTPUT_VARIABLE DARWIN_VERSION)
     STRING(REGEX MATCH "[0-9]+" DARWIN_VERSION ${DARWIN_VERSION})
     MESSAGE(STATUS "DARWIN_VERSION=${DARWIN_VERSION}")
 
-    #for el capitain have to use rpath
+    add_compile_definitions(APPLE)
 
+    #for el capitain have to use rpath
     IF (DARWIN_VERSION LESS 15)
         set(CMAKE_SKIP_RPATH TRUE)
     ENDIF ()
@@ -105,6 +39,7 @@ ELSE()
     set(CMAKE_SKIP_RPATH TRUE)
 ENDIF()
 
+
 # windows treat symbolic file as a real file, which is different with unix
 # We create a hidden file and compile it instead of origin source file.
 function(windows_symbolic TARGET)
@@ -132,111 +67,118 @@ function(windows_symbolic TARGET)
                     COMMAND ${CMAKE_COMMAND} -E remove ${final_path}/.${src}.cu
                     COMMAND ${CMAKE_COMMAND} -E copy "${final_path}/${src}.cpp" "${final_path}/.${src}.cu"
                     COMMENT "create hidden file of ${src}.cu")
-        endif(copy_flag)
+        endif()
         add_custom_target(${TARGET} ALL DEPENDS ${final_path}/.${src}.cu)
     endforeach()
 endfunction()
 
-IF (WITH_GPU)
+if(NOT WITH_GPU)
+    message(STATUS "Building shared library with no GPU support")
+    add_library(warpctc src/ctc_entrypoint.cpp)
+else()
+    message(STATUS "Building shared library with GPU support")
+
+    # need to be at least 30 or __shfl_down in reduce wont compile
+    IF (CUDA_VERSION VERSION_LESS "11.0")
+        set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_30,code=sm_30")
+    ENDIF()
+    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_35,code=sm_35")
+
+    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_50,code=sm_50")
+    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_52,code=sm_52")
+
+    if (CUDA_VERSION VERSION_GREATER "7.6")
+        set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_60,code=sm_60")
+        set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_61,code=sm_61")
+        set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_62,code=sm_62")
+    endif()
+
+    if ((CUDA_VERSION VERSION_GREATER "9.0") OR (CUDA_VERSION VERSION_EQUAL "9.0"))
+        set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_70,code=sm_70")
+    endif()
+
+    if ((CUDA_VERSION VERSION_GREATER "10.0") OR (CUDA_VERSION VERSION_EQUAL "10.0"))
+        set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_75,code=sm_75")
+    endif()
 
-    MESSAGE(STATUS "Building shared library with GPU support")
-    MESSAGE(STATUS "NVCC_ARCH_FLAGS" ${CUDA_NVCC_FLAGS})
+    if ((CUDA_VERSION VERSION_GREATER "11.0") OR (CUDA_VERSION VERSION_EQUAL "11.0"))
+        set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -gencode arch=compute_80,code=sm_80")
+    endif()
 
     if (WIN32)
         SET(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -Xcompiler \"/wd 4068 /wd 4244 /wd 4267 /wd 4305 /wd 4819\"")
         windows_symbolic(ctc_entrypoint SRCS ctc_entrypoint.cu PATH src)
-        CUDA_ADD_LIBRARY(warpctc ${WARPCTC_SHARED} src/.ctc_entrypoint.cu src/reduce.cu)
+        cuda_add_library(warpctc src/.ctc_entrypoint.cu src/reduce.cu)
     else()
-        CUDA_ADD_LIBRARY(warpctc ${WARPCTC_SHARED} src/ctc_entrypoint.cu src/reduce.cu)
-    endif(WIN32)
-
-    IF (!WITH_TORCH)
-        TARGET_LINK_LIBRARIES(warpctc ${CUDA_curand_LIBRARY})
-    ENDIF()
-
-    if(BUILD_TESTS)
-        add_executable(test_cpu tests/test_cpu.cpp )
-        TARGET_LINK_LIBRARIES(test_cpu warpctc)
-        SET_TARGET_PROPERTIES(test_cpu PROPERTIES COMPILE_FLAGS "${CMAKE_CXX_FLAGS} --std=c++11")
+        cuda_add_library(warpctc src/ctc_entrypoint.cu src/reduce.cu)
+    endif()
+endif()
 
-        cuda_add_executable(test_gpu tests/test_gpu.cu)
-        TARGET_LINK_LIBRARIES(test_gpu warpctc ${CUDA_curand_LIBRARY})
-    endif(BUILD_TESTS)
-
-    INSTALL(TARGETS warpctc
-            RUNTIME DESTINATION "bin"
-            LIBRARY DESTINATION "lib"
-            ARCHIVE DESTINATION "lib")
-
-    INSTALL(FILES include/ctc.h DESTINATION "include")
-
-    IF (WITH_TORCH)
-        MESSAGE(STATUS "Building Torch Bindings with GPU support")
-        INCLUDE_DIRECTORIES(${CUDA_INCLUDE_DIRS} "${CUDA_TOOLKIT_ROOT_DIR}/samples/common/inc")
-        INCLUDE_DIRECTORIES(${Torch_INSTALL_INCLUDE} ${Torch_INSTALL_INCLUDE}/TH ${Torch_INSTALL_INCLUDE}/THC)
-
-        TARGET_LINK_LIBRARIES(warpctc luajit luaT THC TH ${CUDA_curand_LIBRARY})
-        INSTALL(TARGETS warpctc
-                RUNTIME DESTINATION "${Torch_INSTALL_BIN_SUBDIR}"
-                LIBRARY DESTINATION "${Torch_INSTALL_LIB_SUBDIR}"
-                ARCHIVE DESTINATION "${Torch_INSTALL_LIB_SUBDIR}")
-
-        SET(src torch_binding/binding.cpp torch_binding/utils.c)
-        SET(luasrc torch_binding/init.lua)
-
-        ADD_TORCH_PACKAGE(warp_ctc "${src}" "${luasrc}")
-        IF (APPLE)
-            TARGET_LINK_LIBRARIES(warp_ctc warpctc luajit luaT THC TH ${CUDA_curand_LIBRARY})
-        ELSE()
-            TARGET_LINK_LIBRARIES(warp_ctc warpctc luajit luaT THC TH ${CUDA_curand_LIBRARY} gomp)
-        ENDIF()
-    ENDIF()
 
-ELSE()
-    MESSAGE(STATUS "Building shared library with no GPU support")
+if(NOT WITH_OMP)
+    #target_link_libraries(warpctc PRIVATE OpenMP::OpenMP_CXX)
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_EXE_LINKER_FLAGS}")
+  set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -Xcompiler ${OpenMP_CXX_FLAGS}")
+else()
+    add_compile_definitions(CTC_DISABLE_OMP)
+endif()
 
-    if (NOT APPLE AND NOT WIN32)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -O2")
-    ENDIF()
+target_include_directories(warpctc PUBLIC include)
+install(TARGETS warpctc)
+install(FILES include/ctc.h DESTINATION "include")
 
-    ADD_LIBRARY(warpctc ${WARPCTC_SHARED} src/ctc_entrypoint.cpp)
 
-    if(BUILD_TESTS)
-        add_executable(test_cpu tests/test_cpu.cpp )
-        TARGET_LINK_LIBRARIES(test_cpu warpctc)
-        SET_TARGET_PROPERTIES(test_cpu PROPERTIES COMPILE_FLAGS "${CMAKE_CXX_FLAGS} --std=c++11")
-    endif(BUILD_TESTS)
+# If Torch is present
+if (WITH_TORCH)
+    if(WITH_GPU)
+        message(STATUS "Building Torch Bindings with GPU upport")
+    else()
+        message(STATUS "Building Torch Bindings with no GPU support")
+    endif()
 
-    INSTALL(TARGETS warpctc
-            RUNTIME DESTINATION "bin"
-            LIBRARY DESTINATION "lib"
-            ARCHIVE DESTINATION "lib")
+    target_link_libraries(warpctc PUBLIC luajit luaT TH)
+    target_include_directories(${Torch_INSTALL_INCLUDE} ${Torch_INSTALL_INCLUDE}/TH)
 
-    INSTALL(FILES include/ctc.h DESTINATION "include")
+    install(TARGETS warpctc
+            RUNTIME DESTINATION "${Torch_INSTALL_BIN_SUBDIR}"
+            LIBRARY DESTINATION "${Torch_INSTALL_LIB_SUBDIR}"
+            ARCHIVE DESTINATION "${Torch_INSTALL_LIB_SUBDIR}")
 
-    IF (WITH_TORCH)
-        MESSAGE(STATUS "Building Torch Bindings with no GPU support")
-        add_definitions(-DTORCH_NOGPU)
-        INCLUDE_DIRECTORIES(${Torch_INSTALL_INCLUDE} ${Torch_INSTALL_INCLUDE}/TH)
+    add_torch_package(
+    warp_ctc
+        torch_binding/binding.cpp
+        torch_binding/utils.c
+        torch_binding/init.lua
+    )
+    target_link_libraries(warp_ctc PRIVATE warpctc)
 
-        TARGET_LINK_LIBRARIES(warpctc luajit luaT TH)
+    if (NOT APPLE)
+        target_link_libraries(warp_ctc PRIVATE gomp)
+    endif()
 
-        INSTALL(TARGETS warpctc
-                RUNTIME DESTINATION "${Torch_INSTALL_BIN_SUBDIR}"
-                LIBRARY DESTINATION "${Torch_INSTALL_LIB_SUBDIR}"
-                ARCHIVE DESTINATION "${Torch_INSTALL_LIB_SUBDIR}")
+    if(WITH_GPU)
+        include_directories(${Torch_INSTALL_INCLUDE}/THC ${CUDA_INCLUDE_DIRS} "${CUDA_TOOLKIT_ROOT_DIR}/samples/common/inc")
+        target_link_libraries(warpctc PRIVATE THC ${CUDA_curand_LIBRARY})
+        target_link_libraries(warp_ctc PRIVATE THC ${CUDA_curand_LIBRARY})
+    else()
+        add_compile_definitions(TORCH_NOGPU)
+    endif()
 
-        SET(src torch_binding/binding.cpp torch_binding/utils.c)
-        SET(luasrc torch_binding/init.lua)
+endif()
 
-        ADD_TORCH_PACKAGE(warp_ctc "${src}" "${luasrc}")
-        IF (APPLE)
-            TARGET_LINK_LIBRARIES(warp_ctc warpctc luajit luaT TH)
-        ELSE()
-            TARGET_LINK_LIBRARIES(warp_ctc warpctc luajit luaT TH gomp)
-        ENDIF()
-    ENDIF()
 
-ENDIF()
+# Build Tests
+if(BUILD_TESTS)
+    add_executable(test_cpu tests/test_cpu.cpp )
+    target_link_libraries(test_cpu warpctc)
+    target_include_directories(test_cpu PRIVATE tests)
 
+    if(WITH_GPU)
+        cuda_add_executable(test_gpu tests/test_gpu.cu)
+        target_link_libraries(test_gpu warpctc ${CUDA_curand_LIBRARY})
+        target_include_directories(test_gpu PRIVATE tests)
+    endif()
 
+endif()