diff --git a/libcxx/docs/Status/RangesPaper.csv b/libcxx/docs/Status/RangesPaper.csv
--- a/libcxx/docs/Status/RangesPaper.csv
+++ b/libcxx/docs/Status/RangesPaper.csv
@@ -137,7 +137,7 @@
 | [range.subrange]",Christopher Di Bella,✅
 `[range.all] <http://wg21.link/range.all>`_,`view::all <https://llvm.org/D102028>`_,"[range.subrange], [range.view.ref]",Zoe Carver,✅
 `[range.view.ref] <http://wg21.link/range.view>`_,`ref-view <https://llvm.org/D102020>`_,[view.interface],Zoe Carver,✅
-`[range.filter] <http://wg21.link/range.filter>`_,filter_view,[range.all],Louis Dionne,Not started
+`[range.filter] <http://wg21.link/range.filter>`_,`filter_view <https://llvm.org/D109086>`_,[range.all],Louis Dionne,✅
 `[range.transform] <http://wg21.link/range.transform>`_,`transform_view <https://llvm.org/D103056>`_,[range.all],Zoe Carver,✅
 `[range.iota] <http://wg21.link/range.iota>`_,iota_view,[range.all],Zoe Carver,✅
 `[range.take] <http://wg21.link/range.take>`_,take_view,[range.all],Zoe Carver,✅
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -320,6 +320,7 @@
   __ranges/empty.h
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h
+  __ranges/filter_view.h
   __ranges/iota_view.h
   __ranges/join_view.h
   __ranges/non_propagating_cache.h
diff --git a/libcxx/include/__ranges/filter_view.h b/libcxx/include/__ranges/filter_view.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__ranges/filter_view.h
@@ -0,0 +1,274 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCPP___RANGES_FILTER_VIEW_H
+#define _LIBCPP___RANGES_FILTER_VIEW_H
+
+// #include <__ranges/find_if.h> // TODO: Use this when available
+#include <__config>
+#include <__debug>
+#include <__functional/reference_wrapper.h>
+#include <__iterator/concepts.h>
+#include <__memory/addressof.h>
+#include <__ranges/access.h>
+#include <__ranges/all.h>
+#include <__ranges/concepts.h>
+#include <__ranges/copyable_box.h>
+#include <__ranges/non_propagating_cache.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/view_interface.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <concepts>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+namespace ranges {
+  //////////// TODO: Remove this when ranges::find_if lands
+  template<input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Proj = identity,
+             indirect_unary_predicate<projected<_Ip, _Proj>> _Pred>
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr _Ip find_if(_Ip __first, const _Sp __last, _Pred __pred, _Proj __proj = {}) {
+    for (; __first != __last; ++__first) {
+      if (_VSTD::invoke(__pred, _VSTD::invoke(__proj, *__first))) {
+        return __first;
+      }
+    }
+    return __first;
+  }
+
+  template<input_range _Range, class _Proj = identity,
+           indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr borrowed_iterator_t<_Range> find_if(_Range&& __range, _Pred __pred, _Proj __proj = {}) {
+    return ranges::find_if(ranges::begin(__range), ranges::end(__range), _VSTD::move(__pred), _VSTD::move(__proj));
+  }
+  //////////////////////////////////////////
+
+  template<input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
+    requires view<_View> && is_object_v<_Pred>
+  class filter_view : public view_interface<filter_view<_View, _Pred>> {
+    [[no_unique_address]] __copyable_box<_Pred> __pred_;
+    [[no_unique_address]] _View __base_ = _View();
+
+    // We cache the result of begin() to allow providing an amortized O(1) begin() whenever
+    // the underlying range is at least a forward_range.
+    static constexpr bool _UseCache = forward_range<_View>;
+    using _Cache = _If<_UseCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
+    [[no_unique_address]] _Cache __cached_begin_ = _Cache();
+
+    class __iterator;
+    class __sentinel;
+
+  public:
+    _LIBCPP_HIDE_FROM_ABI
+    filter_view() requires default_initializable<_View> && default_initializable<_Pred> = default;
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr filter_view(_View __base, _Pred __pred)
+      : __pred_(in_place, _VSTD::move(__pred)), __base_(_VSTD::move(__base))
+    { }
+
+    template<class _Vp = _View>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr _View base() const& requires copy_constructible<_Vp> { return __base_; }
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr _View base() && { return _VSTD::move(__base_); }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr _Pred const& pred() const { return *__pred_; }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __iterator begin() {
+      _LIBCPP_ASSERT(__pred_.__has_value(), "Trying to call begin() on a filter_view that does not have a valid predicate.");
+      if constexpr (_UseCache) {
+        if (!__cached_begin_.__has_value()) {
+          __cached_begin_.__emplace(ranges::find_if(__base_, _VSTD::ref(*__pred_)));
+        }
+        return {*this, *__cached_begin_};
+      } else {
+        return {*this, ranges::find_if(__base_, _VSTD::ref(*__pred_))};
+      }
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto end() {
+      if constexpr (common_range<_View>)
+        return __iterator{*this, ranges::end(__base_)};
+      else
+        return __sentinel{*this};
+    }
+  };
+
+  template<class _Range, class _Pred>
+  filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
+
+  template<class _View>
+  struct __filter_iterator_category { };
+
+  template<forward_range _View>
+  struct __filter_iterator_category<_View> {
+    using _Cat = typename iterator_traits<iterator_t<_View>>::iterator_category;
+    using iterator_category =
+      _If<derived_from<_Cat, bidirectional_iterator_tag>, bidirectional_iterator_tag,
+      _If<derived_from<_Cat, forward_iterator_tag>,       forward_iterator_tag,
+      /* else */                                          _Cat
+    >>;
+  };
+
+  template<input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
+    requires view<_View> && is_object_v<_Pred>
+  class filter_view<_View, _Pred>::__iterator : public __filter_iterator_category<_View> {
+  public:
+    [[no_unique_address]] iterator_t<_View> __current_ = iterator_t<_View>();
+    [[no_unique_address]] filter_view* __parent_ = nullptr;
+
+    using iterator_concept =
+      _If<bidirectional_range<_View>, bidirectional_iterator_tag,
+      _If<forward_range<_View>,       forward_iterator_tag,
+      /* else */                      input_iterator_tag
+    >>;
+    // using iterator_category = inherited;
+    using value_type = range_value_t<_View>;
+    using difference_type = range_difference_t<_View>;
+
+    _LIBCPP_HIDE_FROM_ABI
+    __iterator() requires default_initializable<iterator_t<_View>> = default;
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __iterator(filter_view& __parent, iterator_t<_View> __current)
+      : __current_(_VSTD::move(__current)), __parent_(_VSTD::addressof(__parent))
+    { }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr iterator_t<_View> const& base() const& noexcept { return __current_; }
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr iterator_t<_View> base() && { return _VSTD::move(__current_); }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr range_reference_t<_View> operator*() const { return *__current_; }
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr iterator_t<_View> operator->() const
+      requires __has_arrow<iterator_t<_View>> && copyable<iterator_t<_View>>
+    {
+      return __current_;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __iterator& operator++() {
+      __current_ = ranges::find_if(_VSTD::move(++__current_), ranges::end(__parent_->__base_),
+                                   _VSTD::ref(*__parent_->__pred_));
+      return *this;
+    }
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr void operator++(int) { ++*this; }
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __iterator operator++(int) requires forward_range<_View> {
+      auto __tmp = *this;
+      ++*this;
+      return __tmp;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __iterator& operator--() requires bidirectional_range<_View> {
+      do {
+        --__current_;
+      } while (!_VSTD::invoke(*__parent_->__pred_, *__current_));
+      return *this;
+    }
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __iterator operator--(int) requires bidirectional_range<_View> {
+      auto tmp = *this;
+      --*this;
+      return tmp;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr bool operator==(__iterator const& __x, __iterator const& __y)
+      requires equality_comparable<iterator_t<_View>>
+    {
+      return __x.__current_ == __y.__current_;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr range_rvalue_reference_t<_View> iter_move(__iterator const& __it)
+      noexcept(noexcept(ranges::iter_move(__it.__current_)))
+    {
+      return ranges::iter_move(__it.__current_);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr void iter_swap(__iterator const& __x, __iterator const& __y)
+      noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_)))
+      requires indirectly_swappable<iterator_t<_View>>
+    {
+      return ranges::iter_swap(__x.__current_, __y.__current_);
+    }
+  };
+
+  template<input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
+    requires view<_View> && is_object_v<_Pred>
+  class filter_view<_View, _Pred>::__sentinel {
+  public:
+    sentinel_t<_View> __end_ = sentinel_t<_View>();
+
+    _LIBCPP_HIDE_FROM_ABI
+    __sentinel() = default;
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr explicit __sentinel(filter_view& __parent)
+      : __end_(ranges::end(__parent.__base_))
+    { }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr sentinel_t<_View> base() const { return __end_; }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr bool operator==(__iterator const& __x, __sentinel const& __y) {
+      return __x.__current_ == __y.__end_;
+    }
+  };
+
+namespace views {
+namespace __filter {
+  struct __fn {
+    template<class _Range, class _Pred>
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Range&& __range, _Pred&& __pred) const
+      noexcept(noexcept(filter_view(_VSTD::forward<_Range>(__range), _VSTD::forward<_Pred>(__pred))))
+      -> decltype(      filter_view(_VSTD::forward<_Range>(__range), _VSTD::forward<_Pred>(__pred)))
+      { return          filter_view(_VSTD::forward<_Range>(__range), _VSTD::forward<_Pred>(__pred)); }
+
+    template<class _Pred>
+      requires constructible_from<decay_t<_Pred>, _Pred>
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Pred&& __pred) const
+      noexcept(is_nothrow_constructible_v<decay_t<_Pred>, _Pred>)
+    { return __range_adaptor_closure_t(_VSTD::__bind_back(*this, _VSTD::forward<_Pred>(__pred))); }
+  };
+}
+
+inline namespace __cpo {
+  inline constexpr auto filter = __filter::__fn{};
+}
+} // namespace views
+
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_FILTER_VIEW_H
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -790,6 +790,7 @@
       module empty_view             { private header "__ranges/empty_view.h" }
       module enable_borrowed_range  { private header "__ranges/enable_borrowed_range.h" }
       module enable_view            { private header "__ranges/enable_view.h" }
+      module filter_view            { private header "__ranges/filter_view.h" }
       module iota_view              { private header "__ranges/iota_view.h" }
       module join_view              { private header "__ranges/join_view.h" }
       module non_propagating_cache  { private header "__ranges/non_propagating_cache.h" }
diff --git a/libcxx/include/ranges b/libcxx/include/ranges
--- a/libcxx/include/ranges
+++ b/libcxx/include/ranges
@@ -135,6 +135,15 @@
   template<class T>
     inline constexpr bool enable_borrowed_range<ref_view<T>> = true;
 
+  // [range.filter], filter view
+  template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
+    requires view<V> && is_object_v<Pred>
+  class filter_view;
+
+  namespace views {
+    inline constexpr unspecified filter = unspecified;
+  }
+
   // [range.drop], drop view
   template<view V>
     class drop_view;
@@ -211,6 +220,7 @@
 #include <__ranges/empty.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
+#include <__ranges/filter_view.h>
 #include <__ranges/iota_view.h>
 #include <__ranges/join_view.h>
 #include <__ranges/ref_view.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/ranges/filter_view.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/ranges/filter_view.module.verify.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/ranges/filter_view.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__ranges/filter_view.h'}}
+#include <__ranges/filter_view.h>
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/adaptor.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/adaptor.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/adaptor.pass.cpp
@@ -0,0 +1,172 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::views::filter
+
+#include <ranges>
+
+#include <cassert>
+#include <concepts>
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+
+#include "test_iterators.h"
+
+template <class View, class T>
+concept CanBePiped = requires (View&& view, T&& t) {
+  { std::forward<View>(view) | std::forward<T>(t) };
+};
+
+struct NonCopyablePredicate {
+  NonCopyablePredicate(NonCopyablePredicate const&) = delete;
+  template <class T>
+  constexpr bool operator()(T x) const { return x % 2 == 0; }
+};
+
+struct Range : std::ranges::view_base {
+  using Iterator = forward_iterator<int*>;
+  using Sentinel = sentinel_wrapper<Iterator>;
+  constexpr explicit Range(int* b, int* e) : begin_(b), end_(e) { }
+  constexpr Iterator begin() const { return Iterator(begin_); }
+  constexpr Sentinel end() const { return Sentinel(Iterator(end_)); }
+
+private:
+  int* begin_;
+  int* end_;
+};
+
+struct Pred {
+  constexpr bool operator()(int i) const { return i % 2 == 0; }
+};
+
+template <typename View>
+constexpr void compareViews(View v, std::initializer_list<int> list) {
+  auto b1 = v.begin();
+  auto e1 = v.end();
+  auto b2 = list.begin();
+  auto e2 = list.end();
+  for (; b1 != e1 && b2 != e2; ++b1, ++b2) {
+    assert(*b1 == *b2);
+  }
+  assert(b1 == e1);
+  assert(b2 == e2);
+}
+
+constexpr bool test() {
+  int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+  // Test `views::filter(pred)(v)`
+  {
+    using Result = std::ranges::filter_view<Range, Pred>;
+    Range const range(buff, buff + 8);
+    Pred pred;
+
+    {
+      std::same_as<Result> auto result = std::views::filter(pred)(range);
+      compareViews(result, {0, 2, 4, 6});
+    }
+    {
+      auto const partial = std::views::filter(pred);
+      std::same_as<Result> auto result = partial(range);
+      compareViews(result, {0, 2, 4, 6});
+    }
+  }
+
+  // Test `v | views::filter(pred)`
+  {
+    using Result = std::ranges::filter_view<Range, Pred>;
+    Range const range(buff, buff + 8);
+    Pred pred;
+
+    {
+      std::same_as<Result> auto result = range | std::views::filter(pred);
+      compareViews(result, {0, 2, 4, 6});
+    }
+    {
+      auto const partial = std::views::filter(pred);
+      std::same_as<Result> auto result = range | partial;
+      compareViews(result, {0, 2, 4, 6});
+    }
+  }
+
+  // Test `views::filter(v, pred)`
+  {
+    using Result = std::ranges::filter_view<Range, Pred>;
+    Range const range(buff, buff + 8);
+    Pred pred;
+
+    std::same_as<Result> auto result = std::views::filter(range, pred);
+    compareViews(result, {0, 2, 4, 6});
+  }
+
+  // Test that one can call std::views::filter with arbitrary stuff, as long as we
+  // don't try to actually complete the call by passing it a range.
+  //
+  // That makes no sense and we can't do anything with the result, but it's valid.
+  {
+    struct X { };
+    auto partial = std::views::filter(X{});
+    (void)partial;
+  }
+
+  // Test `adaptor | views::filter(pred)`
+  {
+    Range const range(buff, buff + 8);
+
+    {
+      auto pred1 = [](int i) { return i % 2 == 0; };
+      auto pred2 = [](int i) { return i % 3 == 0; };
+      using Result = std::ranges::filter_view<std::ranges::filter_view<Range, decltype(pred1)>, decltype(pred2)>;
+      std::same_as<Result> auto result = range | std::views::filter(pred1) | std::views::filter(pred2);
+      compareViews(result, {0, 6});
+    }
+    {
+      auto pred1 = [](int i) { return i % 2 == 0; };
+      auto pred2 = [](int i) { return i % 3 == 0; };
+      using Result = std::ranges::filter_view<std::ranges::filter_view<Range, decltype(pred1)>, decltype(pred2)>;
+      auto const partial = std::views::filter(pred1) | std::views::filter(pred2);
+      std::same_as<Result> auto result = range | partial;
+      compareViews(result, {0, 6});
+    }
+  }
+
+  // Test SFINAE friendliness
+  {
+    struct NotAView { };
+    struct NotInvocable { };
+
+    static_assert(!CanBePiped<Range,    decltype(std::views::filter)>);
+    static_assert( CanBePiped<Range,    decltype(std::views::filter(Pred{}))>);
+    static_assert(!CanBePiped<NotAView, decltype(std::views::filter(Pred{}))>);
+    static_assert(!CanBePiped<Range,    decltype(std::views::filter(NotInvocable{}))>);
+
+    static_assert(!std::is_invocable_v<decltype(std::views::filter)>);
+    static_assert(!std::is_invocable_v<decltype(std::views::filter), Pred, Range>);
+    static_assert( std::is_invocable_v<decltype(std::views::filter), Range, Pred>);
+    static_assert(!std::is_invocable_v<decltype(std::views::filter), Range, Pred, Pred>);
+    static_assert(!std::is_invocable_v<decltype(std::views::filter), NonCopyablePredicate>);
+  }
+
+  {
+    static_assert(std::is_same_v<decltype(std::ranges::views::filter), decltype(std::views::filter)>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/base.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/base.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/base.pass.cpp
@@ -0,0 +1,93 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr View base() const& requires copy_constructible<View>;
+// constexpr View base() &&;
+
+#include <ranges>
+
+#include <cassert>
+#include <concepts>
+#include <utility>
+
+struct Range : std::ranges::view_base {
+  constexpr explicit Range(int* b, int* e) : begin_(b), end_(e) { }
+  constexpr Range(Range const& other) : begin_(other.begin_), end_(other.end_), wasCopyInitialized(true) { }
+  constexpr Range(Range&& other) : begin_(other.begin_), end_(other.end_), wasMoveInitialized(true) { }
+  Range& operator=(Range const&) = default;
+  Range& operator=(Range&&) = default;
+  constexpr int* begin() const { return begin_; }
+  constexpr int* end() const { return end_; }
+
+  int* begin_;
+  int* end_;
+  bool wasCopyInitialized = false;
+  bool wasMoveInitialized = false;
+};
+
+struct Pred {
+  bool operator()(int) const;
+};
+
+struct NoCopyRange : std::ranges::view_base {
+  explicit NoCopyRange(int*, int*);
+  NoCopyRange(NoCopyRange const&) = delete;
+  NoCopyRange(NoCopyRange&&) = default;
+  NoCopyRange& operator=(NoCopyRange const&) = default;
+  NoCopyRange& operator=(NoCopyRange&&) = default;
+  int* begin() const;
+  int* end() const;
+};
+
+template <typename T>
+concept can_call_base_on = requires(T t) { std::forward<T>(t).base(); };
+
+constexpr bool test() {
+  int buff[] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  // Check the const& overload
+  {
+    Range range(buff, buff + 8);
+    std::ranges::filter_view<Range, Pred> const view(range, Pred{});
+    std::same_as<Range> decltype(auto) result = view.base();
+    assert(result.wasCopyInitialized);
+    assert(result.begin() == buff);
+    assert(result.end() == buff + 8);
+  }
+
+  // Check the && overload
+  {
+    Range range(buff, buff + 8);
+    std::ranges::filter_view<Range, Pred> view(range, Pred{});
+    std::same_as<Range> decltype(auto) result = std::move(view).base();
+    assert(result.wasMoveInitialized);
+    assert(result.begin() == buff);
+    assert(result.end() == buff + 8);
+  }
+
+  // Ensure the const& overload is not considered when the base is not copy-constructible
+  {
+    static_assert(!can_call_base_on<std::ranges::filter_view<NoCopyRange, Pred> const&>);
+    static_assert(!can_call_base_on<std::ranges::filter_view<NoCopyRange, Pred>&>);
+    static_assert( can_call_base_on<std::ranges::filter_view<NoCopyRange, Pred>&&>);
+    static_assert( can_call_base_on<std::ranges::filter_view<NoCopyRange, Pred>>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/begin.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/begin.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/begin.pass.cpp
@@ -0,0 +1,187 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr iterator begin();
+
+#include <ranges>
+
+#include <cassert>
+#include "test_iterators.h"
+#include "types.h"
+
+struct Range : std::ranges::view_base {
+  using Iterator = forward_iterator<int*>;
+  using Sentinel = sentinel_wrapper<Iterator>;
+  constexpr explicit Range(int* b, int* e) : begin_(b), end_(e) { }
+  constexpr Iterator begin() const { return Iterator(begin_); }
+  constexpr Sentinel end() const { return Sentinel(Iterator(end_)); }
+
+private:
+  int* begin_;
+  int* end_;
+};
+
+// A range that isn't a forward_range, used to test filter_view
+// when we don't cache the result of begin()
+struct InputRange : std::ranges::view_base {
+  using Iterator = cpp17_input_iterator<int*>;
+  using Sentinel = sentinel_wrapper<Iterator>;
+  constexpr explicit InputRange(int* b, int* e) : begin_(b), end_(e) { }
+  constexpr Iterator begin() const { return Iterator(begin_); }
+  constexpr Sentinel end() const { return Sentinel(Iterator(end_)); }
+
+private:
+  int* begin_;
+  int* end_;
+};
+
+struct TrackingPred : TrackInitialization {
+  using TrackInitialization::TrackInitialization;
+  constexpr bool operator()(int i) const { return i % 2 == 0; }
+};
+
+template <typename Range>
+constexpr void general_tests() {
+  int buff[] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  // begin() over an empty range
+  {
+    Range range(buff, buff);
+    auto pred = [](int) { return true; };
+    std::ranges::filter_view view(range, pred);
+    auto it = view.begin();
+    assert(it.base().base() == buff);
+    assert(it == view.end());
+  }
+
+  // begin() over a 1-element range
+  {
+    {
+      Range range(buff, buff + 1);
+      auto pred = [](int i) { return i == 1; };
+      std::ranges::filter_view view(range, pred);
+      auto it = view.begin();
+      assert(it.base().base() == buff);
+    }
+    {
+      Range range(buff, buff + 1);
+      auto pred = [](int) { return false; };
+      std::ranges::filter_view view(range, pred);
+      auto it = view.begin();
+      assert(it.base().base() == buff + 1);
+      assert(it == view.end());
+    }
+  }
+
+  // begin() over a 2-element range
+  {
+    {
+      Range range(buff, buff + 2);
+      auto pred = [](int i) { return i == 1; };
+      std::ranges::filter_view view(range, pred);
+      auto it = view.begin();
+      assert(it.base().base() == buff);
+    }
+    {
+      Range range(buff, buff + 2);
+      auto pred = [](int i) { return i == 2; };
+      std::ranges::filter_view view(range, pred);
+      auto it = view.begin();
+      assert(it.base().base() == buff + 1);
+    }
+    {
+      Range range(buff, buff + 2);
+      auto pred = [](int) { return false; };
+      std::ranges::filter_view view(range, pred);
+      auto it = view.begin();
+      assert(it.base().base() == buff + 2);
+      assert(it == view.end());
+    }
+  }
+
+  // begin() over a N-element range
+  {
+    for (int k = 1; k != 8; ++k) {
+      Range range(buff, buff + 8);
+      auto pred = [=](int i) { return i == k; };
+      std::ranges::filter_view view(range, pred);
+      auto it = view.begin();
+      assert(it.base().base() == buff + (k - 1));
+    }
+    {
+      Range range(buff, buff + 8);
+      auto pred = [](int) { return false; };
+      std::ranges::filter_view view(range, pred);
+      auto it = view.begin();
+      assert(it.base().base() == buff + 8);
+      assert(it == view.end());
+    }
+  }
+
+  // Make sure we do not make a copy of the predicate when we call begin()
+  // (we should be passing it to ranges::find_if using std::ref)
+  {
+    bool moved = false, copied = false;
+    Range range(buff, buff + 2);
+    std::ranges::filter_view view(range, TrackingPred(&moved, &copied));
+    moved = false;
+    copied = false;
+    auto it = view.begin(); (void)it;
+    assert(!moved);
+    assert(!copied);
+  }
+
+  // Test with a non-const predicate
+  {
+    struct MutablePred {
+      constexpr bool operator()(int i) { return i % 2 == 0; }
+    };
+    Range range(buff, buff + 8);
+    MutablePred pred;
+    std::ranges::filter_view view(range, pred);
+    auto it = view.begin();
+    assert(it.base().base() == buff + 1);
+  }
+}
+
+template <typename ForwardRange>
+constexpr void cache_tests() {
+  int buff[] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  // Make sure that we cache the result of begin() on subsequent calls
+  // (only applies to forward_ranges)
+  ForwardRange range(buff, buff + 8);
+  int called = 0;
+  auto pred = [&](int i) { ++called; return i == 3; };
+
+  std::ranges::filter_view view(range, pred);
+  assert(called == 0);
+  for (int k = 0; k != 3; ++k) {
+    auto it = view.begin();
+    assert(it.base().base() == buff + 2);
+    assert(called == 3);
+  }
+}
+
+constexpr bool test() {
+  general_tests<Range>();
+  general_tests<InputRange>(); // test when we don't cache the result
+  cache_tests<Range>();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/constraints.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/constraints.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/constraints.compile.pass.cpp
@@ -0,0 +1,111 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// Check constraints on the type itself.
+//
+// template<input_range View, indirect_unary_predicate<iterator_t<View>> Pred>
+//    requires view<View> && is_object_v<Pred>
+// class filter_view;
+
+#include <ranges>
+
+#include <concepts>
+#include <cstddef>
+#include <iterator>
+#include <type_traits>
+
+template <class View, class Pred>
+concept can_form_filter_view = requires {
+  typename std::ranges::filter_view<View, Pred>;
+};
+
+// filter_view is not valid when the view is not an input_range
+namespace test1 {
+  struct View : std::ranges::view_base {
+    struct NotInputIterator {
+      NotInputIterator& operator++();
+      void operator++(int);
+      int& operator*() const;
+      using difference_type = std::ptrdiff_t;
+      friend bool operator==(NotInputIterator const&, NotInputIterator const&);
+    };
+    NotInputIterator begin() const;
+    NotInputIterator end() const;
+  };
+  struct Pred { bool operator()(int) const; };
+
+  static_assert(!std::ranges::input_range<View>);
+  static_assert( std::indirect_unary_predicate<Pred, int*>);
+  static_assert( std::ranges::view<View>);
+  static_assert( std::is_object_v<Pred>);
+  static_assert(!can_form_filter_view<View, Pred>);
+}
+
+// filter_view is not valid when the predicate is not indirect_unary_predicate
+namespace test2 {
+  struct View : std::ranges::view_base {
+    int* begin() const;
+    int* end() const;
+  };
+  struct Pred { };
+
+  static_assert( std::ranges::input_range<View>);
+  static_assert(!std::indirect_unary_predicate<Pred, int*>);
+  static_assert( std::ranges::view<View>);
+  static_assert( std::is_object_v<Pred>);
+  static_assert(!can_form_filter_view<View, Pred>);
+}
+
+// filter_view is not valid when the view is not a view
+namespace test3 {
+  struct View {
+    int* begin() const;
+    int* end() const;
+  };
+  struct Pred { bool operator()(int) const; };
+
+  static_assert( std::ranges::input_range<View>);
+  static_assert( std::indirect_unary_predicate<Pred, int*>);
+  static_assert(!std::ranges::view<View>);
+  static_assert( std::is_object_v<Pred>);
+  static_assert(!can_form_filter_view<View, Pred>);
+}
+
+// filter_view is not valid when the predicate is not an object type
+namespace test4 {
+  struct View : std::ranges::view_base {
+    int* begin() const;
+    int* end() const;
+  };
+  using Pred = bool(&)(int);
+
+  static_assert( std::ranges::input_range<View>);
+  static_assert( std::indirect_unary_predicate<Pred, int*>);
+  static_assert( std::ranges::view<View>);
+  static_assert(!std::is_object_v<Pred>);
+  static_assert(!can_form_filter_view<View, Pred>);
+}
+
+// filter_view is valid when all the constraints are satisfied (test the test)
+namespace test5 {
+  struct View : std::ranges::view_base {
+    int* begin() const;
+    int* end() const;
+  };
+  struct Pred { bool operator()(int) const; };
+
+  static_assert( std::ranges::input_range<View>);
+  static_assert( std::indirect_unary_predicate<Pred, int*>);
+  static_assert( std::ranges::view<View>);
+  static_assert( std::is_object_v<Pred>);
+  static_assert( can_form_filter_view<View, Pred>);
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/ctad.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/ctad.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/ctad.pass.cpp
@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template <class Range, class Pred>
+// filter_view(Range&&, Pred) -> filter_view<views::all_t<Range>, Pred>;
+
+#include <ranges>
+
+#include <cassert>
+#include <type_traits>
+#include "test_iterators.h"
+
+struct View : std::ranges::view_base {
+  View() = default;
+  forward_iterator<int*> begin() const;
+  sentinel_wrapper<forward_iterator<int*>> end() const;
+};
+
+// A range, but not a view
+struct Range {
+  Range() = default;
+  forward_iterator<int*> begin() const;
+  sentinel_wrapper<forward_iterator<int*>> end() const;
+};
+
+struct Pred {
+  constexpr bool operator()(int i) const { return i % 2 == 0; }
+};
+
+constexpr bool test() {
+  {
+    View v;
+    Pred pred;
+    std::ranges::filter_view view(v, pred);
+    static_assert(std::is_same_v<decltype(view), std::ranges::filter_view<View, Pred>>);
+  }
+
+  // Test with a range that isn't a view, to make sure we properly use views::all_t in the implementation.
+  {
+    Range r;
+    Pred pred;
+    std::ranges::filter_view view(r, pred);
+    static_assert(std::is_same_v<decltype(view), std::ranges::filter_view<std::ranges::ref_view<Range>, Pred>>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/ctor.default.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/ctor.default.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/ctor.default.pass.cpp
@@ -0,0 +1,81 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// filter_view() requires std::default_initializable<View> &&
+//                        std::default_initializable<Pred> = default;
+
+#include <ranges>
+
+#include <cassert>
+#include <type_traits>
+
+constexpr int buff[] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+struct DefaultConstructibleView : std::ranges::view_base {
+  constexpr DefaultConstructibleView() : begin_(buff), end_(buff + 8) { }
+  constexpr int const* begin() const { return begin_; }
+  constexpr int const* end() const { return end_; }
+private:
+  int const* begin_;
+  int const* end_;
+};
+
+struct DefaultConstructiblePredicate {
+  DefaultConstructiblePredicate() = default;
+  constexpr bool operator()(int i) const { return i % 2 == 0; }
+};
+
+struct NoDefaultView : std::ranges::view_base {
+  NoDefaultView() = delete;
+  int* begin() const;
+  int* end() const;
+};
+
+struct NoDefaultPredicate {
+  NoDefaultPredicate() = delete;
+  constexpr bool operator()(int) const;
+};
+
+constexpr bool test() {
+  {
+    std::ranges::filter_view<DefaultConstructibleView, DefaultConstructiblePredicate> view;
+    auto it = view.begin(), end = view.end();
+    assert(*it++ == 2);
+    assert(*it++ == 4);
+    assert(*it++ == 6);
+    assert(*it++ == 8);
+    assert(it == end);
+  }
+
+  {
+    std::ranges::filter_view<DefaultConstructibleView, DefaultConstructiblePredicate> view = {};
+    auto it = view.begin(), end = view.end();
+    assert(*it++ == 2);
+    assert(*it++ == 4);
+    assert(*it++ == 6);
+    assert(*it++ == 8);
+    assert(it == end);
+  }
+
+  static_assert(!std::is_default_constructible_v<std::ranges::filter_view<NoDefaultView,            DefaultConstructiblePredicate>>);
+  static_assert(!std::is_default_constructible_v<std::ranges::filter_view<DefaultConstructibleView, NoDefaultPredicate>>);
+  static_assert(!std::is_default_constructible_v<std::ranges::filter_view<NoDefaultView,            NoDefaultPredicate>>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/ctor.view_pred.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/ctor.view_pred.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/ctor.view_pred.pass.cpp
@@ -0,0 +1,102 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr filter_view(View, Pred);
+
+#include <ranges>
+
+#include <cassert>
+#include "types.h"
+
+struct Range : std::ranges::view_base {
+  constexpr explicit Range(int* b, int* e) : begin_(b), end_(e) { }
+  constexpr int* begin() const { return begin_; }
+  constexpr int* end() const { return end_; }
+
+private:
+  int* begin_;
+  int* end_;
+};
+
+struct Pred {
+  constexpr bool operator()(int i) const { return i % 2 != 0; }
+};
+
+struct TrackingPred : TrackInitialization {
+  using TrackInitialization::TrackInitialization;
+  constexpr bool operator()(int) const;
+};
+
+struct TrackingRange : TrackInitialization, std::ranges::view_base {
+  using TrackInitialization::TrackInitialization;
+  int* begin() const;
+  int* end() const;
+};
+
+constexpr bool test() {
+  int buff[] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  // Test explicit syntax
+  {
+    Range range(buff, buff + 8);
+    Pred pred;
+    std::ranges::filter_view<Range, Pred> view(range, pred);
+    auto it = view.begin(), end = view.end();
+    assert(*it++ == 1);
+    assert(*it++ == 3);
+    assert(*it++ == 5);
+    assert(*it++ == 7);
+    assert(it == end);
+  }
+
+  // Test implicit syntax
+  {
+    Range range(buff, buff + 8);
+    Pred pred;
+    std::ranges::filter_view<Range, Pred> view = {range, pred};
+    auto it = view.begin(), end = view.end();
+    assert(*it++ == 1);
+    assert(*it++ == 3);
+    assert(*it++ == 5);
+    assert(*it++ == 7);
+    assert(it == end);
+  }
+
+  // Make sure we move the view
+  {
+    bool moved = false, copied = false;
+    TrackingRange range(&moved, &copied);
+    Pred pred;
+    std::ranges::filter_view<TrackingRange, Pred> view(std::move(range), pred); (void)view;
+    assert(moved);
+    assert(!copied);
+  }
+
+  // Make sure we move the predicate
+  {
+    bool moved = false, copied = false;
+    Range range(buff, buff + 8);
+    TrackingPred pred(&moved, &copied);
+    std::ranges::filter_view<Range, TrackingPred> view(range, std::move(pred)); (void)view;
+    assert(moved);
+    assert(!copied);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/end.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/end.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/end.pass.cpp
@@ -0,0 +1,107 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr auto end();
+
+#include <ranges>
+
+#include <cassert>
+#include <type_traits>
+#include "test_iterators.h"
+
+struct Range : std::ranges::view_base {
+  using Iterator = forward_iterator<int*>;
+  using Sentinel = sentinel_wrapper<Iterator>;
+  constexpr explicit Range(int* b, int* e) : begin_(b), end_(e) { }
+  constexpr Iterator begin() const { return Iterator(begin_); }
+  constexpr Sentinel end() const { return Sentinel(Iterator(end_)); }
+
+private:
+  int* begin_;
+  int* end_;
+};
+
+struct CommonRange : std::ranges::view_base {
+  using Iterator = forward_iterator<int*>;
+  constexpr explicit CommonRange(int* b, int* e) : begin_(b), end_(e) { }
+  constexpr Iterator begin() const { return Iterator(begin_); }
+  constexpr Iterator end() const { return Iterator(end_); }
+
+private:
+  int* begin_;
+  int* end_;
+};
+
+constexpr bool test() {
+  int buff[] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  // end() on an empty range
+  {
+    Range range(buff, buff);
+    auto pred = [](int) { return true; };
+    std::ranges::filter_view view(range, pred);
+    auto end = view.end();
+    assert(base(base(end.base())) == buff);
+    static_assert(!std::is_same_v<decltype(end), decltype(view.begin())>);
+  }
+
+  // end() on a 1-element range
+  {
+    Range range(buff, buff + 1);
+    auto pred = [](int) { return true; };
+    std::ranges::filter_view view(range, pred);
+    auto end = view.end();
+    assert(base(base(end.base())) == buff + 1);
+    static_assert(!std::is_same_v<decltype(end), decltype(view.begin())>);
+  }
+
+  // end() on a 2-element range
+  {
+    Range range(buff, buff + 2);
+    auto pred = [](int) { return true; };
+    std::ranges::filter_view view(range, pred);
+    auto end = view.end();
+    assert(base(base(end.base())) == buff + 2);
+    static_assert(!std::is_same_v<decltype(end), decltype(view.begin())>);
+  }
+
+  // end() on a N-element range
+  {
+    for (int k = 1; k != 8; ++k) {
+      Range range(buff, buff + 8);
+      auto pred = [=](int i) { return i == k; };
+      std::ranges::filter_view view(range, pred);
+      auto end = view.end();
+      assert(base(base(end.base())) == buff + 8);
+      static_assert(!std::is_same_v<decltype(end), decltype(view.begin())>);
+    }
+  }
+
+  // end() on a common_range
+  {
+    CommonRange range(buff, buff + 8);
+    auto pred = [](int i) { return i % 2 == 0; };
+    std::ranges::filter_view view(range, pred);
+    auto end = view.end();
+    assert(end.base().base() == buff + 8);
+    static_assert(std::is_same_v<decltype(end), decltype(view.begin())>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/arrow.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/arrow.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/arrow.pass.cpp
@@ -0,0 +1,120 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr iterator_t<V> operator->() const
+//    requires has-arrow<iterator_t<V>> && copyable<iterator_t<V>>
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <cstddef>
+#include <utility>
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "../types.h"
+
+struct Point {
+  int x;
+  int y;
+};
+
+template <class T>
+concept has_arrow = requires (T t) {
+  { t->x };
+};
+
+struct WithoutArrowOperator : std::ranges::view_base {
+  struct iterator : contiguous_iterator<Point*> {
+    Point* operator->() const = delete;
+    iterator& operator++();
+    iterator operator++(int);
+  };
+
+  iterator begin() const;
+  sentinel_wrapper<iterator> end() const;
+};
+
+struct WithNonCopyableIterator : std::ranges::view_base {
+  struct iterator : contiguous_iterator<Point*> {
+    iterator(iterator&&) = default;
+    iterator& operator=(iterator&&) = default;
+
+    iterator(iterator const&) = delete;
+    iterator& operator=(iterator const&) = delete;
+
+    Point* operator->() const;
+    iterator& operator++();
+    iterator operator++(int);
+
+    friend Point* base(iterator const&);
+  };
+
+  iterator begin() const;
+  sentinel_wrapper<iterator> end() const;
+};
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  std::array<Point, 5> array{{{0, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}}};
+  using View = minimal_view<Iterator, Sentinel>;
+  using FilterView = std::ranges::filter_view<View, AlwaysTrue>;
+  using FilterIterator = std::ranges::iterator_t<FilterView>;
+
+  auto make_filter_view = [](auto begin, auto end, auto pred) {
+    View view{Iterator(begin), Sentinel(Iterator(end))};
+    return FilterView(std::move(view), pred);
+  };
+
+  for (std::ptrdiff_t n = 0; n != 5; ++n) {
+    FilterView view = make_filter_view(array.begin(), array.end(), AlwaysTrue{});
+    FilterIterator const iter(view, Iterator(array.begin() + n));
+    std::same_as<Iterator> auto result = iter.operator->();
+    assert(base(result) == array.begin() + n);
+    assert(iter->x == n);
+    assert(iter->y == n);
+  }
+}
+
+constexpr bool tests() {
+  // TODO: None of these archetypes should actually provide operator-> by default.
+  test<cpp17_input_iterator<Point*>>();
+  // cpp20_input_iterator is not copyable, so it doesn't get operator->
+  test<forward_iterator<Point*>>();
+  test<bidirectional_iterator<Point*>>();
+  test<random_access_iterator<Point*>>();
+  test<contiguous_iterator<Point*>>();
+
+  // Make sure filter_view::iterator doesn't have operator-> if the
+  // underlying iterator doesn't have one.
+  {
+    using FilterView = std::ranges::filter_view<WithoutArrowOperator, AlwaysTrue>;
+    using FilterIterator = std::ranges::iterator_t<FilterView>;
+    static_assert(!has_arrow<FilterIterator>);
+  }
+
+  // Make sure filter_view::iterator doesn't have operator-> if the
+  // underlying iterator is not copyable.
+  {
+    using FilterView = std::ranges::filter_view<WithNonCopyableIterator, AlwaysTrue>;
+    using FilterIterator = std::ranges::iterator_t<FilterView>;
+    static_assert(!has_arrow<FilterIterator>);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/base.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/base.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/base.pass.cpp
@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr iterator_t<V> const& base() const& noexcept;
+// constexpr iterator_t<V> base() &&;
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <utility>
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "../types.h"
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View = minimal_view<Iterator, Sentinel>;
+  using FilterView = std::ranges::filter_view<View, AlwaysTrue>;
+  using FilterIterator = std::ranges::iterator_t<FilterView>;
+
+  auto make_filter_view = [](auto begin, auto end, auto pred) {
+    View view{Iterator(begin), Sentinel(Iterator(end))};
+    return FilterView(std::move(view), pred);
+  };
+
+  std::array<int, 5> array{0, 1, 2, 3, 4};
+  FilterView view = make_filter_view(array.begin(), array.end(), AlwaysTrue{});
+
+  // Test the const& version
+  {
+    FilterIterator const iter(view, Iterator(array.begin()));
+    std::same_as<Iterator const&> auto& result = iter.base();
+    ASSERT_NOEXCEPT(iter.base());
+    assert(base(result) == array.begin());
+  }
+
+  // Test the && version
+  {
+    FilterIterator iter(view, Iterator(array.begin()));
+    std::same_as<Iterator> auto result = std::move(iter).base();
+    assert(base(result) == array.begin());
+  }
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int*>>();
+  test<cpp20_input_iterator<int*>>();
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/compare.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/compare.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/compare.pass.cpp
@@ -0,0 +1,83 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// friend constexpr bool operator==(iterator const&, iterator const&)
+//  requires equality_comparable<iterator_t<V>>
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <utility>
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "../types.h"
+
+template <class T>
+concept has_equal = requires (T const& x, T const& y) { { x == y }; };
+
+template <class Iterator>
+using FilterIteratorFor = std::ranges::iterator_t<
+  std::ranges::filter_view<minimal_view<Iterator, sentinel_wrapper<Iterator>>, AlwaysTrue>
+>;
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View = minimal_view<Iterator, Sentinel>;
+  using FilterView = std::ranges::filter_view<View, AlwaysTrue>;
+  using FilterIterator = std::ranges::iterator_t<FilterView>;
+
+  auto make_filter_view = [](auto begin, auto end, auto pred) {
+    View view{Iterator(begin), Sentinel(Iterator(end))};
+    return FilterView(std::move(view), pred);
+  };
+
+  {
+    std::array<int, 5> array{0, 1, 2, 3, 4};
+    FilterView view = make_filter_view(array.begin(), array.end(), AlwaysTrue{});
+    FilterIterator it1 = view.begin();
+    FilterIterator it2 = view.begin();
+    std::same_as<bool> auto result = (it1 == it2);
+    assert(result);
+
+    ++it1;
+    assert(!(it1 == it2));
+  }
+
+  {
+    std::array<int, 5> array{0, 1, 2, 3, 4};
+    FilterView view = make_filter_view(array.begin(), array.end(), AlwaysTrue{});
+    assert(!(view.begin() == view.end()));
+  }
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int const*>>();
+  test<forward_iterator<int const*>>();
+  test<bidirectional_iterator<int const*>>();
+  test<random_access_iterator<int const*>>();
+  test<contiguous_iterator<int const*>>();
+
+  // Make sure `operator==` isn't provided for non comparable iterators
+  {
+    static_assert(!has_equal<FilterIteratorFor<cpp20_input_iterator<int*>>>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/ctor.default.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/ctor.default.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/ctor.default.pass.cpp
@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::filter_view<V>::<iterator>() requires default_initializable<iterator_t<V>> = default;
+
+#include <ranges>
+
+#include <cassert>
+#include <type_traits>
+#include "test_iterators.h"
+#include "../types.h"
+
+template <class Iterator>
+constexpr void test_default_constructible() {
+  // Make sure the iterator is default constructible when the underlying iterator is.
+  using View = minimal_view<Iterator, sentinel_wrapper<Iterator>>;
+  using FilterView = std::ranges::filter_view<View, AlwaysTrue>;
+  using FilterIterator = std::ranges::iterator_t<FilterView>;
+  FilterIterator iter1{};
+  FilterIterator iter2;
+  assert(iter1 == iter2);
+}
+
+template <class Iterator>
+constexpr void test_not_default_constructible() {
+  // Make sure the iterator is *not* default constructible when the underlying iterator isn't.
+  using View = minimal_view<Iterator, sentinel_wrapper<Iterator>>;
+  using FilterView = std::ranges::filter_view<View, AlwaysTrue>;
+  using FilterIterator = std::ranges::iterator_t<FilterView>;
+  static_assert(!std::is_default_constructible_v<FilterIterator>);
+}
+
+constexpr bool tests() {
+  test_not_default_constructible<cpp17_input_iterator<int*>>();
+  test_not_default_constructible<cpp20_input_iterator<int*>>();
+  test_default_constructible<forward_iterator<int*>>();
+  test_default_constructible<bidirectional_iterator<int*>>();
+  test_default_constructible<random_access_iterator<int*>>();
+  test_default_constructible<contiguous_iterator<int*>>();
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/ctor.parent_iter.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/ctor.parent_iter.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/ctor.parent_iter.pass.cpp
@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr std::ranges::filter_view::<iterator>(filter_view&, iterator_t<V>);
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include "test_iterators.h"
+#include "../types.h"
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View = minimal_view<Iterator, Sentinel>;
+  using FilterView = std::ranges::filter_view<View, AlwaysTrue>;
+  using FilterIterator = std::ranges::iterator_t<FilterView>;
+
+  std::array<int, 10> array{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  View view(Iterator(array.begin()), Sentinel(Iterator(array.end())));
+  Iterator iter = view.begin();
+
+  FilterView filter_view(std::move(view), AlwaysTrue{});
+  FilterIterator filter_iter(filter_view, std::move(iter));
+  assert(base(filter_iter.base()) == array.begin());
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int*>>();
+  test<cpp20_input_iterator<int*>>();
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/decrement.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/decrement.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/decrement.pass.cpp
@@ -0,0 +1,136 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr iterator& operator--() requires bidirectional_range<V>;
+// constexpr iterator operator--(int) requires bidirectional_range<V>;
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <iterator>
+#include <utility>
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "../types.h"
+
+struct EqualTo {
+  int x;
+  constexpr bool operator()(int y) const { return x == y; }
+};
+
+template <class T>
+concept has_pre_decrement = requires (T t) { { --t }; };
+
+template <class T>
+concept has_post_decrement = requires (T t) { { t-- }; };
+
+template <class Iterator>
+using FilterIteratorFor = std::ranges::iterator_t<
+  std::ranges::filter_view<minimal_view<Iterator, sentinel_wrapper<Iterator>>, EqualTo>
+>;
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View = minimal_view<Iterator, Sentinel>;
+  using FilterView = std::ranges::filter_view<View, EqualTo>;
+  using FilterIterator = std::ranges::iterator_t<FilterView>;
+
+  auto make_filter_view = [](auto begin, auto end, auto pred) {
+    View view{Iterator(begin), Sentinel(Iterator(end))};
+    return FilterView(std::move(view), pred);
+  };
+
+  // Test with a single satisfied value
+  {
+    std::array<int, 5> array{0, 1, 2, 3, 4};
+    FilterView view = make_filter_view(array.begin(), array.end(), EqualTo{1});
+    FilterIterator it = std::ranges::next(view.begin(), view.end());
+    assert(base(it.base()) == array.end()); // test the test
+
+    std::same_as<FilterIterator&> auto& result = --it;
+    assert(&result == &it);
+    assert(base(result.base()) == array.begin() + 1);
+  }
+
+  // Test with more than one satisfied value
+  {
+    std::array<int, 6> array{0, 1, 2, 3, 1, 4};
+    FilterView view = make_filter_view(array.begin(), array.end(), EqualTo{1});
+    FilterIterator it = std::ranges::next(view.begin(), view.end());
+    assert(base(it.base()) == array.end()); // test the test
+
+    std::same_as<FilterIterator&> auto& result = --it;
+    assert(&result == &it);
+    assert(base(result.base()) == array.begin() + 4);
+
+    --it;
+    assert(base(it.base()) == array.begin() + 1);
+  }
+
+  // Test going forward and then backward on the same iterator
+  {
+    std::array<int, 10> array{0, 1, 2, 3, 1, 1, 4, 5, 1, 6};
+    FilterView view = make_filter_view(array.begin(), array.end(), EqualTo{1});
+    FilterIterator it = view.begin();
+    ++it;
+    --it; assert(base(it.base()) == array.begin() + 1);
+    ++it; ++it;
+    --it; assert(base(it.base()) == array.begin() + 4);
+    ++it; ++it;
+    --it; assert(base(it.base()) == array.begin() + 5);
+    ++it; ++it;
+    --it; assert(base(it.base()) == array.begin() + 8);
+  }
+
+  // Test post-decrement
+  {
+    std::array<int, 6> array{0, 1, 2, 3, 1, 4};
+    FilterView view = make_filter_view(array.begin(), array.end(), EqualTo{1});
+    FilterIterator it = std::ranges::next(view.begin(), view.end());
+    assert(base(it.base()) == array.end()); // test the test
+
+    std::same_as<FilterIterator> auto result = it--;
+    assert(base(result.base()) == array.end());
+    assert(base(it.base()) == array.begin() + 4);
+
+    result = it--;
+    assert(base(result.base()) == array.begin() + 4);
+    assert(base(it.base()) == array.begin() + 1);
+  }
+}
+
+constexpr bool tests() {
+  test<bidirectional_iterator<int const*>>();
+  test<random_access_iterator<int const*>>();
+  test<contiguous_iterator<int const*>>();
+
+  // Make sure `operator--` isn't provided for non bidirectional ranges
+  {
+    static_assert(!has_pre_decrement<FilterIteratorFor<cpp17_input_iterator<int*>>>);
+    static_assert(!has_pre_decrement<FilterIteratorFor<cpp20_input_iterator<int*>>>);
+    static_assert(!has_pre_decrement<FilterIteratorFor<forward_iterator<int*>>>);
+
+    static_assert(!has_post_decrement<FilterIteratorFor<cpp17_input_iterator<int*>>>);
+    static_assert(!has_post_decrement<FilterIteratorFor<cpp20_input_iterator<int*>>>);
+    static_assert(!has_post_decrement<FilterIteratorFor<forward_iterator<int*>>>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/deref.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/deref.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/deref.pass.cpp
@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr range_reference_t<V> operator*() const;
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <cstddef>
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "../types.h"
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View = minimal_view<Iterator, Sentinel>;
+  using FilterView = std::ranges::filter_view<View, AlwaysTrue>;
+  using FilterIterator = std::ranges::iterator_t<FilterView>;
+
+  auto make_filter_view = [](auto begin, auto end, auto pred) {
+    View view{Iterator(begin), Sentinel(Iterator(end))};
+    return FilterView(std::move(view), pred);
+  };
+
+  std::array<int, 10> array{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  FilterView view = make_filter_view(array.begin(), array.end(), AlwaysTrue{});
+
+  for (std::ptrdiff_t n = 0; n != 9; ++n) {
+    FilterIterator const iter(view, Iterator(array.begin() + n));
+    std::same_as<int&> auto& result = *iter;
+    assert(&result == array.begin() + n);
+  }
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int*>>();
+  test<cpp20_input_iterator<int*>>();
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/increment.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/increment.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/increment.pass.cpp
@@ -0,0 +1,140 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr iterator& operator++();
+// constexpr void operator++(int);
+// constexpr iterator operator++(int) requires forward_range<V>;
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <type_traits>
+#include <utility>
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "../types.h"
+
+struct EqualTo {
+  int x;
+  constexpr bool operator()(int y) const { return x == y; }
+};
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View = minimal_view<Iterator, Sentinel>;
+  using FilterView = std::ranges::filter_view<View, EqualTo>;
+  using FilterIterator = std::ranges::iterator_t<FilterView>;
+
+  auto make_filter_view = [](auto begin, auto end, auto pred) {
+    View view{Iterator(begin), Sentinel(Iterator(end))};
+    return FilterView(std::move(view), pred);
+  };
+
+  // Increment an iterator when it won't find another satisfied value after begin()
+  {
+    std::array<int, 5> array{0, 1, 2, 3, 4};
+    FilterView view = make_filter_view(array.begin(), array.end(), EqualTo{1});
+
+    FilterIterator it = view.begin();
+    std::same_as<FilterIterator&> auto& result = ++it;
+    assert(&result == &it);
+    assert(base(result.base()) == array.end());
+  }
+
+  // Increment the iterator and it finds another value after begin()
+  {
+    std::array<int, 5> array{99, 1, 99, 1, 99};
+    FilterView view = make_filter_view(array.begin(), array.end(), EqualTo{1});
+
+    FilterIterator it = view.begin();
+    ++it;
+    assert(base(it.base()) == array.begin() + 3);
+  }
+
+  // Increment advances all the way to the end of the range
+  {
+    std::array<int, 5> array{99, 1, 99, 99, 1};
+    FilterView view = make_filter_view(array.begin(), array.end(), EqualTo{1});
+
+    FilterIterator it = view.begin();
+    ++it;
+    assert(base(it.base()) == array.begin() + 4);
+  }
+
+  // Increment an iterator multiple times
+  {
+    std::array<int, 10> array{0, 1, 2, 3, 1, 1, 4, 5, 1, 6};
+    FilterView view = make_filter_view(array.begin(), array.end(), EqualTo{1});
+
+    FilterIterator it = view.begin();
+          assert(base(it.base()) == array.begin() + 1);
+    ++it; assert(base(it.base()) == array.begin() + 4);
+    ++it; assert(base(it.base()) == array.begin() + 5);
+    ++it; assert(base(it.base()) == array.begin() + 8);
+    ++it; assert(base(it.base()) == array.end());
+  }
+
+  // Check post-increment for input ranges
+  if constexpr (!std::ranges::forward_range<View>) {
+    std::array<int, 10> array{0, 1, 2, 3, 1, 1, 4, 5, 1, 6};
+    FilterView view = make_filter_view(array.begin(), array.end(), EqualTo{1});
+
+    FilterIterator it = view.begin();
+          assert(base(it.base()) == array.begin() + 1);
+    it++; assert(base(it.base()) == array.begin() + 4);
+    it++; assert(base(it.base()) == array.begin() + 5);
+    it++; assert(base(it.base()) == array.begin() + 8);
+    it++; assert(base(it.base()) == array.end());
+    static_assert(std::is_same_v<decltype(it++), void>);
+  }
+
+  // Check post-increment for forward ranges
+  if constexpr (std::ranges::forward_range<View>) {
+    std::array<int, 10> array{0, 1, 2, 3, 1, 1, 4, 5, 1, 6};
+    FilterView view = make_filter_view(array.begin(), array.end(), EqualTo{1});
+
+    FilterIterator it = view.begin();
+    std::same_as<FilterIterator> auto result = it++;
+    assert(base(result.base()) == array.begin() + 1);
+    assert(base(it.base()) == array.begin() + 4);
+
+    result = it++;
+    assert(base(result.base()) == array.begin() + 4);
+    assert(base(it.base()) == array.begin() + 5);
+
+    result = it++;
+    assert(base(result.base()) == array.begin() + 5);
+    assert(base(it.base()) == array.begin() + 8);
+
+    result = it++;
+    assert(base(result.base()) == array.begin() + 8);
+    assert(base(it.base()) == array.end());
+  }
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int const*>>();
+  test<cpp20_input_iterator<int const*>>();
+  test<forward_iterator<int const*>>();
+  test<bidirectional_iterator<int const*>>();
+  test<random_access_iterator<int const*>>();
+  test<contiguous_iterator<int const*>>();
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  // static_assert(tests());
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/iter_move.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/iter_move.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/iter_move.pass.cpp
@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// friend constexpr range_rvalue_reference_t<V> iter_move(iterator const& i)
+//  noexcept(noexcept(ranges::iter_move(i.current_)));
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <utility>
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "../types.h"
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View = minimal_view<Iterator, Sentinel>;
+  using FilterView = std::ranges::filter_view<View, AlwaysTrue>;
+  using FilterIterator = std::ranges::iterator_t<FilterView>;
+
+  auto make_filter_view = [](auto begin, auto end, auto pred) {
+    View view{Iterator(begin), Sentinel(Iterator(end))};
+    return FilterView(std::move(view), pred);
+  };
+
+  {
+    std::array<int, 5> array{0, 1, 2, 3, 4};
+    FilterView view = make_filter_view(array.begin(), array.end(), AlwaysTrue{});
+    FilterIterator const it = view.begin();
+
+    int&& result = iter_move(it);
+    assert(&result == array.begin());
+  }
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int*>>();
+  test<cpp20_input_iterator<int*>>();
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/iter_swap.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/iter_swap.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/iter_swap.pass.cpp
@@ -0,0 +1,71 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// friend constexpr void iter_swap(iterator const& x, iterator const& y)
+//  noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
+//  requires(indirectly_swappable<iterator_t<V>>);
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <iterator>
+#include <utility>
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "../types.h"
+
+struct IsEven {
+  constexpr bool operator()(int x) const { return x % 2 == 0; }
+};
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View = minimal_view<Iterator, Sentinel>;
+  using FilterView = std::ranges::filter_view<View, IsEven>;
+  using FilterIterator = std::ranges::iterator_t<FilterView>;
+
+  auto make_filter_view = [](auto begin, auto end, auto pred) {
+    View view{Iterator(begin), Sentinel(Iterator(end))};
+    return FilterView(std::move(view), pred);
+  };
+
+  {
+    std::array<int, 5> array{1, 2, 1, 4, 1};
+    FilterView view = make_filter_view(array.begin(), array.end(), IsEven{});
+    FilterIterator const it1 = view.begin();
+    FilterIterator const it2 = std::ranges::next(view.begin());
+
+    static_assert(std::is_same_v<decltype(iter_swap(it1, it2)), void>);
+    ASSERT_NOT_NOEXCEPT(iter_swap(it1, it2));
+
+    assert(*it1 == 2 && *it2 == 4); // test the test
+    iter_swap(it1, it2);
+    assert(*it1 == 4 && *it2 == 2);
+  }
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int*>>();
+  test<cpp20_input_iterator<int*>>();
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/types.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/types.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/types.compile.pass.cpp
@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::filter_view::<iterator>::difference_type
+// std::filter_view::<iterator>::value_type
+// std::filter_view::<iterator>::iterator_category
+// std::filter_view::<iterator>::iterator_concept
+
+#include <ranges>
+
+#include <type_traits>
+#include "test_iterators.h"
+#include "../types.h"
+
+template <typename T>
+concept HasIteratorCategory = requires {
+  typename T::iterator_category;
+};
+
+template <template <class ...> class Iterator>
+using FilterViewFor = std::ranges::filter_view<
+  minimal_view<Iterator<int*>, sentinel_wrapper<Iterator<int*>>>,
+  AlwaysTrue
+>;
+
+template <template <class ...> class Iterator>
+using FilterIteratorFor = std::ranges::iterator_t<FilterViewFor<Iterator>>;
+
+void f() {
+  // Check that value_type is range_value_t and difference_type is range_difference_t
+  {
+    auto test = []<template <class ...> class Iterator> {
+      using FilterView = FilterViewFor<Iterator>;
+      using FilterIterator = FilterIteratorFor<Iterator>;
+      static_assert(std::is_same_v<typename FilterIterator::value_type, std::ranges::range_value_t<FilterView>>);
+      static_assert(std::is_same_v<typename FilterIterator::difference_type, std::ranges::range_difference_t<FilterView>>);
+    };
+    test.operator()<cpp17_input_iterator>();
+    test.operator()<cpp20_input_iterator>();
+    test.operator()<forward_iterator>();
+    test.operator()<bidirectional_iterator>();
+    test.operator()<random_access_iterator>();
+    test.operator()<contiguous_iterator>();
+  }
+
+  // Check iterator_concept for various categories of ranges
+  {
+    static_assert(std::is_same_v<FilterIteratorFor<cpp17_input_iterator>::iterator_concept, std::input_iterator_tag>);
+    static_assert(std::is_same_v<FilterIteratorFor<cpp20_input_iterator>::iterator_concept, std::input_iterator_tag>);
+    static_assert(std::is_same_v<FilterIteratorFor<forward_iterator>::iterator_concept, std::forward_iterator_tag>);
+    static_assert(std::is_same_v<FilterIteratorFor<bidirectional_iterator>::iterator_concept, std::bidirectional_iterator_tag>);
+    static_assert(std::is_same_v<FilterIteratorFor<random_access_iterator>::iterator_concept, std::bidirectional_iterator_tag>);
+    static_assert(std::is_same_v<FilterIteratorFor<contiguous_iterator>::iterator_concept, std::bidirectional_iterator_tag>);
+  }
+
+  // Check iterator_category for various categories of ranges
+  {
+    static_assert(!HasIteratorCategory<FilterIteratorFor<cpp17_input_iterator>>);
+    static_assert(!HasIteratorCategory<FilterIteratorFor<cpp20_input_iterator>>);
+    static_assert(std::is_same_v<FilterIteratorFor<forward_iterator>::iterator_category, std::forward_iterator_tag>);
+    static_assert(std::is_same_v<FilterIteratorFor<bidirectional_iterator>::iterator_category, std::bidirectional_iterator_tag>);
+    static_assert(std::is_same_v<FilterIteratorFor<random_access_iterator>::iterator_category, std::bidirectional_iterator_tag>);
+    static_assert(std::is_same_v<FilterIteratorFor<contiguous_iterator>::iterator_category, std::bidirectional_iterator_tag>);
+  }
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/pred.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/pred.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/pred.pass.cpp
@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// Older Clangs don't properly deduce decltype(auto) with a concept constraint
+// XFAIL: clang-11, clang-12
+// XFAIL: apple-clang-12, apple-clang-13.0
+
+// constexpr Pred const& pred() const;
+
+#include <ranges>
+
+#include <cassert>
+#include <concepts>
+
+struct Range : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+
+struct Pred {
+  bool operator()(int) const;
+  int value;
+};
+
+constexpr bool test() {
+  {
+    Pred pred{42};
+    std::ranges::filter_view<Range, Pred> const view(Range{}, pred);
+    std::same_as<Pred const&> decltype(auto) result = view.pred();
+    assert(result.value == 42);
+
+    // Make sure we're really holding a reference to something inside the view
+    std::same_as<Pred const&> decltype(auto) result2 = view.pred();
+    assert(&result == &result2);
+  }
+
+  // Same, but calling on a non-const view
+  {
+    Pred pred{42};
+    std::ranges::filter_view<Range, Pred> view(Range{}, pred);
+    std::same_as<Pred const&> decltype(auto) result = view.pred();
+    assert(result.value == 42);
+
+    // Make sure we're really holding a reference to something inside the view
+    std::same_as<Pred const&> decltype(auto) result2 = view.pred();
+    assert(&result == &result2);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/sentinel/base.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/sentinel/base.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/sentinel/base.pass.cpp
@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr sentinel_t<V> base() const;
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include "test_iterators.h"
+#include "../types.h"
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View = minimal_view<Iterator, Sentinel>;
+  using FilterView = std::ranges::filter_view<View, AlwaysTrue>;
+  using FilterSentinel = std::ranges::sentinel_t<FilterView>;
+
+  auto make_filter_view = [](auto begin, auto end, auto pred) {
+    View view{Iterator(begin), Sentinel(Iterator(end))};
+    return FilterView(std::move(view), pred);
+  };
+
+  std::array<int, 5> array{0, 1, 2, 3, 4};
+  FilterView view = make_filter_view(array.begin(), array.end(), AlwaysTrue{});
+
+  FilterSentinel const sent = view.end();
+  std::same_as<Sentinel> auto result = sent.base();
+  assert(base(base(result)) == array.end());
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int*>>();
+  test<cpp20_input_iterator<int*>>();
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/sentinel/compare.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/sentinel/compare.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/sentinel/compare.pass.cpp
@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// friend constexpr bool operator==(iterator const&, sentinel const&);
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include "test_iterators.h"
+#include "../types.h"
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View = minimal_view<Iterator, Sentinel>;
+  using FilterView = std::ranges::filter_view<View, AlwaysTrue>;
+  using FilterIterator = std::ranges::iterator_t<FilterView>;
+  using FilterSentinel = std::ranges::sentinel_t<FilterView>;
+
+  auto make_filter_view = [](auto begin, auto end, auto pred) {
+    View view{Iterator(begin), Sentinel(Iterator(end))};
+    return FilterView(std::move(view), pred);
+  };
+
+  std::array<int, 5> array{0, 1, 2, 3, 4};
+  FilterView view = make_filter_view(array.begin(), array.end(), AlwaysTrue{});
+
+  FilterIterator const it = view.begin();
+  FilterSentinel const sent = view.end();
+  std::same_as<bool> auto result = (it == sent);
+  assert(!result);
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int*>>();
+  test<cpp20_input_iterator<int*>>();
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/sentinel/ctor.default.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/sentinel/ctor.default.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/sentinel/ctor.default.pass.cpp
@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// filter_view<V>::<sentinel>() = default;
+
+#include <ranges>
+
+#include <cassert>
+#include "test_iterators.h"
+#include "../types.h"
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View = minimal_view<Iterator, Sentinel>;
+  using FilterView = std::ranges::filter_view<View, AlwaysTrue>;
+  using FilterSentinel = std::ranges::sentinel_t<FilterView>;
+  FilterSentinel sent1{};
+  FilterSentinel sent2;
+  assert(base(base(sent1.base())) == base(base(sent2.base())));
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int*>>();
+  test<cpp20_input_iterator<int*>>();
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/sentinel/ctor.parent.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/sentinel/ctor.parent.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/sentinel/ctor.parent.pass.cpp
@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr explicit sentinel(filter_view&);
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <type_traits>
+#include "test_iterators.h"
+#include "../types.h"
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View = minimal_view<Iterator, Sentinel>;
+  using FilterView = std::ranges::filter_view<View, AlwaysTrue>;
+  using FilterSentinel = std::ranges::sentinel_t<FilterView>;
+
+  auto make_filter_view = [](auto begin, auto end, auto pred) {
+    View view{Iterator(begin), Sentinel(Iterator(end))};
+    return FilterView(std::move(view), pred);
+  };
+
+  std::array<int, 5> array{0, 1, 2, 3, 4};
+  FilterView view = make_filter_view(array.begin(), array.end(), AlwaysTrue{});
+
+  FilterSentinel sent(view);
+  assert(base(base(sent.base())) == base(base(view.end().base())));
+
+  static_assert(!std::is_convertible_v<FilterView, FilterSentinel>);
+  static_assert(!std::is_constructible_v<FilterSentinel, FilterView const&>);
+  static_assert(!std::is_constructible_v<FilterSentinel, FilterView>);
+  static_assert( std::is_constructible_v<FilterSentinel, FilterView&>);
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int*>>();
+  test<cpp20_input_iterator<int*>>();
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/types.h b/libcxx/test/std/ranges/range.adaptors/range.filter/types.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/types.h
@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_FILTER_TYPES_H
+#define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_FILTER_TYPES_H
+
+#include <ranges>
+#include <utility>
+
+struct TrackInitialization {
+  constexpr explicit TrackInitialization(bool* moved, bool* copied) : moved_(moved), copied_(copied) { }
+  constexpr TrackInitialization(TrackInitialization const& other) : moved_(other.moved_), copied_(other.copied_) {
+    *copied_ = true;
+  }
+  constexpr TrackInitialization(TrackInitialization&& other) : moved_(other.moved_), copied_(other.copied_) {
+    *moved_ = true;
+  }
+  TrackInitialization& operator=(TrackInitialization const&) = default;
+  TrackInitialization& operator=(TrackInitialization&&) = default;
+  bool* moved_;
+  bool* copied_;
+};
+
+struct AlwaysTrue {
+  template <typename T>
+  constexpr bool operator()(T const&) const { return true; }
+};
+
+template <class Iterator, class Sentinel>
+struct minimal_view : std::ranges::view_base {
+  constexpr explicit minimal_view(Iterator it, Sentinel sent)
+    : it_(base(std::move(it)))
+    , sent_(base(std::move(sent)))
+  { }
+
+  minimal_view(minimal_view&&) = default;
+  minimal_view& operator=(minimal_view&&) = default;
+
+  constexpr Iterator begin() const { return Iterator(it_); }
+  constexpr Sentinel end() const { return Sentinel(sent_); }
+
+private:
+  decltype(base(std::declval<Iterator>())) it_;
+  decltype(base(std::declval<Sentinel>())) sent_;
+};
+
+#endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_FILTER_TYPES_H