--- a/soupsieve/css_match.py
+++ b/soupsieve/css_match.py
@@ -533,6 +533,7 @@ def __init__(
         self.enable_cache = not bool(self.flags & util.NOCACHE)
         self.iframe_restrict = False
         self.nth_cache: dict[Hashable, dict[Hashable, list[int]]] = {}
+        self.sib_cache: dict[Hashable, dict[Hashable, int]] = {}

         # Find the root element for the whole tree
         doc = scope
@@ -560,6 +561,7 @@ def reset(self) -> None:  # pragma: no cover
         """Reset."""

         self.nth_cache.clear()
+        self.sib_cache.clear()

     def supports_namespaces(self) -> bool:
         """Check if namespaces are supported in the HTML type."""
@@ -805,6 +807,75 @@ def match_tag(self, el: bs4.Tag, tag: ct.SelectorTag | None) -> bool:
                 match = False
         return match

+    def match_general_sibling(self, el: bs4.Tag, relation: ct.SelectorList) -> bool:
+        """Match general sibling combinator."""
+
+        found = False
+
+        if relation[0] is ct.Null:  # pragma: no cover
+            return found
+
+        pkey: tuple[str | None, int] | None = None
+        key: tuple[ct.SelectorList, int] | None = None
+
+        # Setup the cache by the parent if present
+        parent = self.get_parent(el)
+        if parent is None:  # pragma: no cover
+            return found
+
+        if parent:
+            pkey = (parent.name, id(parent))
+
+            # Initialize the cache if necessary
+            if pkey not in self.sib_cache:
+                self.sib_cache[pkey] = {}
+
+        # Check the cache to see if we already know where the first sibling is,
+        # and if we do, check if we are on the correct side of it.
+        # If we've previously searched and found no sibling, there is no sibling.
+        # Lastly, if this is our first time, setup the cache.
+        reverse = relation[0].rel_type == REL_HAS_SIBLING
+        start = len(parent) - 1 if reverse else 0
+        if pkey:
+            key = (relation, id(relation))
+            if key in self.sib_cache[pkey]:
+                index = self.sib_cache[pkey][key]
+                if index >= 0:
+                    a, b = (index, start) if reverse else (start, index)
+                    return not within(el, parent, a, b)
+                else:
+                    return False
+            self.sib_cache[pkey][key] = start
+
+        # Start at the furthest endpoint and walk back towards the element looking for siblings.
+        # The current element counts as a sibling, but will not cause a match.
+        passed = False
+        incr = -1 if reverse else 1
+        for child in self.get_children(parent, start=start, reverse=reverse):
+            start += incr
+            if not isinstance(child, bs4.Tag):
+                continue
+
+            # Flag that we are passing the element.
+            # Any siblings we find aren't valid for this element.
+            if child is el:
+                passed = True
+
+            # We found the furthest sibling.
+            if self.match_selectors(child, relation):
+                found = True
+                break
+
+        # Cache the index of the sibling or mark as there being no siblings.
+        if pkey and key:
+            self.sib_cache[pkey][key] = start if found else -1
+
+        # If we passed the current element and then found a sibling, it doesn't count as a match.
+        if passed:
+            found = False
+
+        return found
+
     def match_past_relations(self, el: bs4.Tag, relation: ct.SelectorList) -> bool:
         """Match past relationship."""

@@ -814,23 +885,22 @@ def match_past_relations(self, el: bs4.Tag, relation: ct.SelectorList) -> bool:
             return found

         if relation[0].rel_type == REL_PARENT:
-            parent = self.get_parent(el, no_iframe=self.iframe_restrict)
-            while not found and parent:
-                found = self.match_selectors(parent, relation)
-                parent = self.get_parent(parent, no_iframe=self.iframe_restrict)
+            parent: bs4.Tag | None = el
+            while not found and parent and (parent := self.get_parent(parent, no_iframe=self.iframe_restrict)):
+                found = parent is not None and self.match_selectors(parent, relation)
         elif relation[0].rel_type == REL_CLOSE_PARENT:
             parent = self.get_parent(el, no_iframe=self.iframe_restrict)
-            if parent:
-                found = self.match_selectors(parent, relation)
+            found = parent is not None and self.match_selectors(parent, relation)
         elif relation[0].rel_type == REL_SIBLING:
-            sibling = self.get_previous_tag(el)
-            while not found and sibling:
-                found = self.match_selectors(sibling, relation)
-                sibling = self.get_previous_tag(sibling)
+            if self.enable_cache:
+                found = self.match_general_sibling(el, relation)
+            else:
+                sibling: bs4.Tag | None = el
+                while not found and sibling and (sibling := self.get_previous_tag(sibling)):
+                    found = sibling is not None and self.match_selectors(sibling, relation)
         elif relation[0].rel_type == REL_CLOSE_SIBLING:
             sibling = self.get_previous_tag(el)
-            if sibling and self.is_tag(sibling):
-                found = self.match_selectors(sibling, relation)
+            found = sibling is not None and self.match_selectors(sibling, relation)
         return found

     def match_future_child(self, parent: bs4.Tag, relation: ct.SelectorList, recursive: bool = False) -> bool:
@@ -842,8 +912,8 @@ def match_future_child(self, parent: bs4.Tag, relation: ct.SelectorList, recursi
         else:
             children = self.get_tag_children
         for child in children(parent, no_iframe=self.iframe_restrict):
-            match = self.match_selectors(child, relation)
-            if match:
+            if self.match_selectors(child, relation):
+                match = True
                 break
         return match

@@ -860,14 +930,15 @@ def match_future_relations(self, el: bs4.Tag, relation: ct.SelectorList) -> bool
         elif relation[0].rel_type == REL_HAS_CLOSE_PARENT:
             found = self.match_future_child(el, relation)
         elif relation[0].rel_type == REL_HAS_SIBLING:
-            sibling = self.get_next_tag(el)
-            while not found and sibling:
-                found = self.match_selectors(sibling, relation)
-                sibling = self.get_next_tag(sibling)
+            if self.enable_cache:
+                found = self.match_general_sibling(el, relation)
+            else:
+                sibling: bs4.Tag | None = el
+                while not found and sibling and (sibling := self.get_next_tag(sibling)):
+                    found = self.match_selectors(sibling, relation)
         elif relation[0].rel_type == REL_HAS_CLOSE_SIBLING:
             sibling = self.get_next_tag(el)
-            if sibling and self.is_tag(sibling):
-                found = self.match_selectors(sibling, relation)
+            found = sibling is not None and self.match_selectors(sibling, relation)
         return found

     def match_relations(self, el: bs4.Tag, relation: ct.SelectorList) -> bool: