diff --git a/build/source_list.bzl b/build/source_list.bzl
index 37e3f2b..fac6ffe 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -336,6 +336,7 @@
     "quic/core/quic_framer.h",
     "quic/core/quic_generic_session.h",
     "quic/core/quic_idle_network_detector.h",
+    "quic/core/quic_inlined_string_view.h",
     "quic/core/quic_interval.h",
     "quic/core/quic_interval_deque.h",
     "quic/core/quic_interval_set.h",
@@ -1312,6 +1313,7 @@
     "quic/core/quic_framer_test.cc",
     "quic/core/quic_generic_session_test.cc",
     "quic/core/quic_idle_network_detector_test.cc",
+    "quic/core/quic_inlined_string_view_test.cc",
     "quic/core/quic_interval_deque_test.cc",
     "quic/core/quic_interval_set_test.cc",
     "quic/core/quic_interval_test.cc",
diff --git a/build/source_list.gni b/build/source_list.gni
index 6a24274..93a4c55 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -336,6 +336,7 @@
     "src/quiche/quic/core/quic_framer.h",
     "src/quiche/quic/core/quic_generic_session.h",
     "src/quiche/quic/core/quic_idle_network_detector.h",
+    "src/quiche/quic/core/quic_inlined_string_view.h",
     "src/quiche/quic/core/quic_interval.h",
     "src/quiche/quic/core/quic_interval_deque.h",
     "src/quiche/quic/core/quic_interval_set.h",
@@ -1313,6 +1314,7 @@
     "src/quiche/quic/core/quic_framer_test.cc",
     "src/quiche/quic/core/quic_generic_session_test.cc",
     "src/quiche/quic/core/quic_idle_network_detector_test.cc",
+    "src/quiche/quic/core/quic_inlined_string_view_test.cc",
     "src/quiche/quic/core/quic_interval_deque_test.cc",
     "src/quiche/quic/core/quic_interval_set_test.cc",
     "src/quiche/quic/core/quic_interval_test.cc",
diff --git a/build/source_list.json b/build/source_list.json
index d7a7523..1cabec8 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -335,6 +335,7 @@
     "quiche/quic/core/quic_framer.h",
     "quiche/quic/core/quic_generic_session.h",
     "quiche/quic/core/quic_idle_network_detector.h",
+    "quiche/quic/core/quic_inlined_string_view.h",
     "quiche/quic/core/quic_interval.h",
     "quiche/quic/core/quic_interval_deque.h",
     "quiche/quic/core/quic_interval_set.h",
@@ -1312,6 +1313,7 @@
     "quiche/quic/core/quic_framer_test.cc",
     "quiche/quic/core/quic_generic_session_test.cc",
     "quiche/quic/core/quic_idle_network_detector_test.cc",
+    "quiche/quic/core/quic_inlined_string_view_test.cc",
     "quiche/quic/core/quic_interval_deque_test.cc",
     "quiche/quic/core/quic_interval_set_test.cc",
     "quiche/quic/core/quic_interval_test.cc",
diff --git a/quiche/quic/core/quic_inlined_string_view.h b/quiche/quic/core/quic_inlined_string_view.h
new file mode 100644
index 0000000..4d3ef3f
--- /dev/null
+++ b/quiche/quic/core/quic_inlined_string_view.h
@@ -0,0 +1,147 @@
+// Copyright 2025 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_CORE_QUIC_INLINED_STRING_VIEW_H_
+#define QUICHE_QUIC_CORE_QUIC_INLINED_STRING_VIEW_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+#include "absl/numeric/bits.h"
+#include "absl/strings/string_view.h"
+#include "quiche/common/platform/api/quiche_export.h"
+#include "quiche/common/platform/api/quiche_logging.h"
+
+namespace quic {
+
+// QuicInlinedStringView<kSize> is a class that is similar to absl::string_view,
+// with a notable distinction that it can inline up to `kSize` characters
+// (between 15 and 127).
+//
+// Important use notes:
+// - QuicInlinedStringView makes no assumptions about ownership of non-inlined
+//   data; its primary purpose is to be a building block for other data
+//   structures.
+// - Unlike a regular string_view, the data pointer for QuicInlinedStringView
+//   will start pointing to a different location if inlined.
+// - The string will be inlined iff its size is strictly below kSize; this is
+//   a guaranteeed API behavior.
+template <size_t kSize>
+class QUICHE_NO_EXPORT QuicInlinedStringView {
+ public:
+  // The largest size of a string that can be inlined.
+  static constexpr size_t kMaxInlinedSize = kSize - 1;
+
+  static_assert(kSize >= 16);
+  static_assert(kSize < 255);
+
+  QuicInlinedStringView() { clear(); }
+  explicit QuicInlinedStringView(absl::string_view source) {
+    // Special-case empty strings, since memcpy has weird edge case behaviors
+    // around null pointers.
+    if (source.empty()) {
+      clear();
+      return;
+    }
+
+    QUICHE_DCHECK_EQ(source.size() & (~kLengthMask), 0);
+    if (source.size() > kMaxInlinedSize) {
+      ViewRep rep;
+      rep.data = source.data();
+      rep.size = source.size();
+      memcpy(&data_, &rep, sizeof(rep));
+      set_last_byte(kNotInlinedMarker);
+      return;
+    }
+    memcpy(data_, source.data(), source.size());
+    set_last_byte(source.size());
+  }
+
+  // QuicInlinedStringView is trivially copyable and assignable; see, however,
+  // the warning above regarding the pointer stability.
+  QuicInlinedStringView(const QuicInlinedStringView&) = default;
+  QuicInlinedStringView(QuicInlinedStringView&&) = default;
+  QuicInlinedStringView& operator=(const QuicInlinedStringView&) = default;
+  QuicInlinedStringView& operator=(QuicInlinedStringView&&) = default;
+
+  // Returns true if the string is inlined into the view.
+  bool IsInlined() const { return last_byte() != kNotInlinedMarker; }
+
+  // string_view-compatible API.
+  const char* data() const {
+    if (!IsInlined()) {
+      return view_rep_data();
+    }
+    return last_byte() == 0 ? nullptr : data_;
+  }
+  size_t size() const {
+    return IsInlined() ? last_byte() : (view_rep_size() & kLengthMask);
+  }
+  bool empty() const { return size() == 0; }
+
+  absl::string_view view() const { return absl::string_view(data(), size()); }
+  void clear() { set_last_byte(0); }
+
+ private:
+  // On 64-bit platforms, we want to support kSize of 16, so we take the top
+  // byte of the length, and use it for inlining.  On 32-bit platforms, that
+  // would limit us to 24-bit lengths, which is too short, so we just require
+  // the length to not overlap with the last byte (by setting minimum size to 16
+  // bytes), and no masking is necessary.
+  static_assert(sizeof(size_t) == 4 || sizeof(size_t) == 8);
+  // Here, we have to spell out kLengthMask in terms of numeric_limits, since
+  // specifying the value directly would fail compile-time overflow check on
+  // 32-bit platforms.
+  static constexpr size_t kLengthMask =
+      sizeof(size_t) > 4 ? ((std::numeric_limits<size_t>::max() << 8) >> 8)
+                         : 0xffffffff;
+  static constexpr size_t kNotInlinedMarker = 0xff;
+
+#if defined(__x86_64__)
+  static_assert(kLengthMask == 0x00ffffffffffffff);
+#endif
+
+  // Representation of the string view when it is not inlined.
+  struct ViewRep {
+    const char* data;
+    size_t size;
+  };
+  static_assert(sizeof(ViewRep) <= kSize);
+  static_assert(absl::endian::native == absl::endian::little);
+
+  // Accessors for ViewRep; necessary to work around C++ strict aliasing
+  // limitations.  Clang will turn this into direct field access at `-O1`.
+  const char* view_rep_data() const {
+    ViewRep rep;
+    memcpy(&rep, data_, sizeof(rep));
+    return rep.data;
+  }
+  size_t view_rep_size() const {
+    ViewRep rep;
+    memcpy(&rep, data_, sizeof(rep));
+    return rep.size;
+  }
+  // Those casts should be valid as long as uint8_t is unsigned char.
+  const uint8_t& last_byte() const {
+    return *reinterpret_cast<const uint8_t*>(data_ + kSize - 1);
+  }
+  void set_last_byte(uint8_t byte) {
+    *reinterpret_cast<uint8_t*>(data_ + kSize - 1) = byte;
+  }
+
+  // Internal representation: if the string is inlined, the last byte is the
+  // length of the inlined string, and all of the preceding bytes are the
+  // inlined string.  If the string is not inlined, the `ViewRep` is at the
+  // front, and 0xff is at the end (on 64-bit platforms, those may overlap).
+  alignas(ViewRep) char data_[kSize];
+};
+
+static_assert(std::is_trivially_destructible_v<QuicInlinedStringView<16>>);
+static_assert(std::is_trivially_copyable_v<QuicInlinedStringView<16>>);
+
+}  // namespace quic
+
+#endif  // QUICHE_QUIC_CORE_QUIC_INLINED_STRING_VIEW_H_
diff --git a/quiche/quic/core/quic_inlined_string_view_test.cc b/quiche/quic/core/quic_inlined_string_view_test.cc
new file mode 100644
index 0000000..66b062a
--- /dev/null
+++ b/quiche/quic/core/quic_inlined_string_view_test.cc
@@ -0,0 +1,74 @@
+// Copyright 2025 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/core/quic_inlined_string_view.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "quiche/common/platform/api/quiche_test.h"
+
+namespace quic {
+namespace {
+
+TEST(QuicInlinedStringViewTest, DefaultConstructor) {
+  QuicInlinedStringView<24> view;
+  EXPECT_EQ(view.data(), nullptr);
+  EXPECT_EQ(view.size(), 0);
+  EXPECT_EQ(view.view(), absl::string_view());
+  EXPECT_TRUE(view.IsInlined());
+
+  QuicInlinedStringView<24> view_from_empty("");
+  EXPECT_EQ(view_from_empty.data(), nullptr);
+  EXPECT_EQ(view_from_empty.size(), 0);
+  EXPECT_EQ(view_from_empty.view(), absl::string_view());
+  EXPECT_TRUE(view_from_empty.IsInlined());
+}
+
+TEST(QuicInlinedStringViewTest, RangeTest) {
+  constexpr size_t kBufSize = 32;
+  for (size_t size = 1; size < 1024; ++size) {
+    std::string example(size, 'a');
+    QuicInlinedStringView<kBufSize> view(example);
+    EXPECT_NE(view.data(), nullptr);
+    EXPECT_EQ(view.size(), size);
+    EXPECT_EQ(view.view(), example);
+    EXPECT_EQ(view.IsInlined(), size < kBufSize);
+  }
+}
+
+// Test 16 bytes specifically, since on 64-bit platforms, that is where the size
+// byte overlaps with the inlined marker.
+TEST(QuicInlinedStringViewTest, RangeTest16) {
+  constexpr size_t kBufSize = 16;
+  for (size_t size = 1; size < 1024; ++size) {
+    std::string example(size, 'a');
+    QuicInlinedStringView<kBufSize> view(example);
+    EXPECT_NE(view.data(), nullptr);
+    EXPECT_EQ(view.size(), size);
+    EXPECT_EQ(view.view(), example);
+    EXPECT_EQ(view.IsInlined(), size < kBufSize);
+  }
+}
+
+TEST(QuicInlinedStringViewTest, CopyConstructor) {
+  QuicInlinedStringView<24> view_inlined("aaa");
+  ASSERT_TRUE(view_inlined.IsInlined());
+  QuicInlinedStringView<24> view_inlined_copy = view_inlined;
+  EXPECT_EQ(view_inlined.view(), view_inlined_copy.view());
+  EXPECT_NE(reinterpret_cast<uintptr_t>(view_inlined.data()),
+            reinterpret_cast<uintptr_t>(view_inlined_copy.data()));
+
+  QuicInlinedStringView<24> view_external("aaaaaaaaaaaaaaaaaaaaaaaaa");
+  ASSERT_FALSE(view_external.IsInlined());
+  QuicInlinedStringView<24> view_external_copy = view_external;
+  EXPECT_EQ(view_external.view(), view_external_copy.view());
+  EXPECT_EQ(reinterpret_cast<uintptr_t>(view_external.data()),
+            reinterpret_cast<uintptr_t>(view_external_copy.data()));
+}
+
+}  // namespace
+}  // namespace quic