diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5ac7f77..4f474ae 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -11,7 +11,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, macos-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
         build_type: [Debug, Release]
         include:
           - os: ubuntu-latest
@@ -20,6 +20,9 @@ jobs:
           - os: macos-latest
             cc: clang
             cxx: clang++
+          - os: windows-latest
+            cc: cl
+            cxx: cl
 
     runs-on: ${{ matrix.os }}
 
@@ -27,42 +30,58 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v4
 
+      - name: Set up C environment (non-Linux)
+        if: runner.os != 'Linux'
+        uses: aminya/setup-cpp@v1
+        with:
+          compiler: ${{ runner.os == 'Windows' && 'msvc' || 'clang' }}
+          vcvarsall: ${{ runner.os == 'Windows' }}
+          cmake: true
+          ninja: true
+
       - name: Install dependencies (Ubuntu)
-        if: matrix.os == 'ubuntu-latest'
+        if: runner.os == 'Linux'
         run: |
           sudo apt-get update
-          sudo apt-get install -y build-essential cmake clang-format clang-tidy libzstd-dev libsodium-dev
+          sudo apt-get install -y build-essential cmake ninja-build clang-format clang-tidy libzstd-dev libsodium-dev
 
       - name: Install dependencies (macOS)
-        if: matrix.os == 'macos-latest'
+        if: runner.os == 'macOS'
         run: |
-          brew install clang-format zstd libsodium || true
-          # cmake is already available on macOS runners
+          brew install clang-format zstd libsodium ninja || true
 
-      - name: Set up environment
+      - name: Install dependencies (Windows)
+        if: runner.os == 'Windows'
+        shell: bash
         run: |
-          echo "CC=${{ matrix.cc }}" >> $GITHUB_ENV
-          echo "CXX=${{ matrix.cxx }}" >> $GITHUB_ENV
+          vcpkg install zstd:x64-windows libsodium:x64-windows
+          echo "VCPKG_ROOT=$VCPKG_INSTALLATION_ROOT" >> "$GITHUB_ENV"
 
       - name: Configure CMake
+        shell: bash
         run: |
+          TOOLCHAIN_ARG=""
+          if [ "${{ runner.os }}" == "Windows" ]; then
+            TOOLCHAIN_ARG="-DCMAKE_TOOLCHAIN_FILE=$VCPKG_INSTALLATION_ROOT/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-windows -DBFC_BUILD_BENCHMARKS=OFF"
+          fi
           cmake -B build \
             -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} \
-            -DCMAKE_C_COMPILER=${{ matrix.cc }} \
-            -DCMAKE_CXX_COMPILER=${{ matrix.cxx }} \
             -DBFC_WITH_ZSTD=ON \
-            -DBFC_WITH_SODIUM=ON
+            -DBFC_WITH_SODIUM=ON \
+            $TOOLCHAIN_ARG
 
       - name: Build
-        run: cmake --build build --config ${{ matrix.build_type }} -j$(nproc 2>/dev/null || sysctl -n hw.ncpu)
+        run: cmake --build build --config ${{ matrix.build_type }} -j4
 
       - name: Run tests
         if: matrix.build_type == 'Debug'
+        shell: bash
         run: |
           cd build
-          ctest --output-on-failure --parallel $(nproc 2>/dev/null || sysctl -n hw.ncpu)
+          ctest --output-on-failure -C ${{ matrix.build_type }} --parallel 4
 
-      - name: Test CLI functionality
+      - name: Test CLI functionality (Unix)
+        if: matrix.os != 'windows-latest'
         run: |
           # Create test data
           mkdir -p test_data
@@ -218,7 +237,50 @@ jobs:
           rm -rf test.bfc test_data test_compressed.bfc test_fast.bfc test_balanced.bfc
           rm -rf test_encrypted.bfc test_keyfile.bfc test_enc_comp.bfc test.key
 
+      - name: Test CLI functionality (Windows)
+        if: runner.os == 'Windows'
+        shell: bash
+        run: |
+          BFC=$(find build/bin -name "bfc.exe" | head -1)
+          [ -z "$BFC" ] && { echo "bfc.exe not found"; exit 1; }
+
+          mkdir -p test_data/subdir
+          echo "Hello World" > test_data/hello.txt
+          echo "Goodbye"     > test_data/bye.txt
+          echo "Nested file" > test_data/subdir/nested.txt
+
+          "$BFC" create test.bfc test_data/
+          "$BFC" list test.bfc
+          "$BFC" info test.bfc
+          "$BFC" verify test.bfc
+          "$BFC" verify --deep test.bfc
+
+          "$BFC" create -c zstd test_compressed.bfc test_data/
+          "$BFC" info test_compressed.bfc test_data/hello.txt
+          "$BFC" verify test_compressed.bfc
+
+          mkdir extract_test && cd extract_test
+          "$OLDPWD/$BFC" extract ../test.bfc
+          [ -f hello.txt ]          && echo "hello.txt extracted"
+          [ -f bye.txt ]            && echo "bye.txt extracted"
+          [ -f subdir/nested.txt ]  && echo "nested.txt extracted"
+          cd ..
+
+          "$BFC" create -e testpassword123 test_encrypted.bfc test_data/
+          mkdir extract_enc && cd extract_enc
+          "$OLDPWD/$BFC" extract -p testpassword123 ../test_encrypted.bfc
+          [ -f hello.txt ] && echo "hello.txt extracted from encrypted container"
+          cd ..
+
+          mkdir extract_fail && cd extract_fail
+          "$OLDPWD/$BFC" extract -p wrongpassword ../test_encrypted.bfc 2>&1 && true
+          [ $? -ne 0 ] && echo "Correctly failed with wrong password" || true
+          cd ..
+
+          rm -rf test_data test.bfc test_compressed.bfc test_encrypted.bfc extract_enc extract_fail
+
       - name: Run benchmarks
+        if: matrix.os != 'windows-latest'
         run: |
           cd build/benchmarks
           ./benchmark_crc32c
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index eb40086..2d533af 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -29,6 +29,11 @@ jobs:
             cc: clang
             cxx: clang++
             platform: macos
+          - os: windows-latest
+            arch: x86_64
+            cc: cl
+            cxx: cl
+            platform: windows
 
     runs-on: ${{ matrix.os }}
 
@@ -51,7 +56,14 @@ jobs:
           # Install create-dmg for DMG creation, zstd for compression, and libsodium for encryption
           brew install create-dmg zstd libsodium
 
-      - name: Build Release
+      - name: Install dependencies (Windows)
+        if: matrix.platform == 'windows'
+        run: |
+          vcpkg install zstd:x64-windows libsodium:x64-windows
+          echo "VCPKG_ROOT=$env:VCPKG_INSTALLATION_ROOT" >> $env:GITHUB_ENV
+
+      - name: Build Release (non-Windows)
+        if: matrix.platform != 'windows'
         env:
           CC: ${{ matrix.cc }}
           CXX: ${{ matrix.cxx }}
@@ -66,12 +78,32 @@ jobs:
 
           cmake --build build --config Release -j$(nproc 2>/dev/null || sysctl -n hw.ncpu)
 
-      - name: Run tests
+      - name: Build Release (Windows)
+        if: matrix.platform == 'windows'
+        run: |
+          cmake -B build `
+            -DCMAKE_BUILD_TYPE=Release `
+            -DCMAKE_TOOLCHAIN_FILE="$env:VCPKG_INSTALLATION_ROOT/scripts/buildsystems/vcpkg.cmake" `
+            -DVCPKG_TARGET_TRIPLET=x64-windows `
+            -DBFC_WITH_ZSTD=ON `
+            -DBFC_WITH_SODIUM=ON `
+            -DBFC_BUILD_BENCHMARKS=OFF
+          cmake --build build --config Release -j4
+
+      - name: Run tests (non-Windows)
+        if: matrix.platform != 'windows'
         run: |
           cd build
           ctest --output-on-failure
 
-      - name: Test CLI functionality
+      - name: Run tests (Windows)
+        if: matrix.platform == 'windows'
+        run: |
+          cd build
+          ctest --output-on-failure -C Release
+
+      - name: Test CLI functionality (non-Windows)
+        if: matrix.platform != 'windows'
         run: |
           # Create test data
           mkdir -p test_data
@@ -158,11 +190,50 @@ jobs:
           rm -rf test.bfc test_data test_compressed.bfc test_fast.bfc test_balanced.bfc
           rm -rf test_encrypted.bfc test_keyfile.bfc test_enc_comp.bfc test.key
 
+      - name: Test CLI functionality (Windows)
+        if: matrix.platform == 'windows'
+        shell: pwsh
+        run: |
+          New-Item -ItemType Directory -Force test_data\subdir | Out-Null
+          "Hello World" | Out-File -Encoding utf8 test_data\hello.txt
+          "Goodbye"     | Out-File -Encoding utf8 test_data\bye.txt
+          "Nested file" | Out-File -Encoding utf8 test_data\subdir\nested.txt
+
+          $bfc = Get-ChildItem -Recurse build\bin -Filter bfc.exe | Select-Object -First 1 -ExpandProperty FullName
+          if (-not $bfc) { Write-Error "bfc.exe not found"; exit 1 }
+
+          & $bfc create test.bfc test_data\
+          & $bfc list test.bfc
+          & $bfc info test.bfc
+          & $bfc verify test.bfc
+          & $bfc verify --deep test.bfc
+
+          & $bfc create -c zstd test_compressed.bfc test_data\
+          & $bfc verify test_compressed.bfc
+
+          New-Item -ItemType Directory -Force extract_test | Out-Null
+          Push-Location extract_test
+          & $bfc extract ..\test.bfc
+          if (Test-Path hello.txt) { Write-Output "hello.txt extracted" }
+          Pop-Location
+          Remove-Item -Recurse -Force extract_test
+
+          & $bfc create -e testpassword123 test_encrypted.bfc test_data\
+          New-Item -ItemType Directory -Force extract_enc | Out-Null
+          Push-Location extract_enc
+          & $bfc extract -p testpassword123 ..\test_encrypted.bfc
+          if (Test-Path hello.txt) { Write-Output "hello.txt extracted from encrypted container" }
+          Pop-Location
+          Remove-Item -Recurse -Force extract_enc
+
+          Remove-Item -Recurse -Force test_data, test.bfc, test_compressed.bfc, test_encrypted.bfc -ErrorAction SilentlyContinue
+
       - name: Get version
         id: get_version
         run: echo "version=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
 
-      - name: Create release package
+      - name: Create release package (non-Windows)
+        if: matrix.platform != 'windows'
         run: |
           VERSION=${{ steps.get_version.outputs.version }}
           PACKAGE_NAME=bfc-${VERSION#v}-${{ matrix.platform }}-${{ matrix.arch }}
@@ -216,6 +287,42 @@ jobs:
           # Create tarball
           tar -czf ${PACKAGE_NAME}.tar.gz ${PACKAGE_NAME}
 
+      - name: Create release package (Windows)
+        if: matrix.platform == 'windows'
+        shell: pwsh
+        run: |
+          $version = "${{ steps.get_version.outputs.version }}"
+          $versionNoV = $version.TrimStart('v')
+          $pkgName = "bfc-$versionNoV-windows-x86_64"
+
+          New-Item -ItemType Directory -Force $pkgName | Out-Null
+
+          # Find and copy binaries
+          $bfcExe = Get-ChildItem -Recurse build\bin -Filter bfc.exe | Select-Object -First 1 -ExpandProperty FullName
+          Copy-Item $bfcExe "$pkgName\bfc.exe"
+          Copy-Item (Get-ChildItem -Recurse build\lib -Filter bfc.lib | Select-Object -First 1 -ExpandProperty FullName) "$pkgName\bfc.lib"
+          Copy-Item (Get-ChildItem -Recurse build\lib -Filter bfc.dll -ErrorAction SilentlyContinue | Select-Object -First 1 -ExpandProperty FullName) "$pkgName\bfc.dll" -ErrorAction SilentlyContinue
+
+          # Copy headers and docs
+          Copy-Item include\bfc.h "$pkgName\"
+          Copy-Item README.md "$pkgName\"
+          Copy-Item LICENSE "$pkgName\"
+
+          # Create install script
+          @'
+          @echo off
+          echo Installing BFC...
+          copy bfc.exe "%ProgramFiles%\bfc\bfc.exe" 2>nul || (
+            mkdir "%ProgramFiles%\bfc"
+            copy bfc.exe "%ProgramFiles%\bfc\bfc.exe"
+          )
+          copy bfc.h "%ProgramFiles%\bfc\bfc.h"
+          echo BFC installed to %ProgramFiles%\bfc
+          '@ | Out-File -Encoding ascii "$pkgName\install.bat"
+
+          # Create ZIP
+          Compress-Archive -Path $pkgName -DestinationPath "$pkgName.zip"
+
       - name: Create DEB and RPM packages (Linux only)
         if: matrix.platform == 'linux'
         run: |
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d8dd097..5064c25 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -39,11 +39,17 @@ if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Werror")
     set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g -O0 -fsanitize=address,undefined")
     set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O3 -DNDEBUG")
-    
+
     if(BFC_COVERAGE)
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage")
         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
     endif()
+elseif(MSVC)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4 /WX /wd4996")
+    set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Od /Zi /RTC1")
+    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /O2 /DNDEBUG")
+    # Disable sanitizers on MSVC (not supported the same way)
+    add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
 endif()
 
 # Find dependencies
diff --git a/README.md b/README.md
index f996d97..bfd5876 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,7 @@ A high-performance, single-file container format for storing files and directori
 - **Optional compression** - ZSTD compression with intelligent content analysis
 - **Optional encryption** - ChaCha20-Poly1305 AEAD with Argon2id key derivation
 - **Integrity validation** - CRC32C checksums with hardware acceleration
-- **Cross-platform** - Works on Linux, macOS, FreeBSD, and other Unix systems
+- **Cross-platform** - Works on Linux, macOS, FreeBSD, and Windows (MSVC/MinGW-w64)
 - **Crash-safe writes** - Atomic container creation with index at EOF
 - **Memory efficient** - Optimized for large containers and small memory footprint
 
@@ -46,14 +46,14 @@ cmake --build build
 
 ### Prerequisites
 
-- C17 compatible compiler (GCC 7+, Clang 6+)
+- C17 compatible compiler (GCC 7+, Clang 6+, or MSVC 2019+)
 - CMake 3.15+
-- POSIX-compliant system
 
 **Optional dependencies:**
 - ZSTD library for compression support
 - libsodium for encryption support
-- pkg-config (or pkgconf on FreeBSD) for dependency detection
+- pkg-config (or pkgconf on FreeBSD/Linux) for dependency detection on Unix
+- vcpkg for dependency management on Windows
 
 ### Build from source
 
@@ -87,6 +87,32 @@ cmake -B build -DCMAKE_BUILD_TYPE=Release -DBFC_WITH_ZSTD=ON -DBFC_WITH_SODIUM=O
 make -C build
 ```
 
+**Windows (MSVC) setup:**
+
+```powershell
+# Install dependencies via vcpkg
+vcpkg install zstd:x64-windows libsodium:x64-windows
+
+# Configure with vcpkg toolchain
+cmake -B build `
+  -DCMAKE_TOOLCHAIN_FILE="$env:VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake" `
+  -DVCPKG_TARGET_TRIPLET=x64-windows `
+  -DBFC_WITH_ZSTD=ON `
+  -DBFC_WITH_SODIUM=ON
+
+# Build
+cmake --build build --config Release
+
+# Run
+.\build\bin\Release\bfc.exe create archive.bfc path\to\files\
+```
+
+> **Windows notes:**
+> - Symlink creation requires Developer Mode or elevated privileges; symlinks stored in
+>   containers are extracted as regular files on Windows without Developer Mode.
+> - FUSE mount (`BFC_WITH_FUSE`) is not supported on Windows.
+> - MinGW-w64 is also supported; use the standard Unix cmake/make flow with the MinGW generator.
+
 ### Build options
 
 ```bash
diff --git a/benchmarks/benchmark_all.c b/benchmarks/benchmark_all.c
index dc09b1f..36c8dba 100644
--- a/benchmarks/benchmark_all.c
+++ b/benchmarks/benchmark_all.c
@@ -14,12 +14,15 @@
  * limitations under the License.
  */
 
+#include <bfc_os.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/utsname.h>
 #include <time.h>
+#ifndef _WIN32
+#include <sys/utsname.h>
 #include <unistd.h>
+#endif
 
 // External benchmark functions
 extern int benchmark_crc32c_main(void);
@@ -29,11 +32,15 @@ extern int benchmark_reader_main(void);
 static void print_system_info(void) {
   printf("=== System Information ===\n");
 
+#ifndef _WIN32
   struct utsname info;
   if (uname(&info) == 0) {
     printf("System: %s %s %s\n", info.sysname, info.release, info.machine);
     printf("Node: %s\n", info.nodename);
   }
+#else
+  printf("System: Windows\n");
+#endif
 
   printf("Compiler: ");
 #ifdef __clang__
diff --git a/benchmarks/benchmark_compress.c b/benchmarks/benchmark_compress.c
index 0e56df6..7a4f7e7 100644
--- a/benchmarks/benchmark_compress.c
+++ b/benchmarks/benchmark_compress.c
@@ -16,13 +16,16 @@
 
 #define _GNU_SOURCE
 #include <bfc.h>
+#include <bfc_os.h>
 #include "benchmark_common.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <time.h>
+#ifndef _WIN32
 #include <unistd.h>
+#endif
 
 // Generate compressible content (repeated patterns)
 static void generate_compressible_content(char *buffer, size_t size) {
diff --git a/benchmarks/benchmark_crc32c.c b/benchmarks/benchmark_crc32c.c
index 3e035b4..e3bd019 100644
--- a/benchmarks/benchmark_crc32c.c
+++ b/benchmarks/benchmark_crc32c.c
@@ -15,12 +15,16 @@
  */
 
 #define _GNU_SOURCE
+#include <bfc_os.h>
 #include "bfc_crc32c.h"
 #include "benchmark_common.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
+#ifndef _WIN32
+#include <unistd.h>
+#endif
 
 static int benchmark_crc32c_small_chunks(void)
 {
@@ -43,7 +47,11 @@ static int benchmark_crc32c_small_chunks(void)
     bfc_crc32c_ctx_t ctx;
     struct timespec start, end;
 
+#ifdef _WIN32
+    clock_gettime(CLOCK_REALTIME, &start);
+#else
     clock_gettime(CLOCK_MONOTONIC, &start);
+#endif
 
     uint32_t final_crc = 0;
     for (int i = 0; i < iterations; i++)
@@ -53,7 +61,11 @@ static int benchmark_crc32c_small_chunks(void)
         final_crc = bfc_crc32c_final(&ctx);
     }
 
+#ifdef _WIN32
+    clock_gettime(CLOCK_REALTIME, &end);
+#else
     clock_gettime(CLOCK_MONOTONIC, &end);
+#endif
 
     free(data);
 
@@ -89,7 +101,11 @@ static int benchmark_crc32c_large_chunks(void)
     bfc_crc32c_ctx_t ctx;
     struct timespec start, end;
 
+#ifdef _WIN32
+    clock_gettime(CLOCK_REALTIME, &start);
+#else
     clock_gettime(CLOCK_MONOTONIC, &start);
+#endif
 
     uint32_t final_crc = 0;
     for (int i = 0; i < iterations; i++)
@@ -104,7 +120,11 @@ static int benchmark_crc32c_large_chunks(void)
         }
     }
 
+#ifdef _WIN32
+    clock_gettime(CLOCK_REALTIME, &end);
+#else
     clock_gettime(CLOCK_MONOTONIC, &end);
+#endif
 
     free(data);
 
@@ -141,7 +161,11 @@ static int benchmark_crc32c_streaming(void)
     bfc_crc32c_ctx_t ctx;
     struct timespec start, end;
 
+#ifdef _WIN32
+    clock_gettime(CLOCK_REALTIME, &start);
+#else
     clock_gettime(CLOCK_MONOTONIC, &start);
+#endif
 
     bfc_crc32c_reset(&ctx);
 
@@ -157,7 +181,11 @@ static int benchmark_crc32c_streaming(void)
 
     uint32_t final_crc = bfc_crc32c_final(&ctx);
 
+#ifdef _WIN32
+    clock_gettime(CLOCK_REALTIME, &end);
+#else
     clock_gettime(CLOCK_MONOTONIC, &end);
+#endif
 
     free(chunk);
 
@@ -201,7 +229,11 @@ static int benchmark_crc32c_alignment(void)
         bfc_crc32c_ctx_t ctx;
         struct timespec start, end;
 
-        clock_gettime(CLOCK_MONOTONIC, &start);
+    #ifdef _WIN32
+    clock_gettime(CLOCK_REALTIME, &start);
+#else
+    clock_gettime(CLOCK_MONOTONIC, &start);
+#endif
 
         uint32_t final_crc = 0;
         for (int i = 0; i < iterations; i++)
@@ -211,7 +243,11 @@ static int benchmark_crc32c_alignment(void)
             final_crc = bfc_crc32c_final(&ctx);
         }
 
-        clock_gettime(CLOCK_MONOTONIC, &end);
+    #ifdef _WIN32
+    clock_gettime(CLOCK_REALTIME, &end);
+#else
+    clock_gettime(CLOCK_MONOTONIC, &end);
+#endif
 
         double elapsed = benchmark_time_diff(&start, &end);
         uint64_t total_bytes = (uint64_t)iterations * chunk_size;
diff --git a/benchmarks/benchmark_reader.c b/benchmarks/benchmark_reader.c
index b9c6fa8..c665589 100644
--- a/benchmarks/benchmark_reader.c
+++ b/benchmarks/benchmark_reader.c
@@ -16,13 +16,16 @@
 
 #define _GNU_SOURCE
 #include <bfc.h>
+#include <bfc_os.h>
 #include "benchmark_common.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <time.h>
+#ifndef _WIN32
 #include <unistd.h>
+#endif
 
 // Create a test container for reading benchmarks
 static int create_test_container(const char *container, int num_files, size_t file_size)
diff --git a/benchmarks/benchmark_writer.c b/benchmarks/benchmark_writer.c
index eeb20cf..67436fd 100644
--- a/benchmarks/benchmark_writer.c
+++ b/benchmarks/benchmark_writer.c
@@ -16,13 +16,16 @@
 
 #define _GNU_SOURCE
 #include <bfc.h>
+#include <bfc_os.h>
 #include "benchmark_common.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <time.h>
+#ifndef _WIN32
 #include <unistd.h>
+#endif
 
 static int benchmark_small_files(void)
 {
@@ -225,7 +228,7 @@ static int benchmark_mixed_workload(void)
     // Create directory structure with files
     for (int dir = 0; dir < 50; dir++)
     {
-        char dir_path[512];
+        char dir_path[32];
         snprintf(dir_path, sizeof(dir_path), "dir_%03d", dir);
 
         result = bfc_add_dir(writer, dir_path, 0755, 0);
@@ -233,7 +236,7 @@ static int benchmark_mixed_workload(void)
             break;
 
         // Add subdirectory
-        char subdir_path[512];
+        char subdir_path[64];
         snprintf(subdir_path, sizeof(subdir_path), "%s/subdir", dir_path);
         result = bfc_add_dir(writer, subdir_path, 0755, 0);
         if (result != BFC_OK)
@@ -242,7 +245,7 @@ static int benchmark_mixed_workload(void)
         // Add files of varying sizes
         for (int file = 0; file < 20; file++)
         {
-            char file_path[512];
+            char file_path[64];
             snprintf(file_path, sizeof(file_path), "%s/file_%03d.txt", dir_path, file);
 
             // Vary file sizes: 1KB to 1MB
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index da061d1..c47fdbd 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -20,20 +20,29 @@ target_link_libraries(create_example bfc)
 target_include_directories(create_example PRIVATE ${CMAKE_SOURCE_DIR}/include)
 
 # Read example - demonstrates container reading and listing
-add_executable(read_example read_example.c)  
+add_executable(read_example read_example.c)
 target_link_libraries(read_example bfc)
-target_include_directories(read_example PRIVATE ${CMAKE_SOURCE_DIR}/include)
+target_include_directories(read_example PRIVATE
+    ${CMAKE_SOURCE_DIR}/include
+    ${CMAKE_SOURCE_DIR}/src/lib
+)
 
 # Extract example - demonstrates file extraction
 add_executable(extract_example extract_example.c)
 target_link_libraries(extract_example bfc)
-target_include_directories(extract_example PRIVATE ${CMAKE_SOURCE_DIR}/include)
+target_include_directories(extract_example PRIVATE
+    ${CMAKE_SOURCE_DIR}/include
+    ${CMAKE_SOURCE_DIR}/src/lib
+)
 
 # Encrypt example - demonstrates encryption/decryption (requires libsodium)
 if(BFC_WITH_SODIUM)
     add_executable(encrypt_example encrypt_example.c)
     target_link_libraries(encrypt_example bfc)
-    target_include_directories(encrypt_example PRIVATE ${CMAKE_SOURCE_DIR}/include)
+    target_include_directories(encrypt_example PRIVATE
+        ${CMAKE_SOURCE_DIR}/include
+        ${CMAKE_SOURCE_DIR}/src/lib
+    )
 endif()
 
 # Configure optional dependencies for all examples
diff --git a/examples/encrypt_example.c b/examples/encrypt_example.c
index 19fc111..0d22c7b 100644
--- a/examples/encrypt_example.c
+++ b/examples/encrypt_example.c
@@ -29,13 +29,17 @@
  */
 
 #include <bfc.h>
+#ifdef _WIN32
+#include <bfc_win32_compat.h>
+#else
+#include <unistd.h>
+#endif
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <time.h>
-#include <unistd.h>
 
 // Extraction context for callback
 typedef struct {
diff --git a/examples/extract_example.c b/examples/extract_example.c
index c9f9fd0..ef6efcf 100644
--- a/examples/extract_example.c
+++ b/examples/extract_example.c
@@ -16,6 +16,7 @@
 
 #define _GNU_SOURCE
 #include <bfc.h>
+#include <bfc_os.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
@@ -23,7 +24,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
+#ifndef _WIN32
 #include <unistd.h>
+#endif
 
 // Callback to collect all file entries for extraction
 struct extract_context {
diff --git a/examples/read_example.c b/examples/read_example.c
index a4caeb4..4ebc0ed 100644
--- a/examples/read_example.c
+++ b/examples/read_example.c
@@ -16,6 +16,7 @@
 
 #define _GNU_SOURCE
 #include <bfc.h>
+#include <bfc_os.h>
 #include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/src/cli/CMakeLists.txt b/src/cli/CMakeLists.txt
index 11c6980..5e6f125 100644
--- a/src/cli/CMakeLists.txt
+++ b/src/cli/CMakeLists.txt
@@ -44,6 +44,12 @@ target_include_directories(bfc_cli PRIVATE
     ${CMAKE_SOURCE_DIR}/src/lib
 )
 
+# S_ISSOCK, S_ISVTX and other GNU extensions require _GNU_SOURCE on Linux glibc.
+# Defined via compile definitions so it precedes any system header inclusion.
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    target_compile_definitions(bfc_cli PRIVATE _GNU_SOURCE)
+endif()
+
 # Set output name to 'bfc' and directory
 set_target_properties(bfc_cli PROPERTIES 
     OUTPUT_NAME bfc
diff --git a/src/cli/cli.h b/src/cli/cli.h
index 3418adf..5cc6ab6 100644
--- a/src/cli/cli.h
+++ b/src/cli/cli.h
@@ -19,6 +19,12 @@
 
 #include <bfc.h>
 
+#ifdef _WIN32
+#include "cli_win32_compat.h"
+#else
+#include <sys/stat.h>
+#endif
+
 // Command handler function type
 typedef int (*cmd_handler_t)(int argc, char* argv[]);
 
diff --git a/src/cli/cli_win32_compat.h b/src/cli/cli_win32_compat.h
new file mode 100644
index 0000000..f6deb0a
--- /dev/null
+++ b/src/cli/cli_win32_compat.h
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2021 zombocoder (Taras Havryliak)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#ifdef _WIN32
+
+#include "../lib/bfc_win32_compat.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// dirname replacement
+static char* dirname(char* path) {
+  static char buffer[MAX_PATH];
+  if (!path || !*path) {
+    strcpy(buffer, ".");
+    return buffer;
+  }
+
+  char* last_slash = strrchr(path, '/');
+  char* last_backslash = strrchr(path, '\\');
+  char* sep = (last_slash > last_backslash) ? last_slash : last_backslash;
+
+  if (!sep) {
+    strcpy(buffer, ".");
+  } else if (sep == path) {
+    strcpy(buffer, "/");
+  } else {
+    size_t len = sep - path;
+    if (len >= MAX_PATH)
+      len = MAX_PATH - 1;
+    strncpy(buffer, path, len);
+    buffer[len] = '\0';
+  }
+  return buffer;
+}
+
+// POSIX function mappings for Windows
+#define chdir _chdir
+#define lstat stat
+#define symlink(target, linkpath) (-1)        // Not supported for now
+#define lutimes(path, tv) (0)                 // Stub
+#define futimens(fd, ts) (0)                  // Stub
+#define utimensat(dirfd, path, ts, flags) (0) // Stub
+#define fchmod(fd, mode) (0)                  // Stub
+#define chmod _chmod
+
+// dirent.h basic replacement for Windows
+typedef struct dirent {
+  char d_name[MAX_PATH];
+} dirent_t;
+
+typedef struct DIR {
+  HANDLE hFind;
+  WIN32_FIND_DATA findData;
+  struct dirent ent;
+  int first;
+} DIR;
+
+static DIR* opendir(const char* name) {
+  DIR* dir = (DIR*) malloc(sizeof(DIR));
+  char searchPath[MAX_PATH];
+  snprintf(searchPath, MAX_PATH, "%s/*", name);
+  dir->hFind = FindFirstFile(searchPath, &dir->findData);
+  if (dir->hFind == INVALID_HANDLE_VALUE) {
+    free(dir);
+    return NULL;
+  }
+  dir->first = 1;
+  return dir;
+}
+
+static struct dirent* readdir(DIR* dir) {
+  if (dir->first) {
+    dir->first = 0;
+  } else {
+    if (!FindNextFile(dir->hFind, &dir->findData)) {
+      return NULL;
+    }
+  }
+  strncpy(dir->ent.d_name, dir->findData.cFileName, MAX_PATH);
+  return &dir->ent;
+}
+
+static int closedir(DIR* dir) {
+  FindClose(dir->hFind);
+  free(dir);
+  return 0;
+}
+
+#endif // _WIN32
diff --git a/src/cli/cmd_create.c b/src/cli/cmd_create.c
index 5b6d2fa..e407bf0 100644
--- a/src/cli/cmd_create.c
+++ b/src/cli/cmd_create.c
@@ -14,16 +14,17 @@
  * limitations under the License.
  */
 
-#define _GNU_SOURCE
 #include "cli.h"
+#ifndef _WIN32
 #include <dirent.h>
+#include <unistd.h>
+#endif
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
-#include <unistd.h>
 
 #ifdef BFC_WITH_SODIUM
 // Function to read encryption key from file
@@ -233,6 +234,7 @@ static int add_file_to_container(bfc_t* writer, const char* file_path, const cha
   return 0;
 }
 
+#ifndef _WIN32
 static int add_symlink_to_container(bfc_t* writer, const char* link_path,
                                     const char* container_path) {
   print_verbose("Adding symlink: %s -> %s", link_path, container_path);
@@ -268,6 +270,7 @@ static int add_symlink_to_container(bfc_t* writer, const char* link_path,
 
   return 0;
 }
+#endif
 
 static int add_directory_to_container(bfc_t* writer, const char* dir_path,
                                       const char* container_path);
@@ -296,7 +299,12 @@ static int process_directory_entry(bfc_t* writer, const char* base_path, const c
   } else if (S_ISDIR(st.st_mode)) {
     return add_directory_to_container(writer, full_path, container_path);
   } else if (S_ISLNK(st.st_mode)) {
+#ifndef _WIN32
     return add_symlink_to_container(writer, full_path, container_path);
+#else
+    print_verbose("Skipping symlink on Windows: %s", full_path);
+    return 0;
+#endif
   } else {
     print_verbose("Skipping special file: %s", full_path);
     return 0;
@@ -488,10 +496,14 @@ int cmd_create(int argc, char* argv[]) {
         return 1;
       }
     } else if (S_ISLNK(st.st_mode)) {
+#ifndef _WIN32
       if (add_symlink_to_container(writer, input_path, basename) != 0) {
         bfc_close(writer);
         return 1;
       }
+#else
+      print_verbose("Skipping symlink on Windows: %s", input_path);
+#endif
     } else {
       print_error("'%s' is not a regular file, directory, or symlink", input_path);
       bfc_close(writer);
diff --git a/src/cli/cmd_extract.c b/src/cli/cmd_extract.c
index 117587f..f9d52d5 100644
--- a/src/cli/cmd_extract.c
+++ b/src/cli/cmd_extract.c
@@ -14,18 +14,19 @@
  * limitations under the License.
  */
 
-#define _GNU_SOURCE
 #include "cli.h"
+#ifndef _WIN32
+#include <libgen.h>
+#include <sys/time.h>
+#include <unistd.h>
+#endif
 #include <errno.h>
 #include <fcntl.h>
-#include <libgen.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
-#include <sys/time.h>
 #include <time.h>
-#include <unistd.h>
 
 #ifdef BFC_WITH_SODIUM
 static int read_key_from_file(const char* filename, uint8_t key[32]) {
@@ -168,28 +169,32 @@ static int create_parent_directories(const char* path, int force) {
     return 0;
   }
 
-  struct stat st;
-  if (stat(dir, &st) == 0) {
-    if (!S_ISDIR(st.st_mode)) {
-      print_error("'%s' exists but is not a directory", dir);
-      free(path_copy);
-      return -1;
-    }
-    free(path_copy);
-    return 0;
-  }
-
-  // Recursively create parent directories
+  // Recursively create parent directories first
   if (create_parent_directories(dir, force) != 0) {
     free(path_copy);
     return -1;
   }
 
   print_verbose("Creating directory: %s", dir);
+#ifdef _WIN32
+  if (mkdir(dir) != 0) {
+#else
   if (mkdir(dir, 0755) != 0) {
-    print_error("Cannot create directory '%s': %s", dir, strerror(errno));
-    free(path_copy);
-    return -1;
+#endif
+    if (errno == EEXIST) {
+      // Directory already exists - verify it is actually a directory
+      struct stat st;
+      if (stat(dir, &st) != 0 || !S_ISDIR(st.st_mode)) {
+        print_error("'%s' exists but is not a directory", dir);
+        free(path_copy);
+        return -1;
+      }
+      // Already a directory, that is fine
+    } else {
+      print_error("Cannot create directory '%s': %s", dir, strerror(errno));
+      free(path_copy);
+      return -1;
+    }
   }
 
   free(path_copy);
@@ -198,13 +203,6 @@ static int create_parent_directories(const char* path, int force) {
 
 static int extract_file(bfc_t* reader, const bfc_entry_t* entry, const char* output_path,
                         int force) {
-  // Check if file exists
-  struct stat st;
-  if (stat(output_path, &st) == 0 && !force) {
-    print_error("File '%s' already exists. Use -f to overwrite.", output_path);
-    return -1;
-  }
-
   // Create parent directories
   if (create_parent_directories(output_path, force) != 0) {
     return -1;
@@ -212,10 +210,21 @@ static int extract_file(bfc_t* reader, const bfc_entry_t* entry, const char* out
 
   print_verbose("Extracting file: %s -> %s", entry->path, output_path);
 
-  // Open output file
-  int fd = open(output_path, O_WRONLY | O_CREAT | O_TRUNC, entry->mode & 0777);
+  // Open output file atomically: O_EXCL rejects existing files when !force,
+  // O_NOFOLLOW prevents symlink attacks (POSIX). No separate stat() needed.
+#ifdef _WIN32
+  int oflags = O_WRONLY | O_CREAT | O_BINARY | (force ? O_TRUNC : O_EXCL);
+  int fd = open(output_path, oflags, _S_IREAD | _S_IWRITE);
+#else
+  int oflags = O_WRONLY | O_CREAT | O_NOFOLLOW | (force ? O_TRUNC : O_EXCL);
+  int fd = open(output_path, oflags, entry->mode & 0777);
+#endif
   if (fd < 0) {
-    print_error("Cannot create file '%s': %s", output_path, strerror(errno));
+    if (!force && errno == EEXIST) {
+      print_error("File '%s' already exists. Use -f to overwrite.", output_path);
+    } else {
+      print_error("Cannot create file '%s': %s", output_path, strerror(errno));
+    }
     return -1;
   }
 
@@ -229,11 +238,14 @@ static int extract_file(bfc_t* reader, const bfc_entry_t* entry, const char* out
     return -1;
   }
 
-  // Set file permissions and timestamps using file descriptor to avoid TOCTOU race conditions
+// Set file permissions and timestamps using file descriptor to avoid TOCTOU race conditions
+#ifndef _WIN32
   if (fchmod(fd, entry->mode & 0777) != 0) {
     print_verbose("Warning: cannot set permissions on '%s': %s", output_path, strerror(errno));
   }
+#endif
 
+#ifndef _WIN32
   struct timespec times[2] = {
       {.tv_sec = entry->mtime_ns / 1000000000ULL,
        .tv_nsec = entry->mtime_ns % 1000000000ULL}, // atime = mtime
@@ -244,7 +256,7 @@ static int extract_file(bfc_t* reader, const bfc_entry_t* entry, const char* out
   if (futimens(fd, times) != 0) {
     print_verbose("Warning: cannot set timestamps on '%s': %s", output_path, strerror(errno));
   }
-
+#endif
   // Close file descriptor after setting metadata
   close(fd);
 
@@ -256,6 +268,8 @@ static int extract_file(bfc_t* reader, const bfc_entry_t* entry, const char* out
 }
 
 static int extract_directory(const char* output_path, const bfc_entry_t* entry, int force) {
+#ifdef _WIN32
+  (void) entry; // permissions and timestamps are POSIX-only
   struct stat st;
   if (stat(output_path, &st) == 0) {
     if (!S_ISDIR(st.st_mode)) {
@@ -268,49 +282,86 @@ static int extract_directory(const char* output_path, const bfc_entry_t* entry,
         return -1;
       }
     } else {
-      // Directory already exists, just update permissions and timestamps
-      if (chmod(output_path, entry->mode & 0777) != 0) {
-        print_verbose("Warning: cannot set permissions on '%s': %s", output_path, strerror(errno));
-      }
+      return 0;
+    }
+  }
 
-      struct timespec times[2] = {
-          {.tv_sec = entry->mtime_ns / 1000000000ULL,
-           .tv_nsec = entry->mtime_ns % 1000000000ULL}, // atime = mtime
-          {.tv_sec = entry->mtime_ns / 1000000000ULL, .tv_nsec = entry->mtime_ns % 1000000000ULL}
-          // mtime
-      };
+  if (create_parent_directories(output_path, force) != 0) {
+    return -1;
+  }
 
-      if (utimensat(AT_FDCWD, output_path, times, 0) != 0) {
-        print_verbose("Warning: cannot set timestamps on '%s': %s", output_path, strerror(errno));
-      }
+  print_verbose("Creating directory: %s", output_path);
 
-      return 0;
+  if (mkdir(output_path) != 0) {
+    print_error("Cannot create directory '%s': %s", output_path, strerror(errno));
+    return -1;
+  }
+
+  if (!g_options.quiet) {
+    printf("Created: %s/\n", output_path);
+  }
+
+  return 0;
+#else
+  // POSIX: use open() as the atomic probe — no preceding stat() to avoid TOCTOU.
+  int dirfd = open(output_path, O_RDONLY | O_DIRECTORY | O_NOFOLLOW);
+  if (dirfd >= 0) {
+    // Directory exists — update permissions and timestamps via fd.
+    if (fchmod(dirfd, entry->mode & 0777) != 0) {
+      print_verbose("Warning: cannot set permissions on '%s': %s", output_path, strerror(errno));
+    }
+    struct timespec times[2] = {
+        {.tv_sec = entry->mtime_ns / 1000000000ULL, .tv_nsec = entry->mtime_ns % 1000000000ULL},
+        {.tv_sec = entry->mtime_ns / 1000000000ULL, .tv_nsec = entry->mtime_ns % 1000000000ULL}};
+    if (futimens(dirfd, times) != 0) {
+      print_verbose("Warning: cannot set timestamps on '%s': %s", output_path, strerror(errno));
     }
+    close(dirfd);
+    return 0;
   }
 
-  // Create parent directories
+  int open_errno = errno;
+
+  if (open_errno == ENOTDIR || open_errno == ELOOP) {
+    // Path exists but is not a directory, or is a symlink (O_NOFOLLOW sets ELOOP).
+    if (!force) {
+      print_error("'%s' exists but is not a directory. Use -f to overwrite.", output_path);
+      return -1;
+    }
+    if (unlink(output_path) != 0) {
+      print_error("Cannot remove '%s': %s", output_path, strerror(errno));
+      return -1;
+    }
+    // fall through to create
+  } else if (open_errno != ENOENT) {
+    print_error("Cannot access '%s': %s", output_path, strerror(open_errno));
+    return -1;
+  }
+
+  // Create parent directories then the directory itself.
   if (create_parent_directories(output_path, force) != 0) {
     return -1;
   }
 
   print_verbose("Creating directory: %s", output_path);
 
-  // Create directory
   if (mkdir(output_path, entry->mode & 0777) != 0) {
     print_error("Cannot create directory '%s': %s", output_path, strerror(errno));
     return -1;
   }
 
-  // Set timestamps
-  struct timespec times[2] = {
-      {.tv_sec = entry->mtime_ns / 1000000000ULL,
-       .tv_nsec = entry->mtime_ns % 1000000000ULL}, // atime = mtime
-      {.tv_sec = entry->mtime_ns / 1000000000ULL, .tv_nsec = entry->mtime_ns % 1000000000ULL}
-      // mtime
-  };
-
-  if (utimensat(AT_FDCWD, output_path, times, 0) != 0) {
-    print_verbose("Warning: cannot set timestamps on '%s': %s", output_path, strerror(errno));
+  // Set timestamps via fd.
+  {
+    int dirfd_new = open(output_path, O_RDONLY | O_DIRECTORY | O_NOFOLLOW);
+    if (dirfd_new >= 0) {
+      struct timespec times[2] = {
+          {.tv_sec = entry->mtime_ns / 1000000000ULL, .tv_nsec = entry->mtime_ns % 1000000000ULL},
+          {.tv_sec = entry->mtime_ns / 1000000000ULL, .tv_nsec = entry->mtime_ns % 1000000000ULL}};
+      if (futimens(dirfd_new, times) != 0) {
+        print_verbose("Warning: cannot set timestamps on '%s': %s", output_path, strerror(errno));
+      }
+      close(dirfd_new);
+    }
   }
 
   if (!g_options.quiet) {
@@ -318,6 +369,7 @@ static int extract_directory(const char* output_path, const bfc_entry_t* entry,
   }
 
   return 0;
+#endif
 }
 
 static int extract_symlink(bfc_t* reader, const bfc_entry_t* entry, const char* output_path,
@@ -353,7 +405,8 @@ static int extract_symlink(bfc_t* reader, const bfc_entry_t* entry, const char*
   }
   target[entry->size] = '\0';
 
-  // Create symlink
+// Create symlink
+#ifndef _WIN32
   if (symlink(target, output_path) != 0) {
     print_error("Cannot create symlink '%s' -> '%s': %s", output_path, target, strerror(errno));
     free(target);
@@ -372,6 +425,9 @@ static int extract_symlink(bfc_t* reader, const bfc_entry_t* entry, const char*
     print_verbose("Warning: cannot set timestamps on symlink '%s': %s", output_path,
                   strerror(errno));
   }
+#else
+  print_verbose("Warning: symlinks are not supported on Windows, skipping '%s'", entry->path);
+#endif
 
   if (!g_options.quiet) {
     printf("Extracted: %s -> %s\n", output_path, target);
diff --git a/src/cli/cmd_info.c b/src/cli/cmd_info.c
index c782efc..87278e9 100644
--- a/src/cli/cmd_info.c
+++ b/src/cli/cmd_info.c
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-#define _GNU_SOURCE
 #include "cli.h"
 #include <inttypes.h>
 #include <stdio.h>
diff --git a/src/cli/cmd_list.c b/src/cli/cmd_list.c
index b9a85e0..612c8e3 100644
--- a/src/cli/cmd_list.c
+++ b/src/cli/cmd_list.c
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-#define _GNU_SOURCE
 #include "cli.h"
 #include <inttypes.h>
 #include <stdio.h>
diff --git a/src/cli/cmd_verify.c b/src/cli/cmd_verify.c
index ddaeda0..c263c09 100644
--- a/src/cli/cmd_verify.c
+++ b/src/cli/cmd_verify.c
@@ -110,22 +110,6 @@ static int verify_progress_callback(const bfc_entry_t* entry, void* user) {
   return 0;
 }
 
-__attribute__((unused)) static int verify_entry_callback(const bfc_entry_t* entry, void* user) {
-  verify_progress_t* ctx = (verify_progress_t*) user;
-
-  ctx->verified_entries++;
-
-  if (ctx->show_progress) {
-    if (S_ISREG(entry->mode)) {
-      printf("Verifying (%d/%d): %s\n", ctx->verified_entries, ctx->total_entries, entry->path);
-    } else {
-      printf("Checking (%d/%d): %s\n", ctx->verified_entries, ctx->total_entries, entry->path);
-    }
-  }
-
-  return 0;
-}
-
 int cmd_verify(int argc, char* argv[]) {
   verify_options_t opts;
   int result = parse_verify_options(argc, argv, &opts);
diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt
index 6f4da3c..c164966 100644
--- a/src/lib/CMakeLists.txt
+++ b/src/lib/CMakeLists.txt
@@ -16,7 +16,6 @@ set(BFC_LIB_SOURCES
     bfc_format.c
     bfc_writer.c
     bfc_reader.c
-    bfc_iter.c
     bfc_crc32c.c
     bfc_compress.c
     bfc_encrypt.c
@@ -38,8 +37,10 @@ add_library(bfc_shared SHARED ${BFC_LIB_SOURCES})
 
 # Enable SSE4.2 and CRC32 for hardware support on x86_64
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64|amd64")
-    target_compile_options(bfc PRIVATE -msse4.2 -mcrc32)
-    target_compile_options(bfc_shared PRIVATE -msse4.2 -mcrc32)
+    if(NOT MSVC)
+        target_compile_options(bfc PRIVATE -msse4.2 -mcrc32)
+        target_compile_options(bfc_shared PRIVATE -msse4.2 -mcrc32)
+    endif()
 endif()
 
 # Set properties for both libraries
@@ -50,7 +51,11 @@ foreach(target bfc bfc_shared)
     )
     
     # Link with math library if needed
-    target_link_libraries(${target} m)
+    if(NOT WIN32)
+        target_link_libraries(${target} m)
+    else()
+        target_link_libraries(${target} bcrypt)
+    endif()
     
     # Optional dependencies
     if(BFC_WITH_FUSE)
diff --git a/src/lib/bfc_crc32c.c b/src/lib/bfc_crc32c.c
index c3e8ea9..93e395f 100644
--- a/src/lib/bfc_crc32c.c
+++ b/src/lib/bfc_crc32c.c
@@ -19,7 +19,11 @@
 #include <string.h>
 
 #if defined(__x86_64__) || defined(_M_X64)
+#ifdef _MSC_VER
+#include <intrin.h>
+#else
 #include <cpuid.h>
+#endif
 #include <immintrin.h>
 #define HAS_X86_64 1
 #elif defined(__aarch64__) || defined(_M_ARM64)
@@ -51,11 +55,17 @@ static void init_crc32c_table(void) {
 
 #ifdef HAS_X86_64
 static int detect_sse42_support(void) {
+#ifdef _MSC_VER
+  int cpu_info[4];
+  __cpuid(cpu_info, 1);
+  return (cpu_info[2] & (1 << 20)) != 0; // SSE4.2 is bit 20 of ecx
+#else
   unsigned int eax, ebx, ecx, edx;
   if (__get_cpuid(1, &eax, &ebx, &ecx, &edx)) {
     return (ecx & bit_SSE4_2) != 0;
   }
   return 0;
+#endif
 }
 
 static uint32_t crc32c_hw_x86(uint32_t crc, const void* data, size_t len) {
@@ -65,7 +75,7 @@ static uint32_t crc32c_hw_x86(uint32_t crc, const void* data, size_t len) {
   while (len >= 8 && ((uintptr_t) ptr % 8) == 0) {
     uint64_t val;
     memcpy(&val, ptr, 8);
-    crc = _mm_crc32_u64(crc, val);
+    crc = (uint32_t) _mm_crc32_u64(crc, val);
     ptr += 8;
     len -= 8;
   }
diff --git a/src/lib/bfc_format.c b/src/lib/bfc_format.c
index b983221..7dc3bd5 100644
--- a/src/lib/bfc_format.c
+++ b/src/lib/bfc_format.c
@@ -22,8 +22,8 @@
 #include <time.h>
 
 #ifdef _WIN32
+#include "bfc_win32_compat.h"
 #include <bcrypt.h>
-#include <windows.h>
 #else
 #include <fcntl.h>
 #include <unistd.h>
diff --git a/src/lib/bfc_iter.c b/src/lib/bfc_iter.c
deleted file mode 100644
index e5c72fe..0000000
--- a/src/lib/bfc_iter.c
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
- * Copyright 2021 zombocoder (Taras Havryliak)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// Placeholder implementation - iterator functionality to be implemented
-// This will contain directory iteration and prefix matching logic
\ No newline at end of file
diff --git a/src/lib/bfc_os.c b/src/lib/bfc_os.c
index 7514ab4..27ad036 100644
--- a/src/lib/bfc_os.c
+++ b/src/lib/bfc_os.c
@@ -87,6 +87,10 @@ int bfc_os_sync(FILE* file) {
 #ifdef _WIN32
   int fd = _fileno(file);
   return _commit(fd) == 0 ? BFC_OK : BFC_E_IO;
+#elif defined(__APPLE__)
+  /* fdatasync availability is unreliable on macOS; fsync is equivalent */
+  int fd = fileno(file);
+  return fsync(fd) == 0 ? BFC_OK : BFC_E_IO;
 #else
   int fd = fileno(file);
   return fdatasync(fd) == 0 ? BFC_OK : BFC_E_IO;
@@ -165,14 +169,29 @@ int64_t bfc_os_tell(FILE* file) {
 }
 
 void* bfc_os_mmap(FILE* file, size_t size, size_t offset) {
-#ifdef _WIN32
-  // Windows memory mapping not implemented in v1
-  return NULL;
-#else
   if (!file || size == 0) {
     return NULL;
   }
 
+#ifdef _WIN32
+  HANDLE hFile = (HANDLE) _get_osfhandle(_fileno(file));
+  if (hFile == INVALID_HANDLE_VALUE) {
+    return NULL;
+  }
+
+  HANDLE hMapping = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
+  if (hMapping == NULL) {
+    return NULL;
+  }
+
+  DWORD offsetLow = (DWORD) (offset & 0xFFFFFFFF);
+  DWORD offsetHigh = (DWORD) (offset >> 32);
+
+  void* addr = MapViewOfFile(hMapping, FILE_MAP_READ, offsetHigh, offsetLow, size);
+  CloseHandle(hMapping); // Mapping handle is no longer needed after MapViewOfFile
+
+  return addr;
+#else
   int fd = fileno(file);
   void* addr = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, (off_t) offset);
   return (addr == MAP_FAILED) ? NULL : addr;
@@ -180,13 +199,13 @@ void* bfc_os_mmap(FILE* file, size_t size, size_t offset) {
 }
 
 int bfc_os_munmap(void* addr, size_t size) {
-#ifdef _WIN32
-  return BFC_E_INVAL;
-#else
   if (!addr || size == 0) {
     return BFC_E_INVAL;
   }
 
+#ifdef _WIN32
+  return UnmapViewOfFile(addr) ? BFC_OK : BFC_E_IO;
+#else
   return munmap(addr, size) == 0 ? BFC_OK : BFC_E_IO;
 #endif
 }
@@ -346,6 +365,10 @@ int bfc_os_mkdir_p(const char* path, uint32_t mode) {
     return BFC_E_INVAL;
   }
 
+#ifdef _WIN32
+  (void) mode; // Windows _mkdir does not accept a mode argument
+#endif
+
   char* path_copy = strdup(path);
   if (!path_copy) {
     return BFC_E_IO;
diff --git a/src/lib/bfc_os.h b/src/lib/bfc_os.h
index 7ccac47..c555a5d 100644
--- a/src/lib/bfc_os.h
+++ b/src/lib/bfc_os.h
@@ -21,7 +21,7 @@
 #include <stdio.h>
 
 #ifdef _WIN32
-#include <windows.h>
+#include "bfc_win32_compat.h"
 #else
 #include <sys/types.h>
 #include <unistd.h>
diff --git a/src/lib/bfc_reader.c b/src/lib/bfc_reader.c
index 7e842ab..c013fab 100644
--- a/src/lib/bfc_reader.c
+++ b/src/lib/bfc_reader.c
@@ -25,7 +25,6 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
-#include <unistd.h>
 
 #define READ_BUFFER_SIZE 65536
 
@@ -492,7 +491,7 @@ static size_t read_compressed_file(bfc_t* r, bfc_reader_entry_t* entry, uint64_t
 
   // Decompress the data
   bfc_decompress_result_t decomp_result =
-      bfc_decompress_data(entry->comp, data_to_decompress, data_size, obj_hdr.orig_size);
+      bfc_decompress_data((uint8_t) entry->comp, data_to_decompress, data_size, obj_hdr.orig_size);
 
   // Clean up
   free(raw_data);
@@ -567,7 +566,7 @@ size_t bfc_read(bfc_t* r, const char* container_path, uint64_t offset, void* buf
 
   // Handle compressed files
   if (entry->comp != BFC_COMP_NONE) {
-    if (!bfc_compress_is_supported(entry->comp)) {
+    if (!bfc_compress_is_supported((uint8_t) entry->comp)) {
       return 0; // Unsupported compression type
     }
 
@@ -639,14 +638,14 @@ int bfc_extract_to_fd(bfc_t* r, const char* container_path, int out_fd) {
   size_t hdr_name_size = sizeof(obj_hdr) + name_len;
   size_t padding = bfc_padding_size(hdr_name_size, BFC_ALIGN);
 
-  if (fseek(r->file, name_len + padding, SEEK_CUR) != 0) {
+  if (fseek(r->file, (long) (name_len + padding), SEEK_CUR) != 0) {
     return BFC_E_IO;
   }
 
   // Handle compressed vs uncompressed files
   if (entry->comp != BFC_COMP_NONE) {
     // Compressed file - decompress and write
-    if (!bfc_compress_is_supported(entry->comp)) {
+    if (!bfc_compress_is_supported((uint8_t) entry->comp)) {
       return BFC_E_INVAL;
     }
 
@@ -675,8 +674,8 @@ int bfc_extract_to_fd(bfc_t* r, const char* container_path, int out_fd) {
 
       // Create decryption key structure using stored key
       bfc_encrypt_key_t decrypt_key;
-      int result = bfc_encrypt_key_from_bytes(r->encryption_key, &decrypt_key);
-      if (result != BFC_OK) {
+      int enc_err = bfc_encrypt_key_from_bytes(r->encryption_key, &decrypt_key);
+      if (enc_err != BFC_OK) {
         free(compressed_data);
         return BFC_E_IO;
       }
@@ -698,8 +697,8 @@ int bfc_extract_to_fd(bfc_t* r, const char* container_path, int out_fd) {
     }
 
     // Decompress
-    bfc_decompress_result_t decomp_result =
-        bfc_decompress_data(entry->comp, data_to_decompress, data_size, obj_hdr.orig_size);
+    bfc_decompress_result_t decomp_result = bfc_decompress_data(
+        (uint8_t) entry->comp, data_to_decompress, data_size, obj_hdr.orig_size);
 
     // Clean up
     free(compressed_data);
@@ -729,7 +728,8 @@ int bfc_extract_to_fd(bfc_t* r, const char* container_path, int out_fd) {
     }
 
     // Write decompressed data to output
-    ssize_t written = write(out_fd, decomp_result.data, decomp_result.decompressed_size);
+    ssize_t written =
+        write(out_fd, decomp_result.data, (unsigned int) decomp_result.decompressed_size);
     free(decomp_result.data);
 
     if (written != (ssize_t) decomp_result.decompressed_size) {
@@ -757,8 +757,8 @@ int bfc_extract_to_fd(bfc_t* r, const char* container_path, int out_fd) {
 
       // Create decryption key structure
       bfc_encrypt_key_t decrypt_key;
-      int result = bfc_encrypt_key_from_bytes(r->encryption_key, &decrypt_key);
-      if (result != BFC_OK) {
+      int enc_err = bfc_encrypt_key_from_bytes(r->encryption_key, &decrypt_key);
+      if (enc_err != BFC_OK) {
         free(encrypted_data);
         return BFC_E_IO;
       }
@@ -785,7 +785,8 @@ int bfc_extract_to_fd(bfc_t* r, const char* container_path, int out_fd) {
       }
 
       // Write decrypted data to output
-      ssize_t written = write(out_fd, decrypt_result.data, decrypt_result.decrypted_size);
+      ssize_t written =
+          write(out_fd, decrypt_result.data, (unsigned int) decrypt_result.decrypted_size);
       free(decrypt_result.data);
 
       if (written != (ssize_t) decrypt_result.decrypted_size) {
@@ -806,7 +807,7 @@ int bfc_extract_to_fd(bfc_t* r, const char* container_path, int out_fd) {
           return BFC_E_IO;
         }
 
-        if (write(out_fd, buffer, bytes_read) != (ssize_t) bytes_read) {
+        if (write(out_fd, buffer, (unsigned int) bytes_read) != (ssize_t) bytes_read) {
           return BFC_E_IO;
         }
 
@@ -861,7 +862,7 @@ int bfc_verify(bfc_t* r, int deep) {
         size_t hdr_name_size = sizeof(obj_hdr) + name_len;
         size_t padding = bfc_padding_size(hdr_name_size, BFC_ALIGN);
 
-        if (fseek(r->file, name_len + padding, SEEK_CUR) != 0) {
+        if (fseek(r->file, (long) (name_len + padding), SEEK_CUR) != 0) {
           return BFC_E_IO;
         }
 
diff --git a/src/lib/bfc_win32_compat.h b/src/lib/bfc_win32_compat.h
new file mode 100644
index 0000000..10574ac
--- /dev/null
+++ b/src/lib/bfc_win32_compat.h
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2021 zombocoder (Taras Havryliak)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#ifdef _WIN32
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <direct.h>
+#include <io.h>
+#include <process.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <time.h>
+#include <windows.h>
+
+// Missing POSIX types
+typedef ptrdiff_t ssize_t;
+
+// Missing POSIX constants for stat
+#ifndef S_IFMT
+#define S_IFMT 0170000
+#endif
+#ifndef S_IFLNK
+#define S_IFLNK 0120000
+#endif
+#ifndef S_IFREG
+#define S_IFREG 0100000
+#endif
+#ifndef S_IFDIR
+#define S_IFDIR 0040000
+#endif
+
+#define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
+#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
+#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
+#define S_ISCHR(m) (0)
+#define S_ISBLK(m) (0)
+#define S_ISFIFO(m) (0)
+#define S_ISSOCK(m) (0)
+
+#ifndef S_IRUSR
+#define S_IRUSR 0000400
+#endif
+#ifndef S_IWUSR
+#define S_IWUSR 0000200
+#endif
+#ifndef S_IXUSR
+#define S_IXUSR 0000100
+#endif
+#ifndef S_IRGRP
+#define S_IRGRP 0000040
+#endif
+#ifndef S_IWGRP
+#define S_IWGRP 0000020
+#endif
+#ifndef S_IXGRP
+#define S_IXGRP 0000010
+#endif
+#ifndef S_IROTH
+#define S_IROTH 0000004
+#endif
+#ifndef S_IWOTH
+#define S_IWOTH 0000002
+#endif
+#ifndef S_IXOTH
+#define S_IXOTH 0000001
+#endif
+
+#ifndef S_ISUID
+#define S_ISUID 0004000
+#endif
+#ifndef S_ISGID
+#define S_ISGID 0002000
+#endif
+#ifndef S_ISVTX
+#define S_ISVTX 0001000
+#endif
+
+#ifndef F_OK
+#define F_OK 0
+#endif
+
+// usleep replacement
+static inline void usleep(unsigned long usec) { Sleep(usec / 1000); }
+
+#define sleep(seconds) Sleep((seconds) * 1000)
+
+// clock_gettime basic replacement for benchmarks
+#ifndef CLOCK_REALTIME
+#define CLOCK_REALTIME 0
+#endif
+#ifndef CLOCK_MONOTONIC
+#define CLOCK_MONOTONIC 1
+#endif
+
+typedef int clockid_t;
+
+static inline int clock_gettime(clockid_t clk_id, struct timespec* tp) {
+  if (clk_id == CLOCK_MONOTONIC) {
+    LARGE_INTEGER counter, freq;
+    QueryPerformanceCounter(&counter);
+    QueryPerformanceFrequency(&freq);
+    tp->tv_sec = (time_t) (counter.QuadPart / freq.QuadPart);
+    tp->tv_nsec = (long) (((counter.QuadPart % freq.QuadPart) * 1000000000LL) / freq.QuadPart);
+    return 0;
+  }
+  // CLOCK_REALTIME and any other clock id: wall-clock from FILETIME.
+  FILETIME ft;
+  uint64_t tim;
+  GetSystemTimeAsFileTime(&ft);
+  tim = ft.dwLowDateTime;
+  tim |= ((uint64_t) ft.dwHighDateTime) << 32;
+  tim -= 116444736000000000ULL; // 1601 to 1970
+  tp->tv_sec = (time_t) (tim / 10000000ULL);
+  tp->tv_nsec = (long) ((tim % 10000000ULL) * 100ULL);
+  return 0;
+}
+
+// Map mkdir to _mkdir
+#define mkdir(path, ...) _mkdir(path)
+
+// Map fseeko/ftello to 64-bit Windows equivalents
+#define fseeko _fseeki64
+#define ftello _ftelli64
+
+// Map fileno to _fileno
+#define fileno _fileno
+
+// Map getpid to _getpid
+#define getpid _getpid
+
+#endif // _WIN32
diff --git a/tests/unit/test_compress.c b/tests/unit/test_compress.c
index db5e6dd..cdd4449 100644
--- a/tests/unit/test_compress.c
+++ b/tests/unit/test_compress.c
@@ -22,7 +22,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#ifndef _WIN32
 #include <unistd.h>
+#endif
 
 // Test basic compression support detection
 static int test_compression_support(void) {
@@ -219,7 +221,7 @@ static int test_compression_utilities(void) {
 
 // Test BFC writer compression settings
 static int test_writer_compression_settings(void) {
-  const char* filename = "/tmp/test_compression_writer.bfc";
+  const char* filename = "test_compression_writer.bfc";
   unlink(filename);
 
   bfc_t* writer = NULL;
@@ -255,9 +257,9 @@ static int test_writer_compression_settings(void) {
 
 // Test end-to-end compression with BFC container
 static int test_end_to_end_compression(void) {
-  const char* container_filename = "/tmp/test_e2e_compression.bfc";
-  const char* test_filename = "/tmp/test_e2e_input.txt";
-  const char* extract_filename = "/tmp/test_e2e_output.txt";
+  const char* container_filename = "test_e2e_compression.bfc";
+  const char* test_filename = "test_e2e_input.txt";
+  const char* extract_filename = "test_e2e_output.txt";
 
   // Clean up any existing files
   unlink(container_filename);
@@ -265,7 +267,7 @@ static int test_end_to_end_compression(void) {
   unlink(extract_filename);
 
   // Create test input file with compressible content
-  FILE* input_file = fopen(test_filename, "w");
+  FILE* input_file = fopen(test_filename, "wb");
   assert(input_file != NULL);
 
   const char* repeating_content =
@@ -321,7 +323,11 @@ static int test_end_to_end_compression(void) {
 #endif
 
   // Extract and verify content
+#ifdef _WIN32
+  int out_fd = open(extract_filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
+#else
   int out_fd = open(extract_filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+#endif
   assert(out_fd >= 0);
 
   result = bfc_extract_to_fd(reader, "test_file.txt", out_fd);
@@ -368,11 +374,12 @@ static int test_end_to_end_compression(void) {
 
 // Test additional compression edge cases for better coverage
 static int test_compression_edge_cases(void) {
-  const char* filename = "/tmp/compress_edge_test.bfc";
-  const char* test_filename = "/tmp/compress_edge_input.txt";
+#ifdef BFC_WITH_ZSTD
+  const char* filename = "compress_edge_test.bfc";
+  const char* test_filename = "compress_edge_input.txt";
 
   // Create a small file that won't be compressed (below threshold)
-  FILE* f = fopen(test_filename, "w");
+  FILE* f = fopen(test_filename, "wb");
   assert(f);
   fprintf(f, "tiny"); // 4 bytes, below default 64-byte threshold
   fclose(f);
@@ -414,7 +421,7 @@ static int test_compression_edge_cases(void) {
   unlink(filename);
 
   // Create larger file that will be compressed
-  f = fopen(test_filename, "w");
+  f = fopen(test_filename, "wb");
   assert(f);
   for (int i = 0; i < 100; i++) {
     fprintf(f, "This is a repeating line %d that should compress well with zstd compression.\n", i);
@@ -467,17 +474,18 @@ static int test_compression_edge_cases(void) {
   // Clean up
   unlink(filename);
   unlink(test_filename);
-
+#endif // BFC_WITH_ZSTD
   return 0;
 }
 
 // Test compression threshold settings
 static int test_compression_threshold_settings(void) {
-  const char* filename = "/tmp/compress_threshold_test.bfc";
-  const char* test_filename = "/tmp/compress_threshold_input.txt";
+#ifdef BFC_WITH_ZSTD
+  const char* filename = "compress_threshold_test.bfc";
+  const char* test_filename = "compress_threshold_input.txt";
 
   // Create a file that's exactly at the threshold
-  FILE* f = fopen(test_filename, "w");
+  FILE* f = fopen(test_filename, "wb");
   assert(f);
   for (int i = 0; i < 64; i++) { // Exactly 64 bytes
     fputc('A', f);
@@ -520,7 +528,7 @@ static int test_compression_threshold_settings(void) {
   // Clean up
   unlink(filename);
   unlink(test_filename);
-
+#endif // BFC_WITH_ZSTD
   return 0;
 }
 
@@ -769,4 +777,4 @@ int test_compress(void) {
   result += test_mixed_content_recommendation();
 
   return result;
-}
\ No newline at end of file
+}
diff --git a/tests/unit/test_crc32c.c b/tests/unit/test_crc32c.c
index 259aeb4..4609943 100644
--- a/tests/unit/test_crc32c.c
+++ b/tests/unit/test_crc32c.c
@@ -167,7 +167,11 @@ static int test_binary_data(void) {
 
 static int test_alignment_cases(void) {
   // Test different alignment cases to exercise alignment handling
+#ifdef _MSC_VER
+  __declspec(align(16)) char aligned_data[32];
+#else
   char aligned_data[32] __attribute__((aligned(16)));
+#endif
   memset(aligned_data, 0xAA, sizeof(aligned_data));
 
   uint32_t crc_aligned = bfc_crc32c_compute(aligned_data, sizeof(aligned_data));
@@ -279,4 +283,4 @@ int test_crc32c(void) {
     return 1;
 
   return 0;
-}
\ No newline at end of file
+}
diff --git a/tests/unit/test_encrypt.c b/tests/unit/test_encrypt.c
index 21ce896..3895fc5 100644
--- a/tests/unit/test_encrypt.c
+++ b/tests/unit/test_encrypt.c
@@ -25,7 +25,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
+#ifndef _WIN32
 #include <unistd.h>
+#endif
 
 // Test basic encryption support detection
 static int test_encryption_support(void) {
@@ -264,7 +266,7 @@ static int test_encryption_utilities(void) {
 
 // Test BFC writer encryption settings
 static int test_writer_encryption_settings(void) {
-  const char* filename = "/tmp/test_encryption_writer.bfc";
+  const char* filename = "test_encryption_writer.bfc";
   unlink(filename);
 
   bfc_t* writer = NULL;
@@ -310,9 +312,9 @@ static int test_end_to_end_encryption(void) {
   char test_filename[256];
   char extract_filename[256];
   int pid = getpid();
-  snprintf(container_filename, sizeof(container_filename), "/tmp/encrypt_e2e_%d.bfc", pid);
-  snprintf(test_filename, sizeof(test_filename), "/tmp/encrypt_e2e_input_%d.txt", pid);
-  snprintf(extract_filename, sizeof(extract_filename), "/tmp/encrypt_e2e_output_%d.txt", pid);
+  snprintf(container_filename, sizeof(container_filename), "encrypt_e2e_%d.bfc", pid);
+  snprintf(test_filename, sizeof(test_filename), "encrypt_e2e_input_%d.txt", pid);
+  snprintf(extract_filename, sizeof(extract_filename), "encrypt_e2e_output_%d.txt", pid);
 
   // Clean up any existing files
   unlink(container_filename);
@@ -320,7 +322,7 @@ static int test_end_to_end_encryption(void) {
   unlink(extract_filename);
 
   // Create test input file with sensitive content
-  FILE* input_file = fopen(test_filename, "w");
+  FILE* input_file = fopen(test_filename, "wb");
   assert(input_file != NULL);
 
   const char* sensitive_content =
@@ -358,7 +360,11 @@ static int test_end_to_end_encryption(void) {
   assert(result == BFC_OK);
 
   // Try to extract without password (should fail)
+#ifdef _WIN32
+  int out_fd = open(extract_filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
+#else
   int out_fd = open(extract_filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+#endif
   assert(out_fd >= 0);
 
   result = bfc_extract_to_fd(reader, "secret_file.txt", out_fd);
@@ -377,7 +383,11 @@ static int test_end_to_end_encryption(void) {
   assert(entry.enc == BFC_ENC_CHACHA20_POLY1305);
 
   // Extract with correct password
+#ifdef _WIN32
+  out_fd = open(extract_filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
+#else
   out_fd = open(extract_filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+#endif
   assert(out_fd >= 0);
 
   result = bfc_extract_to_fd(reader, "secret_file.txt", out_fd);
@@ -448,9 +458,9 @@ static int test_encryption_with_compression(void) {
   char test_filename[256];
   char extract_filename[256];
   int pid = getpid();
-  snprintf(container_filename, sizeof(container_filename), "/tmp/encrypt_compress_%d.bfc", pid);
-  snprintf(test_filename, sizeof(test_filename), "/tmp/encrypt_compress_input_%d.txt", pid);
-  snprintf(extract_filename, sizeof(extract_filename), "/tmp/encrypt_compress_output_%d.txt", pid);
+  snprintf(container_filename, sizeof(container_filename), "encrypt_compress_%d.bfc", pid);
+  snprintf(test_filename, sizeof(test_filename), "encrypt_compress_input_%d.txt", pid);
+  snprintf(extract_filename, sizeof(extract_filename), "encrypt_compress_output_%d.txt", pid);
 
   // Clean up any existing files
   unlink(container_filename);
@@ -458,7 +468,7 @@ static int test_encryption_with_compression(void) {
   unlink(extract_filename);
 
   // Create test input file with compressible content
-  FILE* input_file = fopen(test_filename, "w");
+  FILE* input_file = fopen(test_filename, "wb");
   assert(input_file != NULL);
 
   // Write highly compressible content
@@ -519,7 +529,11 @@ static int test_encryption_with_compression(void) {
 #endif
 
   // Extract and verify content
+#ifdef _WIN32
+  int out_fd = open(extract_filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
+#else
   int out_fd = open(extract_filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+#endif
   assert(out_fd >= 0);
 
   result = bfc_extract_to_fd(reader, "compress_encrypt_file.txt", out_fd);
@@ -528,8 +542,8 @@ static int test_encryption_with_compression(void) {
   bfc_close_read(reader);
 
   // Compare original and extracted files
-  FILE* orig = fopen(test_filename, "r");
-  FILE* extracted = fopen(extract_filename, "r");
+  FILE* orig = fopen(test_filename, "rb");
+  FILE* extracted = fopen(extract_filename, "rb");
   assert(orig != NULL);
   assert(extracted != NULL);
 
@@ -578,12 +592,12 @@ static int test_has_encryption_detection(void) {
   char encrypted_container[256];
   char test_file[256];
   int pid = getpid();
-  snprintf(unencrypted_container, sizeof(unencrypted_container), "/tmp/test_unenc_%d.bfc", pid);
-  snprintf(encrypted_container, sizeof(encrypted_container), "/tmp/test_enc_%d.bfc", pid);
-  snprintf(test_file, sizeof(test_file), "/tmp/test_file_%d.txt", pid);
+  snprintf(unencrypted_container, sizeof(unencrypted_container), "test_unenc_%d.bfc", pid);
+  snprintf(encrypted_container, sizeof(encrypted_container), "test_enc_%d.bfc", pid);
+  snprintf(test_file, sizeof(test_file), "test_file_%d.txt", pid);
 
   // Create test file
-  FILE* f = fopen(test_file, "w");
+  FILE* f = fopen(test_file, "wb");
   assert(f);
   fprintf(f, "Test content for encryption detection");
   fclose(f);
@@ -593,7 +607,7 @@ static int test_has_encryption_detection(void) {
   int result = bfc_create(unencrypted_container, 4096, 0, &writer);
   assert(result == BFC_OK);
 
-  FILE* src = fopen(test_file, "r");
+  FILE* src = fopen(test_file, "rb");
   assert(src);
   result = bfc_add_file(writer, "test.txt", src, 0644, bfc_os_current_time_ns(), NULL);
   assert(result == BFC_OK);
@@ -623,7 +637,7 @@ static int test_has_encryption_detection(void) {
   result = bfc_set_encryption_password(writer, password, strlen(password));
   assert(result == BFC_OK);
 
-  src = fopen(test_file, "r");
+  src = fopen(test_file, "rb");
   assert(src);
   result = bfc_add_file(writer, "test.txt", src, 0644, bfc_os_current_time_ns(), NULL);
   assert(result == BFC_OK);
@@ -659,11 +673,11 @@ static int test_encryption_error_paths(void) {
   char container_filename[256];
   char test_filename[256];
   int pid = getpid();
-  snprintf(container_filename, sizeof(container_filename), "/tmp/test_err_%d.bfc", pid);
-  snprintf(test_filename, sizeof(test_filename), "/tmp/test_err_file_%d.txt", pid);
+  snprintf(container_filename, sizeof(container_filename), "test_err_%d.bfc", pid);
+  snprintf(test_filename, sizeof(test_filename), "test_err_file_%d.txt", pid);
 
   // Create test file
-  FILE* f = fopen(test_filename, "w");
+  FILE* f = fopen(test_filename, "wb");
   assert(f);
   fprintf(f, "Error test content");
   fclose(f);
@@ -678,7 +692,7 @@ static int test_encryption_error_paths(void) {
   result = bfc_set_encryption_key(writer, test_key);
   assert(result == BFC_OK);
 
-  FILE* src = fopen(test_filename, "r");
+  FILE* src = fopen(test_filename, "rb");
   assert(src);
   result = bfc_add_file(writer, "test.txt", src, 0644, bfc_os_current_time_ns(), NULL);
   assert(result == BFC_OK);
@@ -700,12 +714,16 @@ static int test_encryption_error_paths(void) {
   assert(bfc_has_encryption(reader) == 1);
 
   // Test extraction with correct key
-  int fd = open("/tmp/test_extract.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
+#ifdef _WIN32
+  int fd = open("test_extract.txt", O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
+#else
+  int fd = open("test_extract.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
+#endif
   assert(fd >= 0);
   result = bfc_extract_to_fd(reader, "test.txt", fd);
   assert(result == BFC_OK);
   close(fd);
-  unlink("/tmp/test_extract.txt");
+  unlink("test_extract.txt");
 
   bfc_close_read(reader);
 
@@ -720,12 +738,16 @@ static int test_encryption_error_paths(void) {
   assert(result == BFC_OK);
 
   // Try to extract with wrong key - should fail
-  fd = open("/tmp/test_extract_fail.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
+#ifdef _WIN32
+  fd = open("test_extract_fail.txt", O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
+#else
+  fd = open("test_extract_fail.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
+#endif
   assert(fd >= 0);
   result = bfc_extract_to_fd(reader, "test.txt", fd);
   assert(result != BFC_OK); // Should fail with wrong key
   close(fd);
-  unlink("/tmp/test_extract_fail.txt");
+  unlink("test_extract_fail.txt");
 
   bfc_close_read(reader);
 
@@ -743,11 +765,11 @@ static int test_additional_encryption_coverage(void) {
   char container_filename[256];
   char test_filename[256];
   int pid = getpid();
-  snprintf(container_filename, sizeof(container_filename), "/tmp/test_additional_%d.bfc", pid);
-  snprintf(test_filename, sizeof(test_filename), "/tmp/test_additional_file_%d.txt", pid);
+  snprintf(container_filename, sizeof(container_filename), "test_additional_%d.bfc", pid);
+  snprintf(test_filename, sizeof(test_filename), "test_additional_file_%d.txt", pid);
 
   // Create a larger test file to trigger more code paths
-  FILE* f = fopen(test_filename, "w");
+  FILE* f = fopen(test_filename, "wb");
   assert(f);
   for (int i = 0; i < 1000; i++) {
     fprintf(f,
@@ -771,7 +793,7 @@ static int test_additional_encryption_coverage(void) {
   result = bfc_set_encryption_password(writer, password, strlen(password));
   assert(result == BFC_OK);
 
-  FILE* src = fopen(test_filename, "r");
+  FILE* src = fopen(test_filename, "rb");
   assert(src);
   result = bfc_add_file(writer, "large_test.txt", src, 0644, bfc_os_current_time_ns(), NULL);
   assert(result == BFC_OK);
@@ -851,11 +873,11 @@ static int test_encryption_key_edge_cases(void) {
   char container_filename[256];
   char test_filename[256];
   int pid = getpid();
-  snprintf(container_filename, sizeof(container_filename), "/tmp/test_key_edge_%d.bfc", pid);
-  snprintf(test_filename, sizeof(test_filename), "/tmp/test_key_edge_file_%d.txt", pid);
+  snprintf(container_filename, sizeof(container_filename), "test_key_edge_%d.bfc", pid);
+  snprintf(test_filename, sizeof(test_filename), "test_key_edge_file_%d.txt", pid);
 
   // Create test file
-  FILE* f = fopen(test_filename, "w");
+  FILE* f = fopen(test_filename, "wb");
   assert(f);
   fprintf(f, "Key edge case test content");
   fclose(f);
@@ -873,7 +895,7 @@ static int test_encryption_key_edge_cases(void) {
   result = bfc_set_encryption_key(writer, key);
   assert(result == BFC_OK);
 
-  FILE* src = fopen(test_filename, "r");
+  FILE* src = fopen(test_filename, "rb");
   assert(src);
   result = bfc_add_file(writer, "key_test.txt", src, 0644, bfc_os_current_time_ns(), NULL);
   assert(result == BFC_OK);
@@ -902,7 +924,7 @@ static int test_encryption_key_edge_cases(void) {
 
   // Test clearing encryption (for writer coverage)
   writer = NULL;
-  result = bfc_create("/tmp/test_clear_enc.bfc", 4096, 0, &writer);
+  result = bfc_create("test_clear_enc.bfc", 4096, 0, &writer);
   assert(result == BFC_OK);
 
   result = bfc_set_encryption_password(writer, "temp", 4);
@@ -915,7 +937,7 @@ static int test_encryption_key_edge_cases(void) {
   assert(bfc_get_encryption(writer) == BFC_ENC_NONE);
 
   bfc_close(writer);
-  unlink("/tmp/test_clear_enc.bfc");
+  unlink("test_clear_enc.bfc");
 
   // Clean up
   unlink(container_filename);
@@ -1215,4 +1237,4 @@ int test_encrypt(void) {
   result += test_encrypt_corruption_handling();
 
   return result;
-}
\ No newline at end of file
+}
diff --git a/tests/unit/test_encrypt_integration.c b/tests/unit/test_encrypt_integration.c
index fbffc8f..470bb4d 100644
--- a/tests/unit/test_encrypt_integration.c
+++ b/tests/unit/test_encrypt_integration.c
@@ -311,4 +311,4 @@ int test_encrypt_integration(void) {
 #else
 // When libsodium is not available, just return success
 int test_encrypt_integration(void) { return 0; }
-#endif
\ No newline at end of file
+#endif
diff --git a/tests/unit/test_format.c b/tests/unit/test_format.c
index 97fcd5c..f2c53bb 100644
--- a/tests/unit/test_format.c
+++ b/tests/unit/test_format.c
@@ -140,4 +140,4 @@ int test_format(void) {
     return 1;
 
   return 0;
-}
\ No newline at end of file
+}
diff --git a/tests/unit/test_main.c b/tests/unit/test_main.c
index e838f59..db13928 100644
--- a/tests/unit/test_main.c
+++ b/tests/unit/test_main.c
@@ -17,6 +17,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#ifdef _WIN32
+#include <crtdbg.h>
+#endif
 
 // Test declarations
 int test_format(void);
@@ -66,6 +69,12 @@ static int run_test(const char* name, int (*func)(void)) {
 int main(int argc, char* argv[]) {
   int failed = 0;
 
+#ifdef _WIN32
+  /* Suppress assert dialogs on CI - print to stderr and continue */
+  _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
+  _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
+#endif
+
   if (argc == 2) {
     // Run specific test
     const char* test_name = argv[1];
@@ -96,4 +105,4 @@ int main(int argc, char* argv[]) {
     printf("\nAll tests passed.\n");
     return 0;
   }
-}
\ No newline at end of file
+}
diff --git a/tests/unit/test_os.c b/tests/unit/test_os.c
index e592997..03137a1 100644
--- a/tests/unit/test_os.c
+++ b/tests/unit/test_os.c
@@ -22,10 +22,12 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
+#ifndef _WIN32
 #include <unistd.h>
+#endif
 
 static int test_file_operations(void) {
-  const char* test_file = "/tmp/test_bfc_os.dat";
+  const char* test_file = "test_bfc_os.dat";
 
   // Test open for writing
   FILE* file = NULL;
@@ -82,17 +84,15 @@ static int test_file_operations(void) {
   assert(result == BFC_OK);
 
   void* mapped = bfc_os_mmap(file, data_len, 0);
-#ifdef _WIN32
-  // Windows mmap not implemented, should return NULL
-  assert(mapped == NULL);
-#else
-  // Unix should work
+  // Both Unix and Windows should work now
   if (mapped != NULL) {
     assert(memcmp(mapped, test_data, data_len) == 0);
     result = bfc_os_munmap(mapped, data_len);
     assert(result == BFC_OK);
+  } else {
+    // If mmap fails, it's an error unless it's a known limitation
+    assert(mapped != NULL);
   }
-#endif
 
   // Test advisory functions
   result = bfc_os_advise_sequential(file);
@@ -126,14 +126,14 @@ static int test_error_conditions(void) {
   assert(result == BFC_E_INVAL);
 
   // NULL output pointer
-  result = bfc_os_open_read("/tmp/test", NULL);
+  result = bfc_os_open_read("test", NULL);
   assert(result == BFC_E_INVAL);
 
-  result = bfc_os_open_write("/tmp/test", NULL);
+  result = bfc_os_open_write("test", NULL);
   assert(result == BFC_E_INVAL);
 
   // Non-existent file for reading
-  result = bfc_os_open_read("/tmp/nonexistent_file_12345", &file);
+  result = bfc_os_open_read("nonexistent_file_12345", &file);
   assert(result == BFC_E_IO);
 
   // Test invalid file operations
@@ -170,7 +170,7 @@ static int test_error_conditions(void) {
 }
 
 static int test_directory_operations(void) {
-  const char* test_dir = "/tmp/bfc_test_dir_12345";
+  const char* test_dir = "bfc_test_dir_12345";
 
   // Test directory sync (should handle non-existent directory)
   int result = bfc_os_sync_dir(test_dir);
@@ -207,7 +207,7 @@ static int test_directory_operations(void) {
   assert(bfc_os_path_exists(NULL) == 0);
 
   // Clean up
-  system("rm -rf /tmp/bfc_test_dir_12345");
+  system("rm -rf bfc_test_dir_12345");
 
   return 0;
 }
@@ -281,8 +281,8 @@ static int test_time_operations(void) {
   assert(time2 - time1 >= 10000000); // At least 10ms difference
 
   // Test file mtime
-  const char* test_file = "/tmp/test_mtime.dat";
-  FILE* file = fopen(test_file, "w");
+  const char* test_file = "test_mtime.dat";
+  FILE* file = fopen(test_file, "wb");
   assert(file != NULL);
   fprintf(file, "test");
   fclose(file);
@@ -291,7 +291,7 @@ static int test_time_operations(void) {
   assert(mtime > 0);
 
   // Test with non-existent file
-  uint64_t bad_mtime = bfc_os_file_mtime_ns("/tmp/nonexistent_file_12345");
+  uint64_t bad_mtime = bfc_os_file_mtime_ns("nonexistent_file_12345");
   assert(bad_mtime == 0);
 
   // Test with NULL
@@ -305,24 +305,31 @@ static int test_time_operations(void) {
 
 static int test_executable_check(void) {
   // Create a test file
-  const char* test_file = "/tmp/test_exec.sh";
-  FILE* file = fopen(test_file, "w");
+#ifdef _WIN32
+  const char* test_file = "test_exec.exe";
+#else
+  const char* test_file = "test_exec.sh";
+#endif
+  FILE* file = fopen(test_file, "wb");
   assert(file != NULL);
   fprintf(file, "#!/bin/sh\necho test\n");
   fclose(file);
 
-  // Initially not executable
+  // Initially not executable (on Unix) or check extension (on Windows)
+#ifdef _WIN32
+  assert(bfc_os_is_executable(test_file) == 1); // .exe is always executable in our impl
+#else
   assert(bfc_os_is_executable(test_file) == 0);
-
   // Make it executable
   chmod(test_file, 0755);
   assert(bfc_os_is_executable(test_file) == 1);
+#endif
 
   // Test with NULL
   assert(bfc_os_is_executable(NULL) == 0);
 
   // Test with non-existent file
-  assert(bfc_os_is_executable("/tmp/nonexistent_exec_12345") == 0);
+  assert(bfc_os_is_executable("nonexistent_exec_12345") == 0);
 
   unlink(test_file);
 
@@ -364,4 +371,4 @@ int test_os(void) {
     return 1;
 
   return 0;
-}
\ No newline at end of file
+}
diff --git a/tests/unit/test_path.c b/tests/unit/test_path.c
index 3468218..0ed6541 100644
--- a/tests/unit/test_path.c
+++ b/tests/unit/test_path.c
@@ -150,4 +150,4 @@ int test_path(void) {
     return 1;
 
   return 0;
-}
\ No newline at end of file
+}
diff --git a/tests/unit/test_reader.c b/tests/unit/test_reader.c
index 5964389..fad1cea 100644
--- a/tests/unit/test_reader.c
+++ b/tests/unit/test_reader.c
@@ -24,7 +24,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
+#ifndef _WIN32
 #include <unistd.h>
+#endif
 
 // Helper function to create a test container
 static int create_test_container(const char* filename) {
@@ -96,7 +98,7 @@ static int create_test_container(const char* filename) {
 }
 
 static int test_open_container(void) {
-  const char* filename = "/tmp/test_reader.bfc";
+  const char* filename = "test_reader.bfc";
 
   // Create test container
   int result = create_test_container(filename);
@@ -115,7 +117,7 @@ static int test_open_container(void) {
 }
 
 static int test_stat_files(void) {
-  const char* filename = "/tmp/test_reader_stat.bfc";
+  const char* filename = "test_reader_stat.bfc";
 
   // Create test container
   int result = create_test_container(filename);
@@ -167,7 +169,7 @@ static int count_entries_cb(const bfc_entry_t* entry, void* user) {
 }
 
 static int test_list_entries(void) {
-  const char* filename = "/tmp/test_reader_list.bfc";
+  const char* filename = "test_reader_list.bfc";
 
   // Create test container
   int result = create_test_container(filename);
@@ -197,7 +199,7 @@ static int test_list_entries(void) {
 }
 
 static int test_read_content(void) {
-  const char* filename = "/tmp/test_reader_read.bfc";
+  const char* filename = "test_reader_read.bfc";
 
   // Create test container
   int result = create_test_container(filename);
@@ -237,8 +239,8 @@ static int test_read_content(void) {
 }
 
 static int test_extract_file(void) {
-  const char* filename = "/tmp/test_reader_extract.bfc";
-  const char* output_file = "/tmp/extracted_file.txt";
+  const char* filename = "test_reader_extract.bfc";
+  const char* output_file = "extracted_file.txt";
 
   // Create test container
   int result = create_test_container(filename);
@@ -250,7 +252,11 @@ static int test_extract_file(void) {
   assert(result == BFC_OK);
 
   // Extract to file
+#ifdef _WIN32
+  int out_fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
+#else
   int out_fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+#endif
   assert(out_fd >= 0);
 
   // Debug: check what we can stat first
@@ -273,7 +279,7 @@ static int test_extract_file(void) {
   close(out_fd);
 
   // Verify extracted content
-  FILE* extracted = fopen(output_file, "r");
+  FILE* extracted = fopen(output_file, "rb");
   assert(extracted != NULL);
 
   char buffer[256];
@@ -291,7 +297,7 @@ static int test_extract_file(void) {
 }
 
 static int test_verify_container(void) {
-  const char* filename = "/tmp/test_reader_verify.bfc";
+  const char* filename = "test_reader_verify.bfc";
 
   // Create test container
   int result = create_test_container(filename);
@@ -317,10 +323,10 @@ static int test_verify_container(void) {
 }
 
 static int test_invalid_container(void) {
-  const char* filename = "/tmp/reader_test_invalid.bfc";
+  const char* filename = "reader_test_invalid.bfc";
 
   // Create invalid file
-  FILE* f = fopen(filename, "w");
+  FILE* f = fopen(filename, "wb");
   assert(f != NULL);
   fprintf(f, "This is not a valid BFC container");
   fclose(f);
@@ -334,7 +340,7 @@ static int test_invalid_container(void) {
   unlink(filename);
 
   // Test non-existent file
-  result = bfc_open("/tmp/nonexistent.bfc", &reader);
+  result = bfc_open("nonexistent.bfc", &reader);
   assert(result != BFC_OK);
   assert(reader == NULL);
 
@@ -350,7 +356,7 @@ static int test_error_conditions(void) {
   int result = bfc_open(NULL, &reader);
   assert(result == BFC_E_INVAL);
 
-  result = bfc_open("/tmp/reader_test.bfc", NULL);
+  result = bfc_open("reader_test.bfc", NULL);
   assert(result == BFC_E_INVAL);
 
   // Test operations on NULL reader
@@ -375,7 +381,7 @@ static int test_error_conditions(void) {
 }
 
 static int test_edge_cases(void) {
-  const char* filename = "/tmp/test_reader_edge.bfc";
+  const char* filename = "test_reader_edge.bfc";
 
   // Create container with edge case data
   int result = create_test_container(filename);
@@ -431,7 +437,7 @@ static int test_edge_cases(void) {
 }
 
 static int test_corrupted_data(void) {
-  const char* filename = "/tmp/test_corrupted.bfc";
+  const char* filename = "test_corrupted.bfc";
 
   // Create a valid container first
   int result = create_test_container(filename);
@@ -457,7 +463,7 @@ static int test_corrupted_data(void) {
 }
 
 static int test_large_file_operations(void) {
-  const char* filename = "/tmp/test_large.bfc";
+  const char* filename = "test_large.bfc";
 
   // Create container with larger content
   unlink(filename);
@@ -510,7 +516,7 @@ static int test_large_file_operations(void) {
 }
 
 static int test_empty_container(void) {
-  const char* filename = "/tmp/reader_test_empty.bfc";
+  const char* filename = "reader_test_empty.bfc";
   unlink(filename);
 
   // Create empty container
@@ -549,7 +555,7 @@ static int test_empty_container(void) {
 }
 
 static int test_directory_only_container(void) {
-  const char* filename = "/tmp/test_dirs_only.bfc";
+  const char* filename = "test_dirs_only.bfc";
   unlink(filename);
 
   // Create container with only directories
@@ -605,7 +611,7 @@ static int test_directory_only_container(void) {
 }
 
 static int test_encryption_functions(void) {
-  const char* filename = "/tmp/test_encrypted.bfc";
+  const char* filename = "test_encrypted.bfc";
   unlink(filename);
 
   // Test bfc_has_encryption on non-encrypted container
@@ -681,7 +687,7 @@ static int test_encryption_functions(void) {
 }
 
 static int test_file_size_edge_cases(void) {
-  const char* filename = "/tmp/test_file_size.bfc";
+  const char* filename = "test_file_size.bfc";
 
   // Create a file that's too small to be a valid BFC container
   FILE* tiny_file = fopen(filename, "wb");
@@ -700,7 +706,7 @@ static int test_file_size_edge_cases(void) {
 }
 
 static int test_index_parse_errors(void) {
-  const char* filename = "/tmp/test_parse_error.bfc";
+  const char* filename = "test_parse_error.bfc";
 
   // Create a valid container first
   int result = create_test_container(filename);
@@ -727,7 +733,7 @@ static int test_index_parse_errors(void) {
 }
 
 static int test_extract_edge_cases(void) {
-  const char* filename = "/tmp/test_extract_edge.bfc";
+  const char* filename = "test_extract_edge.bfc";
 
   // Create test container
   int result = create_test_container(filename);
@@ -742,7 +748,11 @@ static int test_extract_edge_cases(void) {
   assert(result == BFC_E_INVAL);
 
   // Test extract non-existent file
-  int fd = open("/tmp/test_extract_output", O_WRONLY | O_CREAT | O_TRUNC, 0644);
+#ifdef _WIN32
+  int fd = open("test_extract_output", O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
+#else
+  int fd = open("test_extract_output", O_WRONLY | O_CREAT | O_TRUNC, 0644);
+#endif
   assert(fd >= 0);
 
   result = bfc_extract_to_fd(reader, "nonexistent.txt", fd);
@@ -753,7 +763,7 @@ static int test_extract_edge_cases(void) {
   assert(result == BFC_E_INVAL);
 
   close(fd);
-  unlink("/tmp/test_extract_output");
+  unlink("test_extract_output");
 
   bfc_close_read(reader);
   unlink(filename);
@@ -762,7 +772,7 @@ static int test_extract_edge_cases(void) {
 }
 
 static int test_verify_edge_cases(void) {
-  const char* filename = "/tmp/test_verify_edge.bfc";
+  const char* filename = "test_verify_edge.bfc";
 
   // Create test container
   int result = create_test_container(filename);
@@ -802,7 +812,7 @@ static int test_verify_edge_cases(void) {
 }
 
 static int test_list_edge_cases(void) {
-  const char* filename = "/tmp/test_list_edge.bfc";
+  const char* filename = "test_list_edge.bfc";
 
   // Create test container
   int result = create_test_container(filename);
@@ -838,7 +848,7 @@ static int test_list_edge_cases(void) {
 }
 
 static int test_compressed_files(void) {
-  const char* filename = "/tmp/test_compressed.bfc";
+  const char* filename = "test_compressed.bfc";
   unlink(filename);
 
 #ifdef BFC_WITH_ZSTD
@@ -901,7 +911,11 @@ static int test_compressed_files(void) {
     assert(bytes_read == 0);
 
     // Test extracting compressed file
-    int fd = open("/tmp/test_compressed_output", O_WRONLY | O_CREAT | O_TRUNC, 0644);
+#ifdef _WIN32
+    int fd = open("test_compressed_output", O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
+#else
+    int fd = open("test_compressed_output", O_WRONLY | O_CREAT | O_TRUNC, 0644);
+#endif
     assert(fd >= 0);
 
     result = bfc_extract_to_fd(reader, "compressed.txt", fd);
@@ -909,13 +923,13 @@ static int test_compressed_files(void) {
     close(fd);
 
     // Verify extracted content
-    FILE* extracted = fopen("/tmp/test_compressed_output", "r");
+    FILE* extracted = fopen("test_compressed_output", "rb");
     assert(extracted != NULL);
     fseek(extracted, 0, SEEK_END);
     long extracted_size = ftell(extracted);
     assert(extracted_size == 52000);
     fclose(extracted);
-    unlink("/tmp/test_compressed_output");
+    unlink("test_compressed_output");
 
     free(buffer);
     bfc_close_read(reader);
@@ -932,7 +946,7 @@ static int test_compressed_files(void) {
 }
 
 static int test_read_errors(void) {
-  const char* filename = "/tmp/test_read_errors.bfc";
+  const char* filename = "test_read_errors.bfc";
 
   // Create test container
   int result = create_test_container(filename);
@@ -989,8 +1003,8 @@ static int create_symlink_test_container(const char* filename) {
 
   // Add a regular file
   const char* content = "Test file content for symlinks";
-  const char* src_file = "/tmp/reader_test_src_symlink.txt";
-  FILE* src = fopen(src_file, "w");
+  const char* src_file = "reader_test_src_symlink.txt";
+  FILE* src = fopen(src_file, "wb");
   if (!src) {
     bfc_close(writer);
     return BFC_E_IO;
@@ -1026,8 +1040,8 @@ static int create_symlink_test_container(const char* filename) {
     return result;
   }
 
-  result = bfc_add_symlink(writer, "absolute_link", "/tmp/absolute_target", 0755,
-                           bfc_os_current_time_ns());
+  result =
+      bfc_add_symlink(writer, "absolute_link", "absolute_target", 0755, bfc_os_current_time_ns());
   if (result != BFC_OK) {
     bfc_close(writer);
     return result;
@@ -1081,7 +1095,7 @@ static int symlink_list_callback(const bfc_entry_t* entry, void* user) {
 }
 
 static int test_read_symlink_stat(void) {
-  const char* filename = "/tmp/reader_test_symlink_stat.bfc";
+  const char* filename = "reader_test_symlink_stat.bfc";
 
   // Create test container
   int result = create_symlink_test_container(filename);
@@ -1112,7 +1126,7 @@ static int test_read_symlink_stat(void) {
   result = bfc_stat(reader, "absolute_link", &entry);
   assert(result == BFC_OK);
   assert(S_ISLNK(entry.mode));
-  assert(entry.size == strlen("/tmp/absolute_target"));
+  assert(entry.size == strlen("absolute_target"));
 
   // Test relative symlink
   result = bfc_stat(reader, "relative_link", &entry);
@@ -1133,7 +1147,7 @@ static int test_read_symlink_stat(void) {
 }
 
 static int test_read_symlink_content(void) {
-  const char* filename = "/tmp/reader_test_symlink_content.bfc";
+  const char* filename = "reader_test_symlink_content.bfc";
 
   // Create test container
   int result = create_symlink_test_container(filename);
@@ -1163,9 +1177,9 @@ static int test_read_symlink_content(void) {
   // Test reading absolute symlink target
   memset(buffer, 0, sizeof(buffer));
   bytes_read = bfc_read(reader, "absolute_link", 0, buffer, sizeof(buffer));
-  assert(bytes_read == strlen("/tmp/absolute_target"));
+  assert(bytes_read == strlen("absolute_target"));
   buffer[bytes_read] = '\0';
-  assert(strcmp(buffer, "/tmp/absolute_target") == 0);
+  assert(strcmp(buffer, "absolute_target") == 0);
 
   // Test reading relative symlink target
   memset(buffer, 0, sizeof(buffer));
@@ -1188,7 +1202,7 @@ static int test_read_symlink_content(void) {
 }
 
 static int test_symlink_listing(void) {
-  const char* filename = "/tmp/reader_test_symlink_list.bfc";
+  const char* filename = "reader_test_symlink_list.bfc";
 
   // Create test container
   int result = create_symlink_test_container(filename);
@@ -1219,7 +1233,7 @@ static int test_symlink_listing(void) {
 }
 
 static int test_symlink_partial_read(void) {
-  const char* filename = "/tmp/reader_test_symlink_partial.bfc";
+  const char* filename = "reader_test_symlink_partial.bfc";
 
   // Create test container
   int result = create_symlink_test_container(filename);
@@ -1232,21 +1246,21 @@ static int test_symlink_partial_read(void) {
 
   // Test partial reads of symlink targets
   char buffer[20];
-  const char* target = "/tmp/absolute_target";
+  const char* target = "absolute_target";
   size_t target_len = strlen(target);
 
-  // Read first part of absolute symlink target
+  // Read first part of absolute symlink target ("absol" = first 5 chars)
   size_t bytes_read = bfc_read(reader, "absolute_link", 0, buffer, 5);
   assert(bytes_read == 5);
   buffer[bytes_read] = '\0';
-  assert(strcmp(buffer, "/tmp/") == 0);
+  assert(strcmp(buffer, "absol") == 0);
 
-  // Read second part - remaining bytes
+  // Read second part - remaining bytes ("ute_target" = chars 5..14)
   size_t remaining = target_len - 5;
   bytes_read = bfc_read(reader, "absolute_link", 5, buffer, remaining);
   assert(bytes_read == remaining);
   buffer[bytes_read] = '\0';
-  assert(strcmp(buffer, "absolute_target") == 0);
+  assert(strcmp(buffer, "ute_target") == 0);
 
   bfc_close_read(reader);
   unlink(filename);
@@ -1307,4 +1321,4 @@ int test_reader(void) {
     return 1;
 
   return 0;
-}
\ No newline at end of file
+}
diff --git a/tests/unit/test_util.c b/tests/unit/test_util.c
index 38faa3b..5600fde 100644
--- a/tests/unit/test_util.c
+++ b/tests/unit/test_util.c
@@ -141,4 +141,4 @@ int test_util(void) {
     return 1;
 
   return 0;
-}
\ No newline at end of file
+}
diff --git a/tests/unit/test_writer.c b/tests/unit/test_writer.c
index b524b29..9c49da7 100644
--- a/tests/unit/test_writer.c
+++ b/tests/unit/test_writer.c
@@ -20,10 +20,12 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#ifndef _WIN32
 #include <unistd.h>
+#endif
 
 static int test_create_empty_container(void) {
-  const char* filename = "/tmp/writer_test_empty.bfc";
+  const char* filename = "writer_test_empty.bfc";
 
   // Clean up any existing file
   unlink(filename);
@@ -54,15 +56,15 @@ static int test_create_empty_container(void) {
 }
 
 static int test_add_single_file(void) {
-  const char* filename = "/tmp/test_single.bfc";
+  const char* filename = "test_single.bfc";
   const char* content = "Hello, BFC!";
 
   // Clean up
   unlink(filename);
 
   // Create temporary source file
-  const char* src_file = "/tmp/test_src.txt";
-  FILE* src = fopen(src_file, "w");
+  const char* src_file = "test_src.txt";
+  FILE* src = fopen(src_file, "wb");
   assert(src != NULL);
   fwrite(content, 1, strlen(content), src);
   fclose(src);
@@ -96,7 +98,7 @@ static int test_add_single_file(void) {
 }
 
 static int test_add_directory(void) {
-  const char* filename = "/tmp/test_dir.bfc";
+  const char* filename = "test_dir.bfc";
 
   unlink(filename);
 
@@ -118,7 +120,7 @@ static int test_add_directory(void) {
 }
 
 static int test_duplicate_paths(void) {
-  const char* filename = "/tmp/test_dup.bfc";
+  const char* filename = "test_dup.bfc";
 
   unlink(filename);
 
@@ -141,7 +143,7 @@ static int test_duplicate_paths(void) {
 }
 
 static int test_invalid_paths(void) {
-  const char* filename = "/tmp/writer_test_invalid.bfc";
+  const char* filename = "writer_test_invalid.bfc";
 
   unlink(filename);
 
@@ -166,7 +168,7 @@ static int test_invalid_paths(void) {
 }
 
 static int test_multiple_files(void) {
-  const char* filename = "/tmp/test_multi.bfc";
+  const char* filename = "test_multi.bfc";
 
   unlink(filename);
 
@@ -186,9 +188,9 @@ static int test_multiple_files(void) {
   for (int i = 0; i < num_files; i++) {
     // Create temp source file
     char src_name[64];
-    snprintf(src_name, sizeof(src_name), "/tmp/test_src_%d.txt", i);
+    snprintf(src_name, sizeof(src_name), "test_src_%d.txt", i);
 
-    FILE* src = fopen(src_name, "w");
+    FILE* src = fopen(src_name, "wb");
     assert(src != NULL);
     fwrite(contents[i], 1, strlen(contents[i]), src);
     fclose(src);
@@ -220,20 +222,20 @@ static int test_error_conditions(void) {
   int result = bfc_create(NULL, 4096, 0, &writer);
   assert(result == BFC_E_INVAL);
 
-  result = bfc_create("/tmp/writer_test.bfc", 4096, 0, NULL);
+  result = bfc_create("writer_test.bfc", 4096, 0, NULL);
   assert(result == BFC_E_INVAL);
 
   // Test block size of 0 (should default to header size)
-  result = bfc_create("/tmp/writer_test.bfc", 0, 0, &writer);
+  result = bfc_create("writer_test.bfc", 0, 0, &writer);
   assert(result == BFC_OK);
   bfc_close(writer);
-  unlink("/tmp/writer_test.bfc");
+  unlink("writer_test.bfc");
 
   // Note: Small block size may be accepted and rounded up
-  result = bfc_create("/tmp/writer_test.bfc", 100, 0, &writer);
+  result = bfc_create("writer_test.bfc", 100, 0, &writer);
   if (result == BFC_OK) {
     bfc_close(writer);
-    unlink("/tmp/writer_test.bfc");
+    unlink("writer_test.bfc");
   } else {
     assert(result == BFC_E_INVAL);
   }
@@ -259,7 +261,7 @@ static int test_error_conditions(void) {
 }
 
 static int test_file_parameter_validation(void) {
-  const char* filename = "/tmp/test_validation.bfc";
+  const char* filename = "test_validation.bfc";
   unlink(filename);
 
   bfc_t* writer = NULL;
@@ -299,7 +301,7 @@ static int test_file_parameter_validation(void) {
 }
 
 static int test_large_file_handling(void) {
-  const char* filename = "/tmp/test_large_writer.bfc";
+  const char* filename = "test_large_writer.bfc";
   unlink(filename);
 
   bfc_t* writer = NULL;
@@ -332,7 +334,7 @@ static int test_large_file_handling(void) {
 }
 
 static int test_binary_file_handling(void) {
-  const char* filename = "/tmp/test_binary.bfc";
+  const char* filename = "test_binary.bfc";
   unlink(filename);
 
   bfc_t* writer = NULL;
@@ -365,7 +367,7 @@ static int test_binary_file_handling(void) {
 }
 
 static int test_many_files(void) {
-  const char* filename = "/tmp/test_many.bfc";
+  const char* filename = "test_many.bfc";
   unlink(filename);
 
   bfc_t* writer = NULL;
@@ -401,7 +403,7 @@ static int test_many_files(void) {
 }
 
 static int test_deep_directory_structure(void) {
-  const char* filename = "/tmp/test_deep.bfc";
+  const char* filename = "test_deep.bfc";
   unlink(filename);
 
   bfc_t* writer = NULL;
@@ -437,7 +439,7 @@ static int test_deep_directory_structure(void) {
 }
 
 static int test_various_permissions(void) {
-  const char* filename = "/tmp/test_perms.bfc";
+  const char* filename = "test_perms.bfc";
   unlink(filename);
 
   bfc_t* writer = NULL;
@@ -485,7 +487,7 @@ static int test_various_permissions(void) {
 }
 
 static int test_empty_file(void) {
-  const char* filename = "/tmp/test_empty_file.bfc";
+  const char* filename = "test_empty_file.bfc";
   unlink(filename);
 
   bfc_t* writer = NULL;
@@ -515,7 +517,7 @@ static int test_empty_file(void) {
 }
 
 static int test_finish_before_close(void) {
-  const char* filename = "/tmp/test_finish_close.bfc";
+  const char* filename = "test_finish_close.bfc";
   unlink(filename);
 
   bfc_t* writer = NULL;
@@ -545,7 +547,7 @@ static int test_finish_before_close(void) {
 }
 
 static int test_add_simple_symlink(void) {
-  const char* filename = "/tmp/test_symlink.bfc";
+  const char* filename = "test_symlink.bfc";
   const char* target = "target.txt";
 
   // Clean up
@@ -570,8 +572,8 @@ static int test_add_simple_symlink(void) {
 }
 
 static int test_add_absolute_symlink(void) {
-  const char* filename = "/tmp/test_abs_symlink.bfc";
-  const char* target = "/tmp/absolute_target.txt";
+  const char* filename = "test_abs_symlink.bfc";
+  const char* target = "absolute_target.txt";
 
   // Clean up
   unlink(filename);
@@ -595,7 +597,7 @@ static int test_add_absolute_symlink(void) {
 }
 
 static int test_add_relative_symlink(void) {
-  const char* filename = "/tmp/test_rel_symlink.bfc";
+  const char* filename = "test_rel_symlink.bfc";
   const char* target = "../parent/target.txt";
 
   // Clean up
@@ -620,7 +622,7 @@ static int test_add_relative_symlink(void) {
 }
 
 static int test_symlink_parameter_validation(void) {
-  const char* filename = "/tmp/test_symlink_validation.bfc";
+  const char* filename = "test_symlink_validation.bfc";
 
   // Clean up
   unlink(filename);
@@ -655,7 +657,7 @@ static int test_symlink_parameter_validation(void) {
 }
 
 static int test_symlink_duplicate_paths(void) {
-  const char* filename = "/tmp/test_symlink_dup.bfc";
+  const char* filename = "test_symlink_dup.bfc";
 
   // Clean up
   unlink(filename);
@@ -683,7 +685,7 @@ static int test_symlink_duplicate_paths(void) {
 }
 
 static int test_symlink_long_target(void) {
-  const char* filename = "/tmp/test_symlink_long.bfc";
+  const char* filename = "test_symlink_long.bfc";
 
   // Create a long target path
   char long_target[1024];
@@ -712,15 +714,15 @@ static int test_symlink_long_target(void) {
 }
 
 static int test_mixed_content_with_symlinks(void) {
-  const char* filename = "/tmp/test_mixed_symlinks.bfc";
+  const char* filename = "test_mixed_symlinks.bfc";
   const char* content = "Test file content";
 
   // Clean up
   unlink(filename);
 
   // Create temporary source file
-  const char* src_file = "/tmp/test_mixed_src.txt";
-  FILE* src = fopen(src_file, "w");
+  const char* src_file = "test_mixed_src.txt";
+  FILE* src = fopen(src_file, "wb");
   assert(src != NULL);
   fwrite(content, 1, strlen(content), src);
   fclose(src);
@@ -750,7 +752,7 @@ static int test_mixed_content_with_symlinks(void) {
   result = bfc_add_symlink(writer, "link_to_dir", "testdir", 0755, bfc_os_current_time_ns());
   assert(result == BFC_OK);
 
-  result = bfc_add_symlink(writer, "absolute_link.txt", "/tmp/absolute_target", 0755,
+  result = bfc_add_symlink(writer, "absolute_link.txt", "absolute_target", 0755,
                            bfc_os_current_time_ns());
   assert(result == BFC_OK);
 
@@ -813,4 +815,4 @@ int test_writer(void) {
     return 1;
 
   return 0;
-}
\ No newline at end of file
+}