diff --git a/.gitignore b/.gitignore
index 7e233325..709a1f9c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,3 +20,6 @@ tests/hbtrie_test
 tests/list_test
 tests/mempool_test
 wt2
+CMakeUserPresets.json
+compile_commands.json
+.cache/
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e05e038a..1ceb88cd 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,118 +1,115 @@
-cmake_minimum_required(VERSION 3.4.0)
-project (ForestDB)
+cmake_minimum_required(VERSION 3.20)
+project(ForestDB VERSION 1.0.0 LANGUAGES CXX)
 
-IF (${CMAKE_MAJOR_VERSION} GREATER 2)
-    CMAKE_POLICY(SET CMP0042 NEW)
-ENDIF (${CMAKE_MAJOR_VERSION} GREATER 2)
+if(${CMAKE_MAJOR_VERSION} GREATER 2)
+    cmake_policy(SET CMP0042 NEW)
+endif(${CMAKE_MAJOR_VERSION} GREATER 2)
 
-INCLUDE(CheckCXXCompilerFlag)
+
+include(CheckCXXCompilerFlag)
 CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
 CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
-IF (COMPILER_SUPPORTS_CXX11)
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-    SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -std=c++11")
-    SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -std=c++11")
-ELSEIF(COMPILER_SUPPORTS_CXX0X)
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
-    SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -std=c++0x")
-    SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -std=c++0x")
-ELSE()
-    IF (NOT WIN32)
-        MESSAGE(FATAL_ERROR "Compiler ${CMAKE_CXX_COMPILER} has no C++11 support.")
-    ENDIF()
-ENDIF()
-
-INCLUDE(CheckFunctionExists)
-INCLUDE(CheckIncludeFileCXX)
-INCLUDE(CheckIncludeFiles)
-INCLUDE(CheckLibraryExists)
-INCLUDE(CheckSymbolExists)
-INCLUDE(CheckTypeSize)
-INCLUDE(CTest)
-
-IF (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
-    EXECUTE_PROCESS(COMMAND git describe --abbrev=7 --always --tags
-                    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-                    OUTPUT_VARIABLE FORESTDB_VERSION
-                    ERROR_QUIET
-                    OUTPUT_STRIP_TRAILING_WHITESPACE)
-ELSE (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
-    SET(FORESTDB_VERSION "unknown")
-ENDIF (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
-
-include_directories(BEFORE ${PROJECT_SOURCE_DIR}/option)
-include_directories(BEFORE ${PROJECT_SOURCE_DIR}/utils)
-include_directories(BEFORE ${PROJECT_SOURCE_DIR}/src)
-include_directories(BEFORE ${PROJECT_SOURCE_DIR}/include)
-include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/src)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+if(COMPILER_SUPPORTS_CXX11)
+    set(CMAKE_CXX_STANDARD 11)
+elseif(COMPILER_SUPPORTS_CXX0X)
+    add_compile_options(-std=c++0x)
+else()
+    if(NOT WIN32)
+        message(FATAL_ERROR "Compiler ${CMAKE_CXX_COMPILER} has no C++11 support.")
+    endif()
+endif()
+
+include(CheckFunctionExists)
+include(CheckIncludeFileCXX)
+include(CheckIncludeFiles)
+include(CheckLibraryExists)
+include(CheckSymbolExists)
+include(CheckTypeSize)
+include(CTest) # automatically defines BUILD_TESTING option
+
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
+    execute_process(COMMAND git describe --abbrev=7 --always --tags
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        OUTPUT_VARIABLE FORESTDB_VERSION
+        ERROR_QUIET
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+else()
+    set(FORESTDB_VERSION "unknown")
+endif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
+
+option(WITH_CONAN "Use dependences provide by Conan" OFF)
+option(_JEMALLOC "Use dependences provide by Conan" OFF)
+option(WITH_SNAPPY "Use Snappy Compression" OFF)
+option(CODE_COVERAGE "Enable Coverage" OFF)
+option(ADDRESS_SANITIZER "Enable address sanitizer" OFF)
+option(THREAD_SANITIZER "Enable thread sanitizer" OFF)
+option(LEAK_SANITIZER "Enable leak sanitizer" OFF)
+
+include_directories(BEFORE
+    ${PROJECT_SOURCE_DIR}/option
+    ${PROJECT_SOURCE_DIR}/utils
+    ${PROJECT_SOURCE_DIR}/src
+    ${PROJECT_SOURCE_DIR}/include
+    ${CMAKE_CURRENT_BINARY_DIR}/src
+)
 
 CHECK_INCLUDE_FILES("sched.h" HAVE_SCHED_H)
 
-CONFIGURE_FILE (${CMAKE_CURRENT_SOURCE_DIR}/src/config.cmake.h
-                ${CMAKE_CURRENT_BINARY_DIR}/src/config.h)
-
-LIST(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/Modules")
-
-if (NOT SNAPPY_OPTION)
-    # Disable snappy by default if not given.
-    set(SNAPPY_OPTION "Disable")
-endif ()
-
-
-if (COUCHBASE_SERVER_BUILD)
-    ADD_DEFINITIONS(-D_DOC_COMP=1)
-    include_directories(AFTER ${SNAPPY_INCLUDE_DIR})
-
-    if (WIN32)
-       # The rest of Couchbase server use tcmalloc as the memory
-       # allocator for WIN32. Override the allocator to jemalloc
-       ADD_DEFINITIONS(-UHAVE_TCMALLOC)
-       SET(COUCHBASE_MEMORY_ALLOCATOR "jemalloc")
-       # Make sure that we define all of the variables
-       include(CouchbaseMemoryAllocator)
-    endif (WIN32)
-
-    if (MEMORY_ALLOCATOR)
-        include_directories(AFTER ${MALLOC_INCLUDE_DIR})
-    endif (MEMORY_ALLOCATOR)
-    set(DIRUTILS_LIBRARY dirutils)
-    set(GTEST_LIBRARY gtest)
-
-else(COUCHBASE_SERVER_BUILD)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_GNU_SOURCE -D__DEBUG")
-    if (NOT WIN32)
-        if (NOT(SNAPPY_OPTION STREQUAL "Disable"))
-            INCLUDE(FindSnappy)
-            ADD_DEFINITIONS(-D_DOC_COMP=1)
-            MESSAGE(STATUS "Snappy compression: ENABLED")
-        else ()
-            MESSAGE(STATUS "Snappy compression: DISABLED")
-        endif (NOT(SNAPPY_OPTION STREQUAL "Disable"))
-    endif(NOT WIN32)
-    if (_JEMALLOC EQUAL 1)
-        INCLUDE(FindJemalloc)
-    endif(_JEMALLOC EQUAL 1)
-endif(COUCHBASE_SERVER_BUILD)
-
-#INCLUDE(FindAsyncIOLib)
-
-if (NOT BTREE_SUBBLOCK)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/config.cmake.h
+    ${CMAKE_CURRENT_BINARY_DIR}/src/config.h)
+
+if(SNAPPY_OPTION AND NOT WIN32)
+    if(WITH_CONAN)
+        find_package(Snappy REQUIRED)
+        set(LIBSNAPPY Snappy::snappy)
+    else()
+        include(cmake/Modules/FindSnappy.cmake)
+        if(SNAPPY_FOUND)
+            set(LIBSNAPPY ${SNAPPY_LIBRARIES})
+        else()
+            message(FATAL_ERROR "Can't find snappy, "
+                "if you want to build without snappy set SNAPPY_OPTION=OFF")
+        endif(SNAPPY_FOUND)
+
+    endif(WITH_CONAN)
+    message(STATUS "Snappy compression: ENABLED")
+    add_compile_definitions(_DOC_COMP=1)
+else()
+    message(STATUS "Snappy compression: DISABLED")
+endif()
+
+
+if(_JEMALLOC)
+    if(WITH_CONAN)
+        find_package(jemalloc REQUIRED)
+        set(MALLOC_LIBRARIES jemalloc::jemalloc)
+        add_compile_definitions(HAVE_JEMALLOC=1)
+    else()
+        include(cmake/Modules/FindJemalloc)
+    endif(WITH_CONAN)
+endif(_JEMALLOC)
+
+#include(include(FindAsyncIOLib)
+
+if(NOT BTREE_SUBBLOCK)
     # Enable by default if not given.
     set(BTREE_SUBBLOCK "Enable")
-endif ()
-
-if ( (BTREE_SUBBLOCK STREQUAL "Enable") OR
-     (BTREE_SUBBLOCK STREQUAL "enable") OR
-     (BTREE_SUBBLOCK STREQUAL "True") OR
-     (BTREE_SUBBLOCK STREQUAL "true")  )
-    ADD_DEFINITIONS(-D__BTREEBLK_SUBBLOCK=1)
-    MESSAGE(STATUS "B+tree sub-blocks: ENABLED")
-else ()
-    MESSAGE(STATUS "B+tree sub-blocks: DISABLED")
 endif()
 
-if (NOT CMAKE_BUILD_TYPE)
-     set(DEFAULT_BUILD_TYPE "RelWithDebInfo")
+if((BTREE_SUBBLOCK STREQUAL "Enable") OR
+    (BTREE_SUBBLOCK STREQUAL "enable") OR
+    (BTREE_SUBBLOCK STREQUAL "True") OR
+    (BTREE_SUBBLOCK STREQUAL "true"))
+    add_definitions(-D__BTREEBLK_SUBBLOCK=1)
+    message(STATUS "B+tree sub-blocks: ENABLED")
+else()
+    message(STATUS "B+tree sub-blocks: DISABLED")
+endif()
+
+if(NOT CMAKE_BUILD_TYPE)
+    set(DEFAULT_BUILD_TYPE "RelWithDebInfo")
     #set(DEFAULT_BUILD_TYPE "Debug")
 
     set(BUILD_TYPE_OPTIONS
@@ -121,103 +118,72 @@ if (NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE ${DEFAULT_BUILD_TYPE}
         CACHE ${BUILD_TYPE_OPTIONS} FORCE)
     message(STATUS "Build type is not given, use default.")
-endif ()
+endif()
 message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
 
 
 if(NOT LIBRT)
     unset(LIBRT CACHE)
 endif(NOT LIBRT)
-if (NOT WIN32)
+if(NOT WIN32)
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -Wunused-variable -Wall -pedantic -Wredundant-decls")
     set(PTHREAD_LIB pthread)
     set(LIBM m)
     set(FORESTDB_FILE_OPS "src/filemgr_ops_linux.cc")
-    if (NOT APPLE)
+    if(NOT APPLE)
         set(LIBRT rt)
-    endif (NOT APPLE)
-    FIND_LIBRARY(DL_LIBRARY NAMES dl)
-    if (DL_LIBRARY)
+    endif(NOT APPLE)
+    find_library(DL_LIBRARY NAMES dl)
+    if(DL_LIBRARY)
         set(DL_LIBRARIES "${DL_LIBRARY}")
         message(STATUS "DL library : ${DL_LIBRARY}")
-    endif (DL_LIBRARY)
+    endif(DL_LIBRARY)
 
-    FIND_LIBRARY(DL_STATIC_LIBRARY NAMES libdl.a)
-    if (DL_STATIC_LIBRARY)
+    find_library(DL_STATIC_LIBRARY NAMES libdl.a)
+    if(DL_STATIC_LIBRARY)
         message(STATUS "DL static library : ${DL_STATIC_LIBRARY}")
-    endif ()
+    endif()
 
-else (NOT WIN32)
+else()
     set(FORESTDB_FILE_OPS "src/filemgr_ops_windows.cc")
     set(GETTIMEOFDAY_VS "${PROJECT_SOURCE_DIR}/utils/gettimeofday_vs.cc")
 endif(NOT WIN32)
 
-IF (_MVCC_WAL EQUAL 1)
-    ADD_DEFINITIONS(-D_MVCC_WAL_ENABLE=1)
-ENDIF()
+if(_MVCC_WAL EQUAL 1)
+    add_compile_definitions(_MVCC_WAL_ENABLE=1)
+endif()
 
-IF (_MEMLEAK EQUAL 1)
-    ADD_DEFINITIONS(-D_MEMLEAK_ENABLE=1)
-ELSEIF (_MEMLEAK EQUAL 2)
-    ADD_DEFINITIONS(-D_MEMLEAK_ENABLE=1)
-    ADD_DEFINITIONS(-D_CHK_MODIFY_AFTER_FREE=1)
-ENDIF()
+if(_MEMLEAK EQUAL 1)
+    add_compile_definitions(_MEMLEAK_ENABLE=1)
+elseif(_MEMLEAK EQUAL 2)
+    add_compile_definitions(_MEMLEAK_ENABLE=1)
+    add_compile_definitions(_CHK_MODIFY_AFTER_FREE=1)
+endif()
 
 # Comment the line below to disable compiling Copy-On-Write (COW) optimizations
-ADD_DEFINITIONS (-D_COW_COMPACTION=1)
-
-if (COUCHBASE_SERVER_BUILD)
-    if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-       # using /W0 cause msvc to print out a warning that it overrides
-       # previous settings (/W3 is added by default).
-       # Let's just disable the ones we're "violating"
-       # (we should probably fix them at some point?)
-       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4716 /wd4244 /wd4267 /wd4101 /wd4800 /wd4700 /wd4018 /wd4102")
-   endif()
-else()
-  # If building outside CB server build, set required flags for the selected compiler.
-    if ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -Qunused-arguments -g -fomit-frame-pointer -pthread")
-    elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -g -fomit-frame-pointer -pthread -Wno-class-memaccess -Wno-int-in-bool-context -Wno-format-overflow")
-    elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4716 /W0")
-    endif()
-endif()
+add_compile_definitions(_COW_COMPACTION=1)
 
-# Breakpad support with Couchbase Server Build only when on Windows/Linux.
-if (COUCHBASE_SERVER_BUILD)
-    if (BREAKPAD_FOUND)
-        INCLUDE_DIRECTORIES(AFTER ${BREAKPAD_INCLUDE_DIR})
-        if (WIN32)
-            SET(BREAKPAD_SRC src/breakpad_win32.cc)
-        elseif ("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
-            SET(BREAKPAD_SRC src/breakpad_linux.cc)
-            # Breakpad has headers (which are dependencies for our breakpad
-            # integration code) that don't compile cleanly as C++11, so the
-            # GNU standard is used instead.
-            SET_SOURCE_FILES_PROPERTIES(src/breakpad_linux.cc
-                                        PROPERTIES
-                                        COMPILE_FLAGS ${CB_GNU_CXX11_OPTION})
-        else()
-            SET(BREAKPAD_SRC src/breakpad_dummy.cc)
-        endif()
-    else (BREAKPAD_FOUND)
-        SET(BREAKPAD_SRC src/breakpad_dummy.cc)
-    endif(BREAKPAD_FOUND)
-else()
-    SET(BREAKPAD_SRC src/breakpad_dummy.cc)
-endif()
+add_compile_definitions(_GNU_SOURCE __DEBUG)
 
-if (NOT COUCHBASE_SERVER_BUILD)
-   INCLUDE(ThreadSanitizer)
+# set required flags for the selected compiler.
+if("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
+    add_compile_options(-Qunused-arguments -g -fomit-frame-pointer -pthread)
+elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    add_compile_options(-g -fomit-frame-pointer -pthread -Wno-class-memaccess -Wno-int-in-bool-context -Wno-format-overflow)
+elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+    add_compile_options(/wd4716 /W0)
 endif()
 
-IF (_ENCRYPTION)
-    INCLUDE(FindEncryptionLib)
-ENDIF (_ENCRYPTION)
+set(BREAKPAD_SRC src/breakpad_dummy.cc)
+
+
+include(cmake/Modules/ThreadSanitizer.cmake)
 
-SET(FORESTDB_CORE_SRC
+if(_ENCRYPTION)
+    include(cmake/Modules/FindEncryptionLib)
+endif(_ENCRYPTION)
+
+set(FORESTDB_CORE_SRC
     ${PROJECT_SOURCE_DIR}/src/api_wrapper.cc
     ${PROJECT_SOURCE_DIR}/src/avltree.cc
     ${PROJECT_SOURCE_DIR}/src/bgflusher.cc
@@ -252,7 +218,7 @@ SET(FORESTDB_CORE_SRC
     ${PROJECT_SOURCE_DIR}/src/version.cc
     ${PROJECT_SOURCE_DIR}/src/wal.cc)
 
-SET(FORESTDB_UTILS_SRC
+set(FORESTDB_UTILS_SRC
     ${PROJECT_SOURCE_DIR}/utils/crc32.cc
     ${PROJECT_SOURCE_DIR}/utils/debug.cc
     ${PROJECT_SOURCE_DIR}/utils/memleak.cc
@@ -262,99 +228,108 @@ SET(FORESTDB_UTILS_SRC
     ${PROJECT_SOURCE_DIR}/utils/timing.cc)
 
 add_library(forestdb SHARED
-            ${FORESTDB_FILE_OPS}
-            ${GETTIMEOFDAY_VS}
-            ${FORESTDB_CORE_SRC}
-            ${FORESTDB_UTILS_SRC})
+    ${FORESTDB_FILE_OPS}
+    ${GETTIMEOFDAY_VS}
+    ${FORESTDB_CORE_SRC}
+    ${FORESTDB_UTILS_SRC})
 target_link_libraries(forestdb ${PTHREAD_LIB} ${LIBM} ${SNAPPY_LIBRARIES}
-                      ${ASYNC_IO_LIB} ${MALLOC_LIBRARIES} ${LIBRT}
-                      ${CRYPTO_LIB}
-                      ${DL_LIBRARIES} ${BREAKPAD_LIBRARIES})
+    ${ASYNC_IO_LIB} ${MALLOC_LIBRARIES} ${LIBRT}
+    ${CRYPTO_LIB}
+    ${DL_LIBRARIES} ${BREAKPAD_LIBRARIES})
 
 add_library(static_lib
-            ${FORESTDB_FILE_OPS}
-            ${GETTIMEOFDAY_VS}
-            ${FORESTDB_CORE_SRC}
-            ${FORESTDB_UTILS_SRC})
+    ${FORESTDB_FILE_OPS}
+    ${GETTIMEOFDAY_VS}
+    ${FORESTDB_CORE_SRC}
+    ${FORESTDB_UTILS_SRC})
 target_link_libraries(static_lib
-                      ${PTHREAD_LIB}
-                      ${LIBM}
-                      ${SNAPPY_LIBRARIES}
-                      ${ASYNC_IO_LIB}
-                      ${MALLOC_LIBRARIES}
-                      ${LIBRT}
-                      ${CRYPTO_LIB}
-                      ${DL_LIBRARIES}
-                      ${BREAKPAD_LIBRARIES})
+    ${PTHREAD_LIB}
+    ${LIBM}
+    ${SNAPPY_LIBRARIES}
+    ${ASYNC_IO_LIB}
+    ${MALLOC_LIBRARIES}
+    ${LIBRT}
+    ${CRYPTO_LIB}
+    ${DL_LIBRARIES}
+    ${BREAKPAD_LIBRARIES})
 set_target_properties(static_lib PROPERTIES OUTPUT_NAME forestdb CLEAN_DIRECT_OUTPUT 1)
 
 # Create objects libraries for the different "tools" parts forestdb, which can be reused
 # by various targets.
 add_library(FDB_TOOLS_CORE OBJECT ${FORESTDB_CORE_SRC})
 set_target_properties(FDB_TOOLS_CORE PROPERTIES COMPILE_FLAGS "-D_FDB_TOOLS")
+target_link_libraries(FDB_TOOLS_CORE ${PTHREAD_LIB} ${LIBM} ${SNAPPY_LIBRARIES}
+    ${ASYNC_IO_LIB} ${MALLOC_LIBRARIES} ${PLATFORM_LIBRARY}
+    ${LIBRT} ${CRYPTO_LIB}
+    ${DL_LIBRARIES} ${BREAKPAD_LIBRARIES})
+
 
 add_library(FDB_TOOLS_UTILS OBJECT ${FORESTDB_UTILS_SRC})
 set_target_properties(FDB_TOOLS_UTILS PROPERTIES COMPILE_FLAGS "-D_FDB_TOOLS")
+target_link_libraries(FDB_TOOLS_UTILS ${PTHREAD_LIB} ${LIBM} ${SNAPPY_LIBRARIES}
+    ${ASYNC_IO_LIB} ${MALLOC_LIBRARIES} ${PLATFORM_LIBRARY}
+    ${LIBRT} ${CRYPTO_LIB}
+    ${DL_LIBRARIES} ${BREAKPAD_LIBRARIES})
 
 add_executable(forestdb_dump
-               tools/dump_common.cc
-               tools/forestdb_dump.cc
-               ${FORESTDB_FILE_OPS}
-               ${GETTIMEOFDAY_VS}
-               $<TARGET_OBJECTS:FDB_TOOLS_CORE>
-               $<TARGET_OBJECTS:FDB_TOOLS_UTILS>)
+    tools/dump_common.cc
+    tools/forestdb_dump.cc
+    ${FORESTDB_FILE_OPS}
+    ${GETTIMEOFDAY_VS}
+    $<TARGET_OBJECTS:FDB_TOOLS_CORE>
+    $<TARGET_OBJECTS:FDB_TOOLS_UTILS>)
 target_link_libraries(forestdb_dump ${PTHREAD_LIB} ${LIBM} ${SNAPPY_LIBRARIES}
-                      ${ASYNC_IO_LIB} ${MALLOC_LIBRARIES} ${PLATFORM_LIBRARY}
-                      ${LIBRT} ${CRYPTO_LIB}
-                      ${DL_LIBRARIES} ${BREAKPAD_LIBRARIES})
+    ${ASYNC_IO_LIB} ${MALLOC_LIBRARIES} ${PLATFORM_LIBRARY}
+    ${LIBRT} ${CRYPTO_LIB}
+    ${DL_LIBRARIES} ${BREAKPAD_LIBRARIES})
 set_target_properties(forestdb_dump PROPERTIES COMPILE_FLAGS "-D_FDB_TOOLS")
 
 add_executable(forestdb_hexamine
-               tools/dump_common.cc
-               tools/forestdb_hexamine.cc
-               ${FORESTDB_FILE_OPS}
-               ${GETTIMEOFDAY_VS}
-               $<TARGET_OBJECTS:FDB_TOOLS_CORE>
-               $<TARGET_OBJECTS:FDB_TOOLS_UTILS>)
+    tools/dump_common.cc
+    tools/forestdb_hexamine.cc
+    ${FORESTDB_FILE_OPS}
+    ${GETTIMEOFDAY_VS}
+    $<TARGET_OBJECTS:FDB_TOOLS_CORE>
+    $<TARGET_OBJECTS:FDB_TOOLS_UTILS>)
 target_link_libraries(forestdb_hexamine ${PTHREAD_LIB} ${LIBM} ${SNAPPY_LIBRARIES}
-                      ${ASYNC_IO_LIB} ${MALLOC_LIBRARIES} ${PLATFORM_LIBRARY}
-                      ${LIBRT} ${CRYPTO_LIB}
-                      ${DL_LIBRARIES} ${BREAKPAD_LIBRARIES})
+    ${ASYNC_IO_LIB} ${MALLOC_LIBRARIES} ${PLATFORM_LIBRARY}
+    ${LIBRT} ${CRYPTO_LIB}
+    ${DL_LIBRARIES} ${BREAKPAD_LIBRARIES})
 set_target_properties(forestdb_hexamine PROPERTIES COMPILE_FLAGS "-D_FDB_TOOLS")
 
-if ((NOT COUCHBASE_SERVER_BUILD) OR (INSTALL_HEADER_FILES))
-    INSTALL(FILES
-            include/libforestdb/forestdb.h
-            include/libforestdb/fdb_types.h
-            include/libforestdb/fdb_errors.h
-            DESTINATION include/libforestdb)
+if((NOT COUCHBASE_SERVER_BUILD) OR (INSTALL_HEADER_FILES))
+    install(FILES
+        include/libforestdb/forestdb.h
+        include/libforestdb/fdb_types.h
+        include/libforestdb/fdb_errors.h
+        ${CMAKE_CURRENT_BINARY_DIR}/src/config.h
+        DESTINATION include/libforestdb)
 endif((NOT COUCHBASE_SERVER_BUILD) OR (INSTALL_HEADER_FILES))
 
-INSTALL(TARGETS forestdb
-        RUNTIME DESTINATION bin
-        LIBRARY DESTINATION lib
-        ARCHIVE DESTINATION lib)
+install(TARGETS static_lib
+    RUNTIME DESTINATION bin
+    LIBRARY DESTINATION lib
+    ARCHIVE DESTINATION lib)
 
-INSTALL(TARGETS forestdb_dump
-        RUNTIME DESTINATION bin)
+install(TARGETS forestdb_dump
+    RUNTIME DESTINATION bin)
 
-
-if ("${CMAKE_BUILD_TYPE}" STREQUAL "Coverage")
-    if ((NOT COUCHBASE_SERVER_BUILD) AND (NOT WIN32))
-        INCLUDE(CodeCoverage)
+if("${CMAKE_BUILD_TYPE}" STREQUAL "Coverage")
+    if((NOT COUCHBASE_SERVER_BUILD) AND (NOT WIN32))
+        include(cmake/Modules/CodeCoverage)
         SETUP_TARGET_FOR_COVERAGE(test_coverage ctest ${PROJECT_SOURCE_DIR}/coverage)
     endif((NOT COUCHBASE_SERVER_BUILD) AND (NOT WIN32))
 endif()
 
-if (("${CMAKE_BUILD_TYPE}" STREQUAL "Valgrind") AND (NOT WIN32))
-    INCLUDE(MemoryCheck)
+if(("${CMAKE_BUILD_TYPE}" STREQUAL "Valgrind") AND (NOT WIN32))
+    include(cmake/Modules/MemoryCheck)
     SETUP_TARGET_FOR_MEMCHECK(test_valgrind ${PROJECT_BINARY_DIR}/fdb_functional_test)
 endif()
 
-# add top-level testing dir
-enable_testing()
-add_subdirectory("${PROJECT_SOURCE_DIR}/tests")
+if(BUILD_TESTING)
+    add_subdirectory(tests)
+endif()
 
-if (COUCHBASE_SERVER_BUILD)
+if(COUCHBASE_SERVER_BUILD)
     ENABLE_CODE_COVERAGE_REPORT()
 endif()
diff --git a/INSTALL.md b/INSTALL.md
index 6fbcd4b3..ded5a381 100644
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -155,3 +155,14 @@ To run all the unit tests:
      `git clone https://github.com/couchbase/platform.git`
 
      `Follow the rest of the platform specific build instructions from above`
+
+
+
+Alternative build method - with Conan
+----------
+1. Install conan using one of the methods desribed here: https://conan.io/downloads
+1. `conan build .` - builds Release configuration
+1. `conan build . -s build_type=Debug` builds an alternative configuration supported by CMake
+1. You can control supported build options via command line as well, ex:
+    `conan build . -o build_tests=True`
+**NOTE**: this conan recipe supports conan **editable** mode which make it convenient to embedd this library in other projects built with conan
diff --git a/cmake/Modules/FindJemalloc.cmake b/cmake/Modules/FindJemalloc.cmake
index 1fae7cd1..02672f74 100644
--- a/cmake/Modules/FindJemalloc.cmake
+++ b/cmake/Modules/FindJemalloc.cmake
@@ -1,35 +1,35 @@
 # Locate jemalloc libraries on a host OS.
 
-IF (UNIX)
-    FIND_PATH(JEMALLOC_INCLUDE_DIR jemalloc/jemalloc.h
-              PATH_SUFFIXES include
-              PATHS
-                  ~/Library/Frameworks
-                  /Library/Frameworks
-                  /usr/local
-                  /opt/local
-                  /opt/csw
-                  /opt)
+if(UNIX)
+    find_path(JEMALLOC_INCLUDE_DIR jemalloc/jemalloc.h
+        PATH_SUFFIXES include
+        PATHS
+        ~/Library/Frameworks
+        /Library/Frameworks
+        /usr/local
+        /opt/local
+        /opt/csw
+        /opt)
 
-    FIND_LIBRARY(JEMALLOC_LIBRARIES
-                 NAMES jemalloc
-                 PATHS
-                     ~/Library/Frameworks
-                     /Library/Frameworks
-                     /usr/local
-                     /opt/local
-                     /opt/csw
-                     /opt)
-ELSEIF (WIN32)
-ENDIF()
+    find_library(JEMALLOC_LIBRARIES
+        NAMES jemalloc
+        PATHS
+        ~/Library/Frameworks
+        /Library/Frameworks
+        /usr/local
+        /opt/local
+        /opt/csw
+        /opt)
+elseif(WIN32)
+endif()
 
-IF (JEMALLOC_LIBRARIES)
-    MESSAGE(STATUS "Found jemalloc libraries in ${JEMALLOC_INCLUDE_DIR} :
+if(JEMALLOC_LIBRARIES)
+    message(STATUS "Found jemalloc libraries in ${JEMALLOC_INCLUDE_DIR} :
             ${JEMALLOC_LIBRARIES}")
-    ADD_DEFINITIONS(-D_JEMALLOC=1)
+    add_compile_definitions(HAVE_JEMALLOC=1)
     set(MALLOC_LIBRARIES ${JEMALLOC_LIBRARIES})
     include_directories(AFTER ${JEMALLOC_INCLUDE_DIR})
-    MARK_AS_ADVANCED(MALLOC_INCLUDE_DIR JEMALLOC_LIBRARIES)
-ELSE (JEMALLOC_LIBRARIES)
-    MESSAGE(FATAL_ERROR "Can't find jemalloc libraries")
-ENDIF (JEMALLOC_LIBRARIES)
+    mark_as_advanced(MALLOC_INCLUDE_DIR JEMALLOC_LIBRARIES)
+else()
+    message(FATAL_ERROR "Can't find jemalloc libraries")
+endif(JEMALLOC_LIBRARIES)
diff --git a/conanfile.py b/conanfile.py
new file mode 100644
index 00000000..53f7de6e
--- /dev/null
+++ b/conanfile.py
@@ -0,0 +1,85 @@
+import os
+
+from conan import ConanFile
+from conan.tools.cmake import cmake_layout, CMake, CMakeToolchain
+from conan.tools.files import copy
+from conan.tools.scm import Git
+
+required_conan_version = ">=2.12.2"
+
+'''
+Notes:
+Snappy is disabled.
+Build static lib only, no shared lib.
+Package contains bin forestdb_dump.
+'''
+class ForestdbConan(ConanFile):
+    name = "forestdb"
+    license = "Apache License 2.0"
+    description = "forestdb kv store"
+    homepage = "https://github.com/ForestDB-KVStore/forestdb"
+
+    generators = "CMakeDeps"
+    settings = "os", "compiler", "build_type", "arch"
+    options = {
+        "shared": [True,False],
+        "fPIC": [True, False],
+        "coverage": [True, False],
+        "with_snappy" : [True, False],
+        "with_jemalloc" : [True, False],
+        "build_tests": [True, False]
+    }
+    default_options = {
+        "shared": False,
+        "fPIC": True,
+        "coverage": False,
+        "with_snappy": False,
+        "with_jemalloc": False,
+        "build_tests": False
+    }
+
+    exports_sources = "CMakeLists.txt", "src/*", "include/*", "cmake/*", "tools/*", "LICENSE"
+
+    def requirements(self):
+        if self.options.with_snappy:
+            self.requires("snappy/[~1]")
+
+        if self.options.with_jemalloc:
+            self.requires("jemalloc/[*]")
+
+    def layout(self):
+        cmake_layout(self, generator="CMakeDeps")
+        self.cpp.package.libs = [self.name]
+
+        hash = Git(self).get_commit()
+        self.cpp.package.defines = self.cpp.build.defines = ["_FDB_COMMIT_HASH=%s" % hash]
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables["WITH_CONAN"] = True
+        tc.variables["CONAN_BUILD_COVERAGE"] = False
+        tc.variables["CODE_COVERAGE"] = self.options.coverage
+        tc.variables["SNAPPY_OPTION"] = self.options.with_snappy
+        tc.variables["_JEMALLOC"] = self.options.with_snappy
+        tc.variables["BUILD_TESTING"] = self.options.build_tests
+        tc.variables["CMAKE_VERBOSE_MAKEFILE"] = False
+        tc.variables["CMAKE_EXPORT_COMPILE_COMMANDS"] = True
+        tc.generate()
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+        if self.options.build_tests:
+            cmake.ctest()
+        copy(self, "compile_commands.json", self.build_folder, self.source_folder, keep_path=False)
+
+    def package(self):
+        cmake = CMake(self)
+        cmake.install()
+        assert copy(self, "LICENSE", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses")), "Copy failed"
+
+    def package_info(self):
+        self.cpp_info.system_libs.extend(["pthread", "m", "dl"])
+        if self.settings.os == "Linux":
+            self.cpp_info.system_libs.extend(["rt"])
\ No newline at end of file
diff --git a/tests/unit/CMakeLists.txt b/tests/unit/CMakeLists.txt
index 58a19330..1c453efd 100644
--- a/tests/unit/CMakeLists.txt
+++ b/tests/unit/CMakeLists.txt
@@ -185,7 +185,7 @@ add_executable(btree_str_kv_test
                ${ROOT_SRC}/avltree.cc
                ${GETTIMEOFDAY_VS}
                ${ROOT_UTILS}/memleak.cc)
-target_link_libraries(btree_str_kv_test  ${LIBM} ${MALLOC_LIBRARIES})
+target_link_libraries(btree_str_kv_test ${PTHREAD_LIB} ${LIBM} ${MALLOC_LIBRARIES})
 
 add_executable(btree_kv_test
                btree_kv_test.cc
@@ -193,7 +193,7 @@ add_executable(btree_kv_test
                ${ROOT_SRC}/avltree.cc
                ${GETTIMEOFDAY_VS}
                ${ROOT_UTILS}/memleak.cc)
-target_link_libraries(btree_kv_test ${LIBM} ${MALLOC_LIBRARIES})
+target_link_libraries(btree_kv_test ${PTHREAD_LIB} ${LIBM} ${MALLOC_LIBRARIES})
 
 # add test target
 add_test(hash_test hash_test)