@@ -576,8 +576,10 @@ def _all_items(section: str) -> List[Tuple[str, str]]:
             value = match.group(2).strip()
 
             if keyword in ["gitdir", "gitdir/i"]:
-                value = osp.expanduser(value).replace("\\", "/")
-                git_dir = os.fspath(self._repo.git_dir).replace("\\", "/") if self._repo.git_dir else None
+                value = osp.expanduser(value)
+                git_dir = os.fspath(self._repo.git_dir) if self._repo.git_dir else None
+                if sys.platform == "win32":
+                    git_dir = git_dir.replace("\\", "/") if git_dir else None
 
                 drive, _tail = osp.splitdrive(value)
                 if not drive and not any(value.startswith(s) for s in ["./", "/"]):
 
@@ -316,17 +316,20 @@ def join_path_native(a: PathLike, *p: PathLike) -> PathLike:
 
 
 def _is_path_rooted(path: PathLike) -> bool:
-    r"""Whether ``path`` has a root component after any drive.
+    r"""Whether ``path`` has a root, including one encoded in a UNC drive.
 
     On Windows, ``\directory`` is rooted on the current drive without being
     absolute, while ``C:\directory`` has both a drive and a root. In contrast,
     ``directory`` and the drive-relative ``C:directory`` have no root.
+    UNC paths are rooted: ``\\server\share`` stores the share in the drive
+    returned by :func:`os.path.splitdrive`, while ``\\server\share\directory``
+    additionally has a rooted tail.
     On POSIX, which has no drive concept, this simply distinguishes absolute
     paths such as ``/directory`` from relative paths such as ``directory``.
     """
-    _drive, tail = osp.splitdrive(os.fspath(path))
+    drive, tail = osp.splitdrive(os.fspath(path))
     separators = (os.sep,) if os.altsep is None else (os.sep, os.altsep)
-    return tail.startswith(separators)
+    return tail.startswith(separators) or drive.startswith(separators)
 
 
 def _to_relative_path(root: PathLike, path: PathLike) -> str:
 
@@ -7,6 +7,7 @@
 import io
 import os
 import os.path as osp
+import sys
 from unittest import mock
 
 import pytest
@@ -430,6 +431,7 @@ def test_multiple_include_paths_with_same_key(self, rw_dir):
     def test_conditional_includes_from_git_dir(self, rw_dir):
         # Initiate repository path.
         git_dir = osp.join(rw_dir, "target1", "repo1")
+        git_dir_pattern = git_dir.replace("\\", "/")
         os.makedirs(git_dir)
 
         # Initiate mocked repository.
@@ -441,37 +443,42 @@ def test_conditional_includes_from_git_dir(self, rw_dir):
         template = '[includeIf "{}:{}"]\n    path={}\n'
 
         with open(path1, "w") as stream:
+            # on Windows, this writes a backslash pattern.
             stream.write(template.format("gitdir", git_dir, path2))
 
         # Ensure that config is ignored if no repo is set.
         with GitConfigParser(path1) as config:
             assert not config._has_includes()
             assert config._included_paths() == []
 
-        # Ensure that config is included if path is matching git_dir.
-        with GitConfigParser(path1, repo=repo) as config:
-            assert config._has_includes()
-            assert config._included_paths() == [("path", path2)]
+        # Git uses forward slashes in gitdir patterns on every platform:
+        # backslashes escape the next pattern character rather than separate
+        # path components. On Windows, GitPython therefore normalizes git_dir
+        # to forward slashes but leaves this backslash pattern unchanged, so
+        # the two do not match and no path is included.
+        with GitConfigParser(path1, repo=repo, merge_includes=False) as config:
+            expected_paths = [] if sys.platform == "win32" else [("path", path2)]
+            assert config._included_paths() == expected_paths
 
         # Ensure that Git's forward-slash syntax matches native Windows paths.
         with open(path1, "w") as stream:
-            stream.write(template.format("gitdir", git_dir.replace("\\", "/"), path2))
+            stream.write(template.format("gitdir", git_dir_pattern, path2))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert config._has_includes()
             assert config._included_paths() == [("path", path2)]
 
         # Ensure that config is ignored if case is incorrect.
         with open(path1, "w") as stream:
-            stream.write(template.format("gitdir", git_dir.upper(), path2))
+            stream.write(template.format("gitdir", git_dir_pattern.upper(), path2))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert not config._has_includes()
             assert config._included_paths() == []
 
         # Ensure that config is included if case is ignored.
         with open(path1, "w") as stream:
-            stream.write(template.format("gitdir/i", git_dir.upper(), path2))
+            stream.write(template.format("gitdir/i", git_dir_pattern.upper(), path2))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert config._has_includes()
@@ -501,6 +508,20 @@ def test_conditional_includes_from_git_dir(self, rw_dir):
             assert config._has_includes()
             assert config._included_paths() == [("path", path2)]
 
+    @with_rw_directory
+    def test_conditional_includes_do_not_treat_backslashes_as_separators(self, rw_dir):
+        git_dir = osp.join(rw_dir, "target", "repo")
+        repo = mock.Mock(git_dir=git_dir)
+        config_path = osp.join(rw_dir, "config")
+        included_path = osp.join(rw_dir, "included")
+        pattern = git_dir.replace("\\", "/").replace("/target/repo", R"/target\repo")
+
+        with open(config_path, "w") as stream:
+            stream.write(f'[includeIf "gitdir:{pattern}"]\n    path={included_path}\n')
+
+        with GitConfigParser(config_path, repo=repo, merge_includes=False) as config:
+            assert config._included_paths() == []
+
     @with_rw_directory
     def test_conditional_includes_from_branch_name(self, rw_dir):
         # Initiate mocked branch.
 
@@ -1090,6 +1090,15 @@ class Mocked:
         actual_path = index._to_relative_path(path)
         self.assertEqual(expected_path, actual_path)
 
+    @pytest.mark.skipif(sys.platform != "win32", reason="Specifically for Windows.")
+    def test__to_relative_path_windows_unc_share_root(self):
+        for repo_root in [R"\\server\share", R"\\?\UNC\server\share"]:
+            with self.subTest(repo_root=repo_root):
+                repo = mock.Mock(bare=False, git_dir=repo_root, working_tree_dir=repo_root)
+                index = IndexFile(repo)
+
+                self.assertEqual(index._to_relative_path(repo_root), ".")
+
     @pytest.mark.skipif(sys.platform != "win32", reason="Specifically for Windows.")
     @with_rw_directory
     def test__to_relative_path_windows_path_kinds(self, rw_dir):