diff --git a/tools/cmake/definitions.cmake b/tools/cmake/definitions.cmake
index 5668a69..6dfda8e 100644
--- a/tools/cmake/definitions.cmake
+++ b/tools/cmake/definitions.cmake
@@ -1,5 +1,5 @@
 if(WIN32)
-  add_compile_definitions(LIGHT_PLATFORM_WINDOWS)
+    add_compile_definitions(LIGHT_PLATFORM_WINDOWS)
 elseif(UNIX)
-  add_compile_definitions(LIGHT_PLATFORM_LINUX)
+    add_compile_definitions(LIGHT_PLATFORM_LINUX)
 endif()
diff --git a/tools/cmake/functions.cmake b/tools/cmake/functions.cmake
index d0622cb..0b838b8 100644
--- a/tools/cmake/functions.cmake
+++ b/tools/cmake/functions.cmake
@@ -1,157 +1,140 @@
-function (add_library_module libname)
+function(add_library_module libname)
     set(PUBLIC_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/public_includes")
     file(MAKE_DIRECTORY "${PUBLIC_INCLUDE_DIR}")
-    file(CREATE_LINK
-        "${CMAKE_CURRENT_SOURCE_DIR}/public/"
-        "${PUBLIC_INCLUDE_DIR}/${libname}"
-        SYMBOLIC
-    )
+    file(CREATE_LINK "${CMAKE_CURRENT_SOURCE_DIR}/public/"
+         "${PUBLIC_INCLUDE_DIR}/${libname}" SYMBOLIC)
 
-    if ("${ARGN}" STREQUAL "") # Header only library
+    if("${ARGN}" STREQUAL "") # Header only library
         message("Adding INTERFACE library ${libname}")
         add_library(${libname} INTERFACE)
         target_include_directories(${libname} INTERFACE ${PUBLIC_INCLUDE_DIR})
 
         target_link_libraries(${libname} INTERFACE std)
 
-    else () # Compiled library
+    else() # Compiled library
         set(source_files)
         set(source_directory "${CMAKE_CURRENT_SOURCE_DIR}/private")
-        foreach (source_file ${ARGN})
+        foreach(source_file ${ARGN})
             list(APPEND source_files "${source_directory}/${source_file}")
-        endforeach ()
+        endforeach()
 
         message("Adding library ${libname} with source files: ${source_files}")
         add_library(${libname} ${source_files})
 
         set(PRIVATE_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/private_includes")
         file(MAKE_DIRECTORY "${PRIVATE_INCLUDE_DIR}")
-        file(CREATE_LINK
-            "${CMAKE_CURRENT_SOURCE_DIR}/private/"
-            "${PRIVATE_INCLUDE_DIR}/${libname}"
-            SYMBOLIC
-        )
+        file(CREATE_LINK "${CMAKE_CURRENT_SOURCE_DIR}/private/"
+             "${PRIVATE_INCLUDE_DIR}/${libname}" SYMBOLIC)
 
-        target_include_directories(${libname} 
+        target_include_directories(
+            ${libname}
             PUBLIC ${PUBLIC_INCLUDE_DIR}
-            PRIVATE ${PRIVATE_INCLUDE_DIR}
-        )
+            PRIVATE ${PRIVATE_INCLUDE_DIR})
 
         target_link_libraries(${libname} PUBLIC std)
-    endif ()
+    endif()
 
-endfunction ()
+endfunction()
 
-function (add_executable_module exename)
+function(add_executable_module exename)
     set(source_files)
     set(source_directory "${CMAKE_CURRENT_SOURCE_DIR}/private")
-    foreach (source_file ${ARGN})
+    foreach(source_file ${ARGN})
         list(APPEND source_files "${source_directory}/${source_file}")
-    endforeach ()
+    endforeach()
 
     message("Adding executable ${exename} with source files: ${source_files}")
 
     set(PUBLIC_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/public_includes")
     file(MAKE_DIRECTORY "${PUBLIC_INCLUDE_DIR}")
-    file(CREATE_LINK
-        "${CMAKE_CURRENT_SOURCE_DIR}/public/"
-        "${PUBLIC_INCLUDE_DIR}/${exename}"
-        SYMBOLIC
-    )
+    file(CREATE_LINK "${CMAKE_CURRENT_SOURCE_DIR}/public/"
+         "${PUBLIC_INCLUDE_DIR}/${exename}" SYMBOLIC)
     set(PRIVATE_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/private_includes")
     file(MAKE_DIRECTORY "${PRIVATE_INCLUDE_DIR}")
-    file(CREATE_LINK
-        "${CMAKE_CURRENT_SOURCE_DIR}/private/"
-        "${PRIVATE_INCLUDE_DIR}${exename}"
-        SYMBOLIC
-    )
+    file(CREATE_LINK "${CMAKE_CURRENT_SOURCE_DIR}/private/"
+         "${PRIVATE_INCLUDE_DIR}${exename}" SYMBOLIC)
 
     add_executable(${exename} ${source_files})
     target_link_libraries(${exename} PRIVATE std)
-    target_include_directories(${exename} PRIVATE ${PUBLIC_INCLUDE_DIR} ${PRIVATE_INCLUDE_DIR})
-endfunction ()
+    target_include_directories(${exename} PRIVATE ${PUBLIC_INCLUDE_DIR}
+                                                  ${PRIVATE_INCLUDE_DIR})
+endfunction()
 
-function (add_test_module target_lib_name)
-    if (NOT ${ENABLE_UNIT_TESTS})
+function(add_test_module target_lib_name)
+    if(NOT ${ENABLE_UNIT_TESTS})
         return()
-    endif ()
+    endif()
 
     set(source_files)
     set(source_directory "${CMAKE_CURRENT_SOURCE_DIR}/private")
-    foreach (source_file ${ARGN})
+    foreach(source_file ${ARGN})
         list(APPEND source_files "${source_directory}/${source_file}")
-    endforeach ()
+    endforeach()
 
-    message("Adding test executable ${target_lib_name}_tests with source files: ${source_files}")
+    message(
+        "Adding test executable ${target_lib_name}_tests with source files: ${source_files}"
+    )
 
     set(PUBLIC_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/public_includes")
     file(MAKE_DIRECTORY "${PUBLIC_INCLUDE_DIR}")
-    file(CREATE_LINK
-        "${CMAKE_CURRENT_SOURCE_DIR}/public/"
-        "${PUBLIC_INCLUDE_DIR}/${target_lib_name}"
-        SYMBOLIC
-    )
+    file(CREATE_LINK "${CMAKE_CURRENT_SOURCE_DIR}/public/"
+         "${PUBLIC_INCLUDE_DIR}/${target_lib_name}" SYMBOLIC)
     set(PRIVATE_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/private_includes")
     file(MAKE_DIRECTORY "${PRIVATE_INCLUDE_DIR}")
-    file(CREATE_LINK
-        "${CMAKE_CURRENT_SOURCE_DIR}/private/"
-        "${PRIVATE_INCLUDE_DIR}/${target_lib_name}"
-        SYMBOLIC
-    )
+    file(CREATE_LINK "${CMAKE_CURRENT_SOURCE_DIR}/private/"
+         "${PRIVATE_INCLUDE_DIR}/${target_lib_name}" SYMBOLIC)
 
     add_executable(${target_lib_name}_tests ${source_files})
-    target_link_libraries(${target_lib_name}_tests PRIVATE ${target_lib_name} std test)
-    target_include_directories(${target_lib_name}_tests
+    target_link_libraries(${target_lib_name}_tests PRIVATE ${target_lib_name}
+                                                           std test)
+    target_include_directories(
+        ${target_lib_name}_tests
         PRIVATE ${PUBLIC_INCLUDE_DIR}
-        PRIVATE ${PRIVATE_INCLUDE_DIR}
-    )
-endfunction ()
+        PRIVATE ${PRIVATE_INCLUDE_DIR})
+endfunction()
 
-function (add_fuzz_module target_lib_name)
-    if (NOT ${ENABLE_FUZZ_TESTS})
+function(add_fuzz_module target_lib_name)
+    if(NOT ${ENABLE_FUZZ_TESTS})
         return()
-    endif ()
+    endif()
 
     set(source_files)
     set(source_directory "${CMAKE_CURRENT_SOURCE_DIR}/private")
-    foreach (source_file ${ARGN})
+    foreach(source_file ${ARGN})
         list(APPEND source_files "${source_directory}/${source_file}")
-    endforeach ()
+    endforeach()
 
-    message("Adding fuzz executable ${target_lib_name}_fuzz with source files: ${source_files}")
+    message(
+        "Adding fuzz executable ${target_lib_name}_fuzz with source files: ${source_files}"
+    )
 
     set(PUBLIC_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/public_includes")
     file(MAKE_DIRECTORY "${PUBLIC_INCLUDE_DIR}")
-    file(CREATE_LINK
-        "${CMAKE_CURRENT_SOURCE_DIR}/public/"
-        "${PUBLIC_INCLUDE_DIR}/${target_lib_name}"
-        SYMBOLIC
-    )
+    file(CREATE_LINK "${CMAKE_CURRENT_SOURCE_DIR}/public/"
+         "${PUBLIC_INCLUDE_DIR}/${target_lib_name}" SYMBOLIC)
     set(PRIVATE_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/private_includes")
     file(MAKE_DIRECTORY "${PRIVATE_INCLUDE_DIR}")
-    file(CREATE_LINK
-        "${CMAKE_CURRENT_SOURCE_DIR}/private/"
-        "${PRIVATE_INCLUDE_DIR}/${target_lib_name}"
-        SYMBOLIC
-    )
+    file(CREATE_LINK "${CMAKE_CURRENT_SOURCE_DIR}/private/"
+         "${PRIVATE_INCLUDE_DIR}/${target_lib_name}" SYMBOLIC)
 
     add_executable(${target_lib_name}_fuzz ${source_files})
-    target_link_libraries(${target_lib_name}_fuzz PRIVATE ${target_lib_name} std fuzz_test)
+    target_link_libraries(${target_lib_name}_fuzz PRIVATE ${target_lib_name}
+                                                          std fuzz_test)
     target_link_options(${target_lib_name}_fuzz PRIVATE -fsanitize=fuzzer)
     target_compile_options(${target_lib_name}_fuzz PRIVATE -fsanitize=fuzzer)
-    target_include_directories(${target_lib_name}_fuzz
+    target_include_directories(
+        ${target_lib_name}_fuzz
         PRIVATE ${PUBLIC_INCLUDE_DIR}
-        PRIVATE ${PRIVATE_INCLUDE_DIR}
-    )
-endfunction ()
+        PRIVATE ${PRIVATE_INCLUDE_DIR})
+endfunction()
 
-function (add_option option help)
+function(add_option option help)
     option(${option} ${help})
 
-    if (${option})
+    if(${option})
         message(STATUS "${option}: ON")
         add_compile_definitions(${option}=1)
-    else ()
+    else()
         message(STATUS "${option}: OFF")
-    endif ()
-endfunction ()
+    endif()
+endfunction()
diff --git a/tools/cmake/options.cmake b/tools/cmake/options.cmake
index c3b1dd3..bc298c8 100644
--- a/tools/cmake/options.cmake
+++ b/tools/cmake/options.cmake
@@ -1,32 +1,41 @@
 add_option(ENABLE_UNIT_TESTS "Enables the building of the unit test modules")
 add_option(ENABLE_FUZZ_TESTS "Enables the building of the fuzz test modules")
-add_option(ENABLE_STATIC_ANALYSIS "Makes the clang-tidy checks mandatory for compilation")
-add_option(ENABLE_LLVM_COVERAGE "Enables the code coverage instrumentation for clang")
+add_option(ENABLE_STATIC_ANALYSIS
+           "Makes the clang-tidy checks mandatory for compilation")
+add_option(ENABLE_LLVM_COVERAGE
+           "Enables the code coverage instrumentation for clang")
 
-if (ENABLE_STATIC_ANALYSIS)
-    set(CMAKE_CXX_CLANG_TIDY "clang-tidy;--warnings-as-errors=*;--allow-no-checks")
-endif ()
+if(ENABLE_STATIC_ANALYSIS)
+    set(CMAKE_CXX_CLANG_TIDY
+        "clang-tidy;--warnings-as-errors=*;--allow-no-checks")
+endif()
 
 if(ENABLE_LLVM_COVERAGE)
     include(CheckCXXSourceCompiles)
 
-    if (NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-        message(FATAL_ERROR "ENABLE_LLVM_COVERAGE only supports the clang compiler")
-    endif ()
+    if(NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+        message(
+            FATAL_ERROR "ENABLE_LLVM_COVERAGE only supports the clang compiler")
+    endif()
 
     # Check for libc++
-    check_cxx_source_compiles("
+    check_cxx_source_compiles(
+        "
         #include <string>
         #ifdef _LIBCPP_VERSION
         int main() { return 0; }
         #else
         #error Not using libc++
         #endif
-    " USING_LIBCXX)
+    "
+        USING_LIBCXX)
     if(NOT USING_LIBCXX)
-        message(FATAL_ERROR "ENABLE_LLVM_COVERAGE requires libc++, please compile with -stdlib=libc++")
+        message(
+            FATAL_ERROR
+                "ENABLE_LLVM_COVERAGE requires libc++, please compile with -stdlib=libc++"
+        )
     endif()
 
     add_compile_options(-fprofile-instr-generate -fcoverage-mapping)
     add_link_options(-fprofile-instr-generate -fcoverage-mapping)
-endif ()
+endif()