diff --git a/libraries/libvapours/include/vapours.hpp b/libraries/libvapours/include/vapours.hpp
index 4db67f4e8..d51797e3a 100644
--- a/libraries/libvapours/include/vapours.hpp
+++ b/libraries/libvapours/include/vapours.hpp
@@ -20,6 +20,7 @@
 #include <vapours/literals.hpp>
 
 #include <vapours/timespan.hpp>
+#include <vapours/span.hpp>
 
 #include <vapours/util.hpp>
 #include <vapours/results.hpp>
diff --git a/libraries/libvapours/include/vapours/span.hpp b/libraries/libvapours/include/vapours/span.hpp
new file mode 100644
index 000000000..ee0a07a2d
--- /dev/null
+++ b/libraries/libvapours/include/vapours/span.hpp
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours/common.hpp>
+#include <vapours/assert.hpp>
+
+namespace ams {
+
+    /* TODO C++20 switch to template<typename T> using Span = std::span<T> */
+
+    namespace impl {
+
+        template<typename Span>
+        class SpanConstIterator;
+
+        template<typename Span, typename Derived, typename Reference>
+        class SpanIteratorImpl {
+            public:
+                friend class SpanConstIterator<Span>;
+
+                using index_type        = typename Span::index_type;
+                using difference_type   = typename Span::difference_type;
+                using value_type        = typename std::remove_cv<typename Span::element_type>::type;
+                using pointer           = typename std::add_pointer<Reference>::type;
+                using reference         = Reference;
+                using iterator_category = std::random_access_iterator_tag;
+            private:
+                const Span *span = nullptr;
+                index_type index = 0;
+            public:
+                constexpr ALWAYS_INLINE SpanIteratorImpl() = default;
+                constexpr ALWAYS_INLINE SpanIteratorImpl(const Span *s, index_type idx) : span(s), index(idx) { /* ... */ }
+
+                constexpr ALWAYS_INLINE pointer operator->() const {
+                    return this->span->data() + this->index;
+                }
+
+                constexpr ALWAYS_INLINE reference operator*() const {
+                    return *this->operator->();
+                }
+
+                constexpr ALWAYS_INLINE Derived operator++(int) {
+                    auto prev = static_cast<Derived &>(*this);
+                    ++(*this);
+                    return prev;
+                }
+
+                constexpr ALWAYS_INLINE Derived operator--(int) {
+                    auto prev = static_cast<Derived &>(*this);
+                    --(*this);
+                    return prev;
+                }
+
+                constexpr ALWAYS_INLINE Derived &operator++() { ++this->index; return static_cast<Derived &>(*this); }
+                constexpr ALWAYS_INLINE Derived &operator--() { --this->index; return static_cast<Derived &>(*this); }
+
+                constexpr ALWAYS_INLINE Derived &operator+=(difference_type n) { this->index += n; return static_cast<Derived &>(*this); }
+                constexpr ALWAYS_INLINE Derived &operator-=(difference_type n) { this->index -= n; return static_cast<Derived &>(*this); }
+
+                constexpr ALWAYS_INLINE Derived operator+(difference_type n) const { auto r = static_cast<const Derived &>(*this); return r += n; }
+                constexpr ALWAYS_INLINE Derived operator-(difference_type n) const { auto r = static_cast<const Derived &>(*this); return r -= n; }
+
+                constexpr ALWAYS_INLINE friend Derived  operator+(difference_type n, Derived it) { return it + n; }
+                constexpr ALWAYS_INLINE difference_type operator-(Derived rhs) const { AMS_ASSERT(this->span == rhs.span); return this->index - rhs.index; }
+
+                constexpr ALWAYS_INLINE reference operator[](difference_type n) const { return *(*this + n); }
+
+                constexpr ALWAYS_INLINE friend bool operator==(Derived lhs, Derived rhs) {
+                    return lhs.span == rhs.span && lhs.index == rhs.index;
+                }
+
+                constexpr ALWAYS_INLINE friend bool operator<(Derived lhs, Derived rhs) {
+                    AMS_ASSERT(lhs.span == rhs.span);
+                    return lhs.index < rhs.index;
+                }
+
+                constexpr ALWAYS_INLINE friend bool operator!=(Derived lhs, Derived rhs) { return !(lhs == rhs); }
+
+                constexpr ALWAYS_INLINE friend bool operator>(Derived lhs, Derived rhs)  { return rhs < lhs; }
+
+                constexpr ALWAYS_INLINE friend bool operator<=(Derived lhs, Derived rhs) { return !(lhs > rhs); }
+                constexpr ALWAYS_INLINE friend bool operator>=(Derived lhs, Derived rhs) { return !(lhs < rhs); }
+        };
+
+        template<typename Span>
+        class SpanIterator : public SpanIteratorImpl<Span, SpanIterator<Span>, typename Span::element_type&> {
+            public:
+                using SpanIteratorImpl<Span, SpanIterator<Span>, typename Span::element_type&>::SpanIteratorImpl;
+        };
+
+        template<typename Span>
+        class SpanConstIterator : public SpanIteratorImpl<Span, SpanConstIterator<Span>, const typename Span::element_type&> {
+            public:
+                using SpanIteratorImpl<Span, SpanConstIterator<Span>, const typename Span::element_type&>::SpanIteratorImpl;
+
+                constexpr ALWAYS_INLINE SpanConstIterator() = default;
+                constexpr ALWAYS_INLINE SpanConstIterator(const SpanIterator<Span> &rhs) : SpanConstIterator(rhs.span, rhs.index) { /* ... */ }
+        };
+
+    }
+
+    template<typename T>
+    class Span {
+        public:
+            using element_type           = T;
+            using value_type             = typename std::remove_cv<element_type>::type;
+            using index_type             = std::ptrdiff_t;
+            using difference_type        = std::ptrdiff_t;
+            using pointer                = element_type *;
+            using reference              = element_type &;
+            using iterator               = ::ams::impl::SpanIterator<Span>;
+            using const_iterator         = ::ams::impl::SpanConstIterator<Span>;
+            using reverse_iterator       = std::reverse_iterator<iterator>;
+            using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+        private:
+            T *ptr;
+            index_type num_elements;
+        public:
+            constexpr ALWAYS_INLINE Span() : ptr(), num_elements() { /* ... */ }
+
+            constexpr ALWAYS_INLINE Span(T *p, index_type size) : ptr(p), num_elements(size) {
+                AMS_ASSERT(this->num_elements > 0 || this->ptr == nullptr);
+            }
+
+            constexpr ALWAYS_INLINE Span(T *start, T *end) : Span(start, end - start) { /* ... */ }
+
+            template<size_t Size>
+            constexpr ALWAYS_INLINE Span(T (&arr)[Size]) : Span(static_cast<T *>(arr), static_cast<index_type>(Size)) { /* ... */ }
+
+            template<size_t Size>
+            constexpr ALWAYS_INLINE Span(std::array<value_type, Size> &arr) : Span(arr.data(), static_cast<index_type>(Size)) { /* ... */ }
+
+            template<size_t Size>
+            constexpr ALWAYS_INLINE Span(const std::array<value_type, Size> &arr) : Span(arr.data(), static_cast<index_type>(Size)) { /* ... */ }
+
+            template<typename U, typename = typename std::enable_if<std::is_convertible<U(*)[], T(*)[]>::value>::type>
+            constexpr ALWAYS_INLINE Span(const Span<U> &rhs) : Span(rhs.data(), rhs.size()) { /* ... */ }
+        public:
+            constexpr ALWAYS_INLINE iterator begin() const { return { this, 0 }; }
+            constexpr ALWAYS_INLINE iterator end()   const { return { this, this->num_elements }; }
+
+            constexpr ALWAYS_INLINE const_iterator cbegin() const { return { this, 0 }; }
+            constexpr ALWAYS_INLINE const_iterator cend()   const { return { this, this->num_elements }; }
+
+            constexpr ALWAYS_INLINE reverse_iterator rbegin() const { return reverse_iterator(this->end()); }
+            constexpr ALWAYS_INLINE reverse_iterator rend() const { return reverse_iterator(this->begin()); }
+
+            constexpr ALWAYS_INLINE const_reverse_iterator crbegin() const { return reverse_iterator(this->cend()); }
+            constexpr ALWAYS_INLINE const_reverse_iterator crend() const { return reverse_iterator(this->cbegin()); }
+
+            constexpr ALWAYS_INLINE pointer data() const { return this->ptr; }
+
+            constexpr ALWAYS_INLINE index_type size()       const { return this->num_elements; }
+            constexpr ALWAYS_INLINE index_type size_bytes() const { return this->size() * sizeof(T); }
+
+            constexpr ALWAYS_INLINE bool empty() const { return this->size() == 0; }
+
+            constexpr ALWAYS_INLINE T &operator[](index_type idx) const {
+                AMS_ASSERT(idx < this->size());
+                return this->ptr[idx];
+            }
+
+            constexpr ALWAYS_INLINE T &operator()(index_type idx) const { return (*this)[idx]; }
+
+            constexpr ALWAYS_INLINE Span first(index_type size) const {
+                AMS_ASSERT(size <= this->size());
+                return { this->ptr, size };
+            }
+
+            constexpr ALWAYS_INLINE Span last(index_type size) const {
+                AMS_ASSERT(size <= this->size());
+                return { this->ptr + (this->size() - size), size };
+            }
+
+            constexpr ALWAYS_INLINE Span subspan(index_type idx, index_type size) const {
+                AMS_ASSERT(size <= this->size());
+                AMS_ASSERT(this->size() - size >= idx);
+                return { this->ptr + idx, size };
+            }
+
+            constexpr ALWAYS_INLINE Span subspan(index_type idx) const {
+                AMS_ASSERT(idx <= this->size());
+                return { this->ptr + idx, this->size() - idx };
+            }
+    };
+
+    template<typename T>
+    constexpr ALWAYS_INLINE Span<T> MakeSpan(T *start, T *end) {
+        return { start, end };
+    }
+
+    template<typename T>
+    constexpr ALWAYS_INLINE Span<T> MakeSpan(T *p, typename Span<T>::index_type size) {
+        return { p, size };
+    }
+
+    template<typename T, size_t Size>
+    constexpr ALWAYS_INLINE Span<T> MakeSpan(T (&arr)[Size]) {
+        return Span<T>(arr);
+    }
+
+    template<typename T, size_t Size>
+    constexpr ALWAYS_INLINE Span<T> MakeSpan(std::array<T, Size> &arr) {
+        return Span<T>(arr);
+    }
+
+    template<typename T, size_t Size>
+    constexpr ALWAYS_INLINE Span<const T> MakeSpan(const std::array<T, Size> &arr) {
+        return Span<const T>(arr);
+    }
+
+}