diff --git a/wpiutil/src/main/native/include/wpi/ArrayRef.h b/wpiutil/src/main/native/include/wpi/ArrayRef.h
index c94312ebfd..3aa8e4179e 100644
--- a/wpiutil/src/main/native/include/wpi/ArrayRef.h
+++ b/wpiutil/src/main/native/include/wpi/ArrayRef.h
@@ -14,6 +14,7 @@
 #include "wpi/SmallVector.h"
 #include "wpi/STLExtras.h"
 #include "wpi/Compiler.h"
+#include "wpi/span.h"
 #include <algorithm>
 #include <array>
 #include <cassert>
@@ -24,6 +25,9 @@
 #include <optional>
 #include <type_traits>
 #include <vector>
+#if __has_include(<span>)
+#include <span>
+#endif
 
 namespace wpi {
 
@@ -126,6 +130,24 @@ namespace wpi {
                  std::is_convertible<U *const *, T const *>::value>::type* = 0)
       : Data(Vec.data()), Length(Vec.size()) {}
 
+#ifdef __cpp_lib_span
+    /// Construct an ArrayRef from std::span
+    /*implicit*/ ArrayRef(std::span<T> Span)
+        : Data(Span.data()), Length(Span.size()) {}
+
+    /// Construct an ArrayRef from std::span
+    /*implicit*/ ArrayRef(std::span<const T> Span)
+        : Data(Span.data()), Length(Span.size()) {}
+#endif
+
+    /// Construct an ArrayRef from wpi::span
+    /*implicit*/ ArrayRef(span<T> Span)
+        : Data(Span.data()), Length(Span.size()) {}
+
+    /// Construct an ArrayRef from wpi::span
+    /*implicit*/ ArrayRef(span<const T> Span)
+        : Data(Span.data()), Length(Span.size()) {}
+
     /// @}
     /// @name Simple Operations
     /// @{
@@ -268,6 +290,15 @@ namespace wpi {
       return std::vector<T>(Data, Data+Length);
     }
 
+#ifdef __cpp_lib_span
+    operator std::span<const T>() const {
+      return std::span<const T>(Data, Length);
+    }
+#endif
+
+    operator span<const T>() const {
+      return span<const T>(Data, Length);
+    }
     /// @}
   };
 
@@ -322,6 +353,14 @@ namespace wpi {
     template <size_t N>
     /*implicit*/ constexpr MutableArrayRef(T (&Arr)[N]) : ArrayRef<T>(Arr) {}
 
+#ifdef __cpp_lib_span
+    /// Construct an ArrayRef from std::span
+    /*implicit*/ MutableArrayRef(std::span<T> Span) : ArrayRef<T>(Span) {}
+#endif
+
+    /// Construct an ArrayRef from wpi::span
+    /*implicit*/ MutableArrayRef(span<T> Span) : ArrayRef<T>(Span) {}
+
     T *data() const { return const_cast<T*>(ArrayRef<T>::data()); }
 
     iterator begin() const { return data(); }
@@ -414,6 +453,16 @@ namespace wpi {
       assert(Index < this->size() && "Invalid index!");
       return data()[Index];
     }
+
+#ifdef __cpp_lib_span
+    operator std::span<T>() const {
+      return std::span<T>(data(), this->size());
+    }
+#endif
+
+    operator span<T>() const {
+      return span<T>(data(), this->size());
+    }
   };
 
   /// This is a MutableArrayRef that owns its array.
diff --git a/wpiutil/src/main/native/include/wpi/span.h b/wpiutil/src/main/native/include/wpi/span.h
index 74aa17ef75..479b98d9d2 100644
--- a/wpiutil/src/main/native/include/wpi/span.h
+++ b/wpiutil/src/main/native/include/wpi/span.h
@@ -17,6 +17,9 @@ http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/n4820.pdf
 #include <cstddef>
 #include <cstdint>
 #include <type_traits>
+#if __has_include(<span>)
+#include <span>
+#endif
 
 namespace wpi {
 
@@ -219,6 +222,12 @@ public:
         : storage_(other.data(), other.size())
     {}
 
+#ifdef __cpp_lib_span
+    constexpr span(std::span<ElementType> other) noexcept
+        : storage_(other.data(), other.size())
+    {}
+#endif
+
     ~span() noexcept = default;
 
     constexpr span&
@@ -327,6 +336,15 @@ public:
         return reverse_iterator(begin());
     }
 
+#ifdef __cpp_lib_span
+    constexpr operator auto() const {
+      return std::span < ElementType,
+             (Extent == dynamic_extent)
+                 ? std::dynamic_extent
+                 : Extent > (storage_.ptr, storage_.size);
+    }
+#endif
+
 private:
     storage_type storage_{};
 };
diff --git a/wpiutil/src/test/native/cpp/span/test_conversions.cpp b/wpiutil/src/test/native/cpp/span/test_conversions.cpp
new file mode 100644
index 0000000000..7f72b8dc89
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/span/test_conversions.cpp
@@ -0,0 +1,74 @@
+#if __has_include(<span>)
+#include <span>
+#endif
+#include "wpi/ArrayRef.h"
+
+#include "gtest/gtest.h"
+
+void func1(wpi::span<const int> x) {}
+#ifdef __cpp_lib_span
+void func2(std::span<const int> x) {}
+#endif
+void func3(wpi::ArrayRef<int> x) {} 
+
+void func4(wpi::span<int> x) {}
+#ifdef __cpp_lib_span
+void func5(std::span<int> x) {}
+#endif
+void func6(wpi::MutableArrayRef<int> x) {} 
+
+TEST(Span, ConvertArrayRefStdSpan) {
+  func1(wpi::ArrayRef<int>{});
+  func1(wpi::MutableArrayRef<int>{});
+  func1(wpi::span<const int>{});
+  func1(wpi::span<int>{});
+#ifdef __cpp_lib_span
+  func1(std::span<const int>{});
+  func1(std::span<int>{});
+#endif
+
+#ifdef __cpp_lib_span
+  func2(wpi::ArrayRef<int>{});
+  func2(wpi::MutableArrayRef<int>{});
+  func2(wpi::span<const int>{});
+  func2(wpi::span<int>{});
+  func2(std::span<const int>{});
+  func2(std::span<int>{});
+#endif
+
+  func3(wpi::ArrayRef<int>{});
+  func3(wpi::MutableArrayRef<int>{});
+  func3(wpi::span<const int>{});
+  func3(wpi::span<int>{});
+#ifdef __cpp_lib_span
+  func3(std::span<const int>{});
+  func3(std::span<int>{});
+#endif
+
+  //func4(wpi::ArrayRef<int>{});
+  func4(wpi::MutableArrayRef<int>{});
+  //func4(wpi::span<const int>{});
+  func4(wpi::span<int>{});
+#ifdef __cpp_lib_span
+  //func4(std::span<const int>{});
+  func4(std::span<int>{});
+#endif
+
+#ifdef __cpp_lib_span
+  //func5(wpi::ArrayRef<int>{});
+  func5(wpi::MutableArrayRef<int>{});
+  //func5(wpi::span<const int>{});
+  func5(wpi::span<int>{});
+  //func5(std::span<const int>{});
+  func5(std::span<int>{});
+#endif
+
+  //func6(wpi::ArrayRef<int>{});
+  func6(wpi::MutableArrayRef<int>{});
+  //func6(wpi::span<const int>{});
+  func6(wpi::span<int>{});
+#ifdef __cpp_lib_span
+  //func6(std::span<const int>{});
+  func6(std::span<int>{});
+#endif
+}