diff --git a/pw_containers/docs.rst b/pw_containers/docs.rst
index 382c188..4881835 100644
--- a/pw_containers/docs.rst
+++ b/pw_containers/docs.rst
@@ -30,7 +30,7 @@
 .. doxygentypedef:: pw::InlineQueue
 
 ----------------------------
-pw::VariableLengthEntryDeque
+pw::VariableLengthEntryQueue
 ----------------------------
 .. doxygenfile:: pw_containers/variable_length_entry_queue.h
    :sections: detaileddescription
diff --git a/pw_containers/public/pw_containers/variable_length_entry_queue.h b/pw_containers/public/pw_containers/variable_length_entry_queue.h
index cfb5697..f07b728 100644
--- a/pw_containers/public/pw_containers/variable_length_entry_queue.h
+++ b/pw_containers/public/pw_containers/variable_length_entry_queue.h
@@ -22,18 +22,18 @@
 
 /// @file pw_containers/variable_length_entry_queue.h
 ///
-/// A `VariableLengthEntryDeque` is a double-ended queue of variable-length
+/// A `VariableLengthEntryQueue` is a ended queue of inline variable-length
 /// binary entries. It is implemented as a ring (circular) buffer and supports
 /// operations to append entries and overwrite if necessary. Entries may be zero
-/// bytes up to the maximum size supported by the deque.
+/// bytes up to the maximum size supported by the queue.
 ///
-/// The `VariableLengthEntryDeque` a few interesting properties.
+/// The `VariableLengthEntryQueue` has a few interesting properties.
 ///
 /// - Data and metadata are stored inline in a contiguous block of
 ///   `uint32_t`-aligned memory.
-/// - All data structure state changes are accomplished with a single update to
-///   a `uint32_t`. The memory is always in a valid state and may be parsed
-///   offline.
+/// - The data structure is trivially copyable.
+/// - All state changes are accomplished with a single update to a `uint32_t`.
+///   The memory is always in a valid state and may be parsed offline.
 ///
 /// This data structure is a much simpler version of
 /// @cpp_class{pw::ring_buffer::PrefixedEntryRingBuffer}. Prefer this
@@ -45,40 +45,40 @@
 /// - A consistent, parsable, in-memory representation is required (e.g. to
 ///   decode the buffer from a block of memory).
 ///
-/// A `VariableLengthEntryDeque` may be declared and initialized in C with the
-/// @c_macro{PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE} macro.
+/// A `VariableLengthEntryQueue` may be declared and initialized in C with the
+/// @c_macro{PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE} macro.
 ///
 /// @code{c}
 ///
-///   // Declares a deque with a maximum entry size of 10 bytes.
-///   PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(deque, 10);
+///   // Declares a queue with a maximum single entry size of 10 bytes.
+///   PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(queue, 10);
 ///
 ///   // Write some data
-///   pw_VariableLengthEntryDeque_PushBackOverwrite(deque, "123", 3);
-///   pw_VariableLengthEntryDeque_PushBackOverwrite(deque, "456", 3);
+///   pw_VariableLengthEntryQueue_PushOverwrite(queue, "123", 3);
+///   pw_VariableLengthEntryQueue_PushOverwrite(queue, "456", 3);
 ///
-///   assert(pw_VariableLengthEntryDeque_Size(deque) == 2u);
+///   assert(pw_VariableLengthEntryQueue_Size(queue) == 2u);
 ///
 ///   // Remove the entries
-///   pw_VariableLengthEntryDeque_PopFront(deque);
-///   pw_VariableLengthEntryDeque_PopFront(deque);
+///   pw_VariableLengthEntryQueue_Pop(queue);
+///   pw_VariableLengthEntryQueue_Pop(queue);
 ///
 /// @endcode
 ///
-/// Alternately, a `VariableLengthEntryDeque` may also be initialized in an
+/// Alternately, a `VariableLengthEntryQueue` may also be initialized in an
 /// existing ``uint32_t`` array.
 ///
 /// @code{c}
 ///
-///   // Initialize a VariableLengthEntryDeque.
+///   // Initialize a VariableLengthEntryQueue.
 ///   uint32_t buffer[32];
-///   pw_VariableLengthEntryDeque_Init(buffer, 32);
+///   pw_VariableLengthEntryQueue_Init(buffer, 32);
 ///
 ///   // Largest supported entry works out to 114 B (13 B overhead + 1 B prefix)
-///   assert(pw_VariableLengthEntryDeque_MaxEntrySizeBytes(buffer) == 114u);
+///   assert(pw_VariableLengthEntryQueue_MaxEntrySizeBytes(buffer) == 114u);
 ///
 ///   // Write some data
-///   pw_VariableLengthEntryDeque_PushBackOverwrite(buffer, "123", 3);
+///   pw_VariableLengthEntryQueue_PushOverwrite(buffer, "123", 3);
 ///
 /// @endcode
 
@@ -86,105 +86,103 @@
 extern "C" {
 #endif  // __cplusplus
 
-/// @defgroup variable_length_entry_queue_c_api VariableLengthEntryDeque C API
+/// @defgroup variable_length_entry_queue_c_api VariableLengthEntryQueue C API
 /// @{
 
-/// Handle that refers to a `VariableLengthEntryDeque`. In memory, the deque
+/// Handle that refers to a `VariableLengthEntryQueue`. In memory, the queue
 /// is a `uint32_t` array.
-typedef uint32_t* pw_VariableLengthEntryDeque_Handle;
-typedef const uint32_t* pw_VariableLengthEntryDeque_ConstHandle;
+typedef uint32_t* pw_VariableLengthEntryQueue_Handle;
+typedef const uint32_t* pw_VariableLengthEntryQueue_ConstHandle;
 
-/// Declares and initializes a `VariableLengthEntryDeque` that can hold an entry
+/// Declares and initializes a `VariableLengthEntryQueue` that can hold an entry
 /// of up to `max_entry_size_bytes`. Attempting to store larger entries is
 /// invalid and will fail an assertion.
-#define PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(variable, max_entry_size_bytes) \
-  uint32_t variable[PW_VARIABLE_LENGTH_ENTRY_DEQUE_HEADER_SIZE_UINT32 +        \
-                    _PW_VAR_DEQUE_DATA_SIZE_UINT32(max_entry_size_bytes)] = {  \
-      _PW_VAR_DEQUE_DATA_SIZE_BYTES(max_entry_size_bytes),                     \
+#define PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(variable, max_entry_size_bytes) \
+  uint32_t variable[PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32 +        \
+                    _PW_VAR_QUEUE_DATA_SIZE_UINT32(max_entry_size_bytes)] = {  \
+      _PW_VAR_QUEUE_DATA_SIZE_BYTES(max_entry_size_bytes),                     \
       /*head=*/0u,                                                             \
       /*tail=*/0u}
 
-/// The size of the `VariableLengthEntryDeque` header, in `uint32_t` elements.
+/// The size of the `VariableLengthEntryQueue` header, in `uint32_t` elements.
 /// This header stores the buffer length and head and tail offsets.
 ///
-/// The underlying `uint32_t` array of a `VariableLengthEntryDeque` must be
+/// The underlying `uint32_t` array of a `VariableLengthEntryQueue` must be
 /// larger than this size.
-#define PW_VARIABLE_LENGTH_ENTRY_DEQUE_HEADER_SIZE_UINT32 (3)
+#define PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32 (3)
 
-/// Initializes a `VariableLengthEntryDeque` in place in a `uint32_t` array. The
+/// Initializes a `VariableLengthEntryQueue` in place in a `uint32_t` array. The
 /// array MUST be larger than
-/// @c_macro{PW_VARIABLE_LENGTH_ENTRY_DEQUE_HEADER_SIZE_UINT32} (3) elements.
-static inline void pw_VariableLengthEntryDeque_Init(uint32_t array[],
+/// @c_macro{PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32} (3) elements.
+static inline void pw_VariableLengthEntryQueue_Init(uint32_t array[],
                                                     size_t array_size_uint32);
 
-/// Appends an entry to the end of the deque.
+/// Appends an entry to the end of the queue.
 ///
 /// @pre The entry MUST not be larger than
-/// @cpp_func{pw_VariableLengthEntryDeque_MaxEntrySizeBytes}; asserts if it is.
-void pw_VariableLengthEntryDeque_PushBack(
-    pw_VariableLengthEntryDeque_Handle deque,
-    const void* data,
-    uint32_t data_size_bytes);
+/// @cpp_func{pw_VariableLengthEntryQueue_MaxEntrySizeBytes}; asserts if it is.
+void pw_VariableLengthEntryQueue_Push(pw_VariableLengthEntryQueue_Handle queue,
+                                      const void* data,
+                                      uint32_t data_size_bytes);
 
-/// Appends an entry to the end of the deque, removing entries with `PopFront`
+/// Appends an entry to the end of the queue, removing entries with `Pop`
 /// as necessary to make room.
 ///
 /// @pre The entry MUST not be larger than
-/// @cpp_func{pw_VariableLengthEntryDeque_MaxEntrySizeBytes}; asserts if it is.
-void pw_VariableLengthEntryDeque_PushBackOverwrite(
-    pw_VariableLengthEntryDeque_Handle deque,
+/// @cpp_func{pw_VariableLengthEntryQueue_MaxEntrySizeBytes}; asserts if it is.
+void pw_VariableLengthEntryQueue_PushOverwrite(
+    pw_VariableLengthEntryQueue_Handle queue,
     const void* data,
     uint32_t data_size_bytes);
 
 /// Removes the first entry from the ring buffer.
 ///
-/// @pre The deque MUST have at least one entry.
-void pw_VariableLengthEntryDeque_PopFront(
-    pw_VariableLengthEntryDeque_Handle deque);
+/// @pre The queue MUST have at least one entry.
+void pw_VariableLengthEntryQueue_Pop(pw_VariableLengthEntryQueue_Handle queue);
 
-/// Iterator object for a `VariableLengthEntryDeque`. Iterators are checked for
+/// Iterator object for a `VariableLengthEntryQueue`. Iterators are checked for
 /// equality with
-/// @cpp_func{pw_VariableLengthEntryDeque_Iterator_Equal}.
+/// @cpp_func{pw_VariableLengthEntryQueue_Iterator_Equal}.
 ///
 /// Iterators are invalidated by any operations that change the container or
 /// its underlying data (push/pop/init).
 typedef struct {
   // Private: do not access these fields directly!
-  pw_VariableLengthEntryDeque_ConstHandle _pw_deque;
+  pw_VariableLengthEntryQueue_ConstHandle _pw_queue;
   uint32_t _pw_offset;
-} pw_VariableLengthEntryDeque_Iterator;
+} pw_VariableLengthEntryQueue_Iterator;
 
-// An entry in the deque. Entries may be stored in up to two segments, so this
+// An entry in the queue. Entries may be stored in up to two segments, so this
 // struct includes pointers to both portions of the entry.
 typedef struct {
   const uint8_t* data_1;
   uint32_t size_1;
   const uint8_t* data_2;
   uint32_t size_2;
-} pw_VariableLengthEntryDeque_Entry;
+} pw_VariableLengthEntryQueue_Entry;
 
-/// Returns an iterator to the start of the `VariableLengthEntryDeque`.
-static inline pw_VariableLengthEntryDeque_Iterator
-pw_VariableLengthEntryDeque_Begin(
-    pw_VariableLengthEntryDeque_ConstHandle deque);
+/// Returns an iterator to the start of the `VariableLengthEntryQueue`.
+static inline pw_VariableLengthEntryQueue_Iterator
+pw_VariableLengthEntryQueue_Begin(
+    pw_VariableLengthEntryQueue_ConstHandle queue);
 
 /// Returns an iterator to entry following the last entry, which is not valid.
-static inline pw_VariableLengthEntryDeque_Iterator
-pw_VariableLengthEntryDeque_End(pw_VariableLengthEntryDeque_ConstHandle deque);
+static inline pw_VariableLengthEntryQueue_Iterator
+pw_VariableLengthEntryQueue_End(pw_VariableLengthEntryQueue_ConstHandle queue);
 
-/// Advances an iterator to point to the next entry in the deque. It is
+/// Advances an iterator to point to the next entry in the queue. It is
 /// invalid to call `Advance` on an iterator equal to the `End` iterator.
-void pw_VariableLengthEntryDeque_Iterator_Advance(
-    pw_VariableLengthEntryDeque_Iterator* iterator);
+void pw_VariableLengthEntryQueue_Iterator_Advance(
+    pw_VariableLengthEntryQueue_Iterator* iterator);
 
 /// Compares two iterators for equality.
-static inline bool pw_VariableLengthEntryDeque_Iterator_Equal(
-    const pw_VariableLengthEntryDeque_Iterator* lhs,
-    const pw_VariableLengthEntryDeque_Iterator* rhs);
+static inline bool pw_VariableLengthEntryQueue_Iterator_Equal(
+    const pw_VariableLengthEntryQueue_Iterator* lhs,
+    const pw_VariableLengthEntryQueue_Iterator* rhs);
 
 /// Dereferences an iterator, loading the entry it points to.
-pw_VariableLengthEntryDeque_Entry pw_VariableLengthEntryDeque_GetEntry(
-    const pw_VariableLengthEntryDeque_Iterator* iterator);
+pw_VariableLengthEntryQueue_Entry pw_VariableLengthEntryQueue_GetEntry(
+    const pw_VariableLengthEntryQueue_Iterator* iterator);
 
 /// Copies the contents of the entry to the provided buffer. The entry may be
 /// split into two regions; this serializes it into one buffer.
@@ -193,126 +191,126 @@
 /// @param dest The buffer into which to copy the serialized entry
 /// @param count Copy up to this many bytes; must not be larger than the `dest`
 ///     buffer, but may be larger than the entry
-uint32_t pw_VariableLengthEntryDeque_Entry_Copy(
-    const pw_VariableLengthEntryDeque_Entry* entry, void* dest, uint32_t count);
+uint32_t pw_VariableLengthEntryQueue_Entry_Copy(
+    const pw_VariableLengthEntryQueue_Entry* entry, void* dest, uint32_t count);
 
-/// Returns the number of variable-length entries in the deque. This is O(n) in
-/// the number of entries in the deque.
-uint32_t pw_VariableLengthEntryDeque_Size(
-    pw_VariableLengthEntryDeque_ConstHandle deque);
+/// Returns the number of variable-length entries in the queue. This is O(n) in
+/// the number of entries in the queue.
+uint32_t pw_VariableLengthEntryQueue_Size(
+    pw_VariableLengthEntryQueue_ConstHandle queue);
 
 /// Returns the number of bytes stored in the buffer, including entry metadata.
 /// This can be used with `RawCapacityBytes` to gauge available space for
 /// entries.
-static inline uint32_t pw_VariableLengthEntryDeque_RawSizeBytes(
-    pw_VariableLengthEntryDeque_ConstHandle deque);
+static inline uint32_t pw_VariableLengthEntryQueue_RawSizeBytes(
+    pw_VariableLengthEntryQueue_ConstHandle queue);
 
 /// Returns the maximum number of bytes that can be stored in the buffer,
 /// including per-entry metadata. This can be used with `RawSizeBytes` to gauge
 /// available space for entries.
-static inline uint32_t pw_VariableLengthEntryDeque_RawCapacityBytes(
-    pw_VariableLengthEntryDeque_ConstHandle deque);
+static inline uint32_t pw_VariableLengthEntryQueue_RawCapacityBytes(
+    pw_VariableLengthEntryQueue_ConstHandle queue);
 
-/// Returns the size of the raw underlying `VariableLengthEntryDeque` storage.
-/// This size may be used to copy a `VariableLengthEntryDeque` into another
+/// Returns the size of the raw underlying `VariableLengthEntryQueue` storage.
+/// This size may be used to copy a `VariableLengthEntryQueue` into another
 /// 32-bit aligned memory location.
-static inline uint32_t pw_VariableLengthEntryDeque_RawStorageSizeBytes(
-    pw_VariableLengthEntryDeque_ConstHandle deque);
+static inline uint32_t pw_VariableLengthEntryQueue_RawStorageSizeBytes(
+    pw_VariableLengthEntryQueue_ConstHandle queue);
 
-/// Returns the size of the largest entry this `VariableLengthEntryDeque` can
+/// Returns the size of the largest entry this `VariableLengthEntryQueue` can
 /// hold. Attempting to store a larger entry is invalid and fails an assert.
-static inline uint32_t pw_VariableLengthEntryDeque_MaxEntrySizeBytes(
-    pw_VariableLengthEntryDeque_ConstHandle deque);
+static inline uint32_t pw_VariableLengthEntryQueue_MaxEntrySizeBytes(
+    pw_VariableLengthEntryQueue_ConstHandle queue);
 
-/// Returns true if the `VariableLengthEntryDeque` is empty, false if it has at
+/// Returns true if the `VariableLengthEntryQueue` is empty, false if it has at
 /// least one entry.
-static inline bool pw_VariableLengthEntryDeque_Empty(
-    pw_VariableLengthEntryDeque_ConstHandle deque);
+static inline bool pw_VariableLengthEntryQueue_Empty(
+    pw_VariableLengthEntryQueue_ConstHandle queue);
 
 /// @}
 
 // Implementation details.
 
-#define _PW_VAR_DEQUE_DATA_SIZE_UINT32(max_entry_size_bytes) \
-  ((_PW_VAR_DEQUE_DATA_SIZE_BYTES(max_entry_size_bytes) + 3 /* round up */) / 4)
+#define _PW_VAR_QUEUE_DATA_SIZE_UINT32(max_entry_size_bytes) \
+  ((_PW_VAR_QUEUE_DATA_SIZE_BYTES(max_entry_size_bytes) + 3 /* round up */) / 4)
 
-#define _PW_VAR_DEQUE_DATA_SIZE_BYTES(max_entry_size_bytes)                    \
+#define _PW_VAR_QUEUE_DATA_SIZE_BYTES(max_entry_size_bytes)                    \
   (PW_VARINT_ENCODED_SIZE_BYTES(max_entry_size_bytes) + max_entry_size_bytes + \
    1 /*end byte*/)
 
-#define _PW_VAR_DEQUE_ARRAY_SIZE_BYTES deque[0]
-#define _PW_VAR_DEQUE_HEAD deque[1]
-#define _PW_VAR_DEQUE_TAIL deque[2]  // points after the last byte
-#define _PW_VAR_DEQUE_DATA ((const uint8_t*)&deque[3])
+#define _PW_VAR_QUEUE_ARRAY_SIZE_BYTES queue[0]
+#define _PW_VAR_QUEUE_HEAD queue[1]
+#define _PW_VAR_QUEUE_TAIL queue[2]  // points after the last byte
+#define _PW_VAR_QUEUE_DATA ((const uint8_t*)&queue[3])
 
-#define _PW_VAR_DEQUE_GET_ARRAY_SIZE_BYTES(array_size_uint32)     \
+#define _PW_VAR_QUEUE_GET_ARRAY_SIZE_BYTES(array_size_uint32)     \
   (uint32_t)(array_size_uint32 -                                  \
-             PW_VARIABLE_LENGTH_ENTRY_DEQUE_HEADER_SIZE_UINT32) * \
+             PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32) * \
       sizeof(uint32_t)
 
-static inline void pw_VariableLengthEntryDeque_Init(uint32_t array[],
+static inline void pw_VariableLengthEntryQueue_Init(uint32_t array[],
                                                     size_t array_size_uint32) {
-  array[0] = _PW_VAR_DEQUE_GET_ARRAY_SIZE_BYTES(array_size_uint32);
+  array[0] = _PW_VAR_QUEUE_GET_ARRAY_SIZE_BYTES(array_size_uint32);
   array[1] = 0;  // head
   array[2] = 0;  // tail
 }
 
-static inline pw_VariableLengthEntryDeque_Iterator
-pw_VariableLengthEntryDeque_Begin(
-    pw_VariableLengthEntryDeque_ConstHandle deque) {
-  pw_VariableLengthEntryDeque_Iterator begin = {deque, _PW_VAR_DEQUE_HEAD};
+static inline pw_VariableLengthEntryQueue_Iterator
+pw_VariableLengthEntryQueue_Begin(
+    pw_VariableLengthEntryQueue_ConstHandle queue) {
+  pw_VariableLengthEntryQueue_Iterator begin = {queue, _PW_VAR_QUEUE_HEAD};
   return begin;
 }
 
-static inline pw_VariableLengthEntryDeque_Iterator
-pw_VariableLengthEntryDeque_End(pw_VariableLengthEntryDeque_ConstHandle deque) {
-  pw_VariableLengthEntryDeque_Iterator end = {deque, _PW_VAR_DEQUE_TAIL};
+static inline pw_VariableLengthEntryQueue_Iterator
+pw_VariableLengthEntryQueue_End(pw_VariableLengthEntryQueue_ConstHandle queue) {
+  pw_VariableLengthEntryQueue_Iterator end = {queue, _PW_VAR_QUEUE_TAIL};
   return end;
 }
 
-static inline bool pw_VariableLengthEntryDeque_Iterator_Equal(
-    const pw_VariableLengthEntryDeque_Iterator* lhs,
-    const pw_VariableLengthEntryDeque_Iterator* rhs) {
-  return lhs->_pw_offset == rhs->_pw_offset && lhs->_pw_deque == rhs->_pw_deque;
+static inline bool pw_VariableLengthEntryQueue_Iterator_Equal(
+    const pw_VariableLengthEntryQueue_Iterator* lhs,
+    const pw_VariableLengthEntryQueue_Iterator* rhs) {
+  return lhs->_pw_offset == rhs->_pw_offset && lhs->_pw_queue == rhs->_pw_queue;
 }
 
-static inline uint32_t pw_VariableLengthEntryDeque_RawSizeBytes(
-    pw_VariableLengthEntryDeque_ConstHandle deque) {
-  uint32_t tail = _PW_VAR_DEQUE_TAIL;
-  if (tail < _PW_VAR_DEQUE_HEAD) {
-    tail += _PW_VAR_DEQUE_ARRAY_SIZE_BYTES;
+static inline uint32_t pw_VariableLengthEntryQueue_RawSizeBytes(
+    pw_VariableLengthEntryQueue_ConstHandle queue) {
+  uint32_t tail = _PW_VAR_QUEUE_TAIL;
+  if (tail < _PW_VAR_QUEUE_HEAD) {
+    tail += _PW_VAR_QUEUE_ARRAY_SIZE_BYTES;
   }
-  return tail - _PW_VAR_DEQUE_HEAD;
+  return tail - _PW_VAR_QUEUE_HEAD;
 }
 
-static inline uint32_t pw_VariableLengthEntryDeque_RawCapacityBytes(
-    pw_VariableLengthEntryDeque_ConstHandle deque) {
-  return _PW_VAR_DEQUE_ARRAY_SIZE_BYTES - 1;
+static inline uint32_t pw_VariableLengthEntryQueue_RawCapacityBytes(
+    pw_VariableLengthEntryQueue_ConstHandle queue) {
+  return _PW_VAR_QUEUE_ARRAY_SIZE_BYTES - 1;
 }
 
-static inline uint32_t pw_VariableLengthEntryDeque_RawStorageSizeBytes(
-    pw_VariableLengthEntryDeque_ConstHandle deque) {
-  return PW_VARIABLE_LENGTH_ENTRY_DEQUE_HEADER_SIZE_UINT32 * sizeof(uint32_t) +
-         _PW_VAR_DEQUE_ARRAY_SIZE_BYTES;
+static inline uint32_t pw_VariableLengthEntryQueue_RawStorageSizeBytes(
+    pw_VariableLengthEntryQueue_ConstHandle queue) {
+  return PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32 * sizeof(uint32_t) +
+         _PW_VAR_QUEUE_ARRAY_SIZE_BYTES;
 }
 
-static inline uint32_t pw_VariableLengthEntryDeque_MaxEntrySizeBytes(
-    pw_VariableLengthEntryDeque_ConstHandle deque) {
-  return _PW_VAR_DEQUE_ARRAY_SIZE_BYTES - 1 -
-         (uint32_t)pw_varint_EncodedSizeBytes(_PW_VAR_DEQUE_ARRAY_SIZE_BYTES -
+static inline uint32_t pw_VariableLengthEntryQueue_MaxEntrySizeBytes(
+    pw_VariableLengthEntryQueue_ConstHandle queue) {
+  return _PW_VAR_QUEUE_ARRAY_SIZE_BYTES - 1 -
+         (uint32_t)pw_varint_EncodedSizeBytes(_PW_VAR_QUEUE_ARRAY_SIZE_BYTES -
                                               1);
 }
 
-static inline bool pw_VariableLengthEntryDeque_Empty(
-    pw_VariableLengthEntryDeque_ConstHandle deque) {
-  return _PW_VAR_DEQUE_HEAD == _PW_VAR_DEQUE_TAIL;
+static inline bool pw_VariableLengthEntryQueue_Empty(
+    pw_VariableLengthEntryQueue_ConstHandle queue) {
+  return _PW_VAR_QUEUE_HEAD == _PW_VAR_QUEUE_TAIL;
 }
 
 // These macros are not part of the public API, so undefine them.
-#undef _PW_VAR_DEQUE_ARRAY_SIZE_BYTES
-#undef _PW_VAR_DEQUE_HEAD
-#undef _PW_VAR_DEQUE_TAIL
-#undef _PW_VAR_DEQUE_DATA
+#undef _PW_VAR_QUEUE_ARRAY_SIZE_BYTES
+#undef _PW_VAR_QUEUE_HEAD
+#undef _PW_VAR_QUEUE_TAIL
+#undef _PW_VAR_QUEUE_DATA
 
 #ifdef __cplusplus
 }       // extern "C"
diff --git a/pw_containers/pw_containers_private/variable_length_entry_queue_test_oracle.h b/pw_containers/pw_containers_private/variable_length_entry_queue_test_oracle.h
index f492e68..9389d53 100644
--- a/pw_containers/pw_containers_private/variable_length_entry_queue_test_oracle.h
+++ b/pw_containers/pw_containers_private/variable_length_entry_queue_test_oracle.h
@@ -24,26 +24,26 @@
 
 namespace pw::containers {
 
-// Behaves like a VariableLengthEntryDeque should, but with a std::deque-based
+// Behaves like a VariableLengthEntryQueue should, but with a std::deque-based
 // implementation.
-class VariableLengthEntryDequeTestOracle {
+class VariableLengthEntryQueueTestOracle {
  public:
-  VariableLengthEntryDequeTestOracle(uint32_t max_entry_size_bytes)
+  VariableLengthEntryQueueTestOracle(uint32_t max_entry_size_bytes)
       : max_entry_size_bytes_(max_entry_size_bytes),
         raw_size_bytes_(0),
         raw_capacity_bytes_(
             static_cast<uint32_t>(varint::EncodedSize(max_entry_size_bytes)) +
             max_entry_size_bytes) {}
 
-  void push_back_overwrite(ConstByteSpan data) {
+  void push_overwrite(ConstByteSpan data) {
     size_t encoded_size = varint::EncodedSize(data.size()) + data.size();
     while (encoded_size > (raw_capacity_bytes_ - raw_size_bytes_)) {
-      pop_front();
+      pop();
     }
-    push_back(data);
+    push(data);
   }
 
-  void push_back(ConstByteSpan data) {
+  void push(ConstByteSpan data) {
     PW_ASSERT(data.size() <= max_entry_size_bytes_);
 
     size_t encoded_size = varint::EncodedSize(data.size()) + data.size();
@@ -53,7 +53,7 @@
     raw_size_bytes_ += encoded_size;
   }
 
-  void pop_front() {
+  void pop() {
     PW_ASSERT(!q_.empty());
     raw_size_bytes_ -=
         varint::EncodedSize(q_.front().size()) + q_.front().size();
diff --git a/pw_containers/variable_length_entry_queue.c b/pw_containers/variable_length_entry_queue.c
index b6c532d..8f7cc49 100644
--- a/pw_containers/variable_length_entry_queue.c
+++ b/pw_containers/variable_length_entry_queue.c
@@ -20,25 +20,25 @@
 #include "pw_varint/varint.h"
 
 // Access the underlying buffer size and capacity (one less than size).
-static uint32_t BufferSize(const uint32_t* deque) { return deque[0]; }
-static uint32_t Capacity(const uint32_t* deque) {
-  return BufferSize(deque) - 1;
+static uint32_t BufferSize(const uint32_t* queue) { return queue[0]; }
+static uint32_t Capacity(const uint32_t* queue) {
+  return BufferSize(queue) - 1;
 }
 
 // Access the head and tail offsets.
-#define HEAD(deque) deque[1]
-#define TAIL(deque) deque[2]
+#define HEAD(queue) queue[1]
+#define TAIL(queue) queue[2]
 
 // Access the data. Strict aliasing rules do not apply to byte pointers.
-static uint8_t* WritableData(uint32_t* deque) { return (uint8_t*)&deque[3]; }
-static const uint8_t* Data(const uint32_t* deque) {
-  return (const uint8_t*)&deque[3];
+static uint8_t* WritableData(uint32_t* queue) { return (uint8_t*)&queue[3]; }
+static const uint8_t* Data(const uint32_t* queue) {
+  return (const uint8_t*)&queue[3];
 }
 
-static uint32_t WrapIndex(pw_VariableLengthEntryDeque_ConstHandle deque,
+static uint32_t WrapIndex(pw_VariableLengthEntryQueue_ConstHandle queue,
                           uint32_t offset) {
-  if (offset >= BufferSize(deque)) {
-    offset -= BufferSize(deque);
+  if (offset >= BufferSize(queue)) {
+    offset -= BufferSize(queue);
   }
   return offset;
 }
@@ -49,7 +49,7 @@
 } EntrySize;
 
 // Returns the size of an entry, including both the prefix length and data size.
-static EntrySize ReadEntrySize(pw_VariableLengthEntryDeque_ConstHandle deque,
+static EntrySize ReadEntrySize(pw_VariableLengthEntryQueue_ConstHandle queue,
                                uint32_t offset) {
   EntrySize size = {0, 0};
 
@@ -58,120 +58,118 @@
     PW_DCHECK_UINT_NE(size.prefix, PW_VARINT_MAX_INT32_SIZE_BYTES);
 
     keep_going = pw_varint_DecodeOneByte32(
-        Data(deque)[offset], size.prefix++, &size.data);
-    offset = WrapIndex(deque, offset + 1);
+        Data(queue)[offset], size.prefix++, &size.data);
+    offset = WrapIndex(queue, offset + 1);
   } while (keep_going);
 
   return size;
 }
 
-static uint32_t EncodePrefix(pw_VariableLengthEntryDeque_ConstHandle deque,
+static uint32_t EncodePrefix(pw_VariableLengthEntryQueue_ConstHandle queue,
                              uint8_t prefix[PW_VARINT_MAX_INT32_SIZE_BYTES],
                              uint32_t data_size_bytes) {
   const uint32_t prefix_size = (uint32_t)pw_varint_Encode32(
       data_size_bytes, prefix, PW_VARINT_MAX_INT32_SIZE_BYTES);
 
   // Check that the ring buffer is capable of holding entries of this size.
-  PW_CHECK_UINT_LE(prefix_size + data_size_bytes, Capacity(deque));
+  PW_CHECK_UINT_LE(prefix_size + data_size_bytes, Capacity(queue));
   return prefix_size;
 }
 
 // Returns the total encoded size of an entry.
 static uint32_t ReadEncodedEntrySize(
-    pw_VariableLengthEntryDeque_ConstHandle deque, uint32_t offset) {
-  const EntrySize entry_size = ReadEntrySize(deque, offset);
+    pw_VariableLengthEntryQueue_ConstHandle queue, uint32_t offset) {
+  const EntrySize entry_size = ReadEntrySize(queue, offset);
   return entry_size.prefix + entry_size.data;
 }
 
-static uint32_t PopFrontNonEmpty(pw_VariableLengthEntryDeque_Handle deque) {
-  const uint32_t entry_size = ReadEncodedEntrySize(deque, HEAD(deque));
-  HEAD(deque) = WrapIndex(deque, HEAD(deque) + entry_size);
+static uint32_t PopNonEmpty(pw_VariableLengthEntryQueue_Handle queue) {
+  const uint32_t entry_size = ReadEncodedEntrySize(queue, HEAD(queue));
+  HEAD(queue) = WrapIndex(queue, HEAD(queue) + entry_size);
   return entry_size;
 }
 
 // Copies data to the buffer, wrapping around the end if needed.
-static uint32_t CopyAndWrap(pw_VariableLengthEntryDeque_Handle deque,
+static uint32_t CopyAndWrap(pw_VariableLengthEntryQueue_Handle queue,
                             uint32_t tail,
                             const uint8_t* data,
                             uint32_t size) {
   // Copy the new data in one or two chunks. The first chunk is copied to the
   // byte after the tail, the second from the beginning of the buffer. Both may
   // be zero bytes.
-  uint32_t first_chunk = BufferSize(deque) - tail;
+  uint32_t first_chunk = BufferSize(queue) - tail;
   if (first_chunk >= size) {
     first_chunk = size;
   } else {  // Copy 2nd chunk from the beginning of the buffer (may be 0 bytes).
-    memcpy(WritableData(deque),
+    memcpy(WritableData(queue),
            (const uint8_t*)data + first_chunk,
            size - first_chunk);
   }
-  memcpy(&WritableData(deque)[tail], data, first_chunk);
-  return WrapIndex(deque, tail + size);
+  memcpy(&WritableData(queue)[tail], data, first_chunk);
+  return WrapIndex(queue, tail + size);
 }
 
-static void AppendEntryKnownToFit(pw_VariableLengthEntryDeque_Handle deque,
+static void AppendEntryKnownToFit(pw_VariableLengthEntryQueue_Handle queue,
                                   const uint8_t* prefix,
                                   uint32_t prefix_size,
                                   const void* data,
                                   uint32_t size) {
   // Calculate the new tail offset. Don't update it until the copy is complete.
-  uint32_t tail = TAIL(deque);
-  tail = CopyAndWrap(deque, tail, prefix, prefix_size);
-  TAIL(deque) = CopyAndWrap(deque, tail, data, size);
+  uint32_t tail = TAIL(queue);
+  tail = CopyAndWrap(queue, tail, prefix, prefix_size);
+  TAIL(queue) = CopyAndWrap(queue, tail, data, size);
 }
 
-void pw_VariableLengthEntryDeque_PushBack(
-    pw_VariableLengthEntryDeque_Handle deque,
-    const void* data,
-    const uint32_t data_size_bytes) {
+void pw_VariableLengthEntryQueue_Push(pw_VariableLengthEntryQueue_Handle queue,
+                                      const void* data,
+                                      const uint32_t data_size_bytes) {
   uint8_t prefix[PW_VARINT_MAX_INT32_SIZE_BYTES];
-  uint32_t prefix_size = EncodePrefix(deque, prefix, data_size_bytes);
+  uint32_t prefix_size = EncodePrefix(queue, prefix, data_size_bytes);
 
   PW_CHECK(prefix_size + data_size_bytes <=
-           Capacity(deque) - pw_VariableLengthEntryDeque_RawSizeBytes(deque));
+           Capacity(queue) - pw_VariableLengthEntryQueue_RawSizeBytes(queue));
 
-  AppendEntryKnownToFit(deque, prefix, prefix_size, data, data_size_bytes);
+  AppendEntryKnownToFit(queue, prefix, prefix_size, data, data_size_bytes);
 }
 
-void pw_VariableLengthEntryDeque_PushBackOverwrite(
-    pw_VariableLengthEntryDeque_Handle deque,
+void pw_VariableLengthEntryQueue_PushOverwrite(
+    pw_VariableLengthEntryQueue_Handle queue,
     const void* data,
     const uint32_t data_size_bytes) {
   uint8_t prefix[PW_VARINT_MAX_INT32_SIZE_BYTES];
-  uint32_t prefix_size = EncodePrefix(deque, prefix, data_size_bytes);
+  uint32_t prefix_size = EncodePrefix(queue, prefix, data_size_bytes);
 
   uint32_t available_bytes =
-      Capacity(deque) - pw_VariableLengthEntryDeque_RawSizeBytes(deque);
+      Capacity(queue) - pw_VariableLengthEntryQueue_RawSizeBytes(queue);
   while (data_size_bytes + prefix_size > available_bytes) {
-    available_bytes += PopFrontNonEmpty(deque);
+    available_bytes += PopNonEmpty(queue);
   }
 
-  AppendEntryKnownToFit(deque, prefix, prefix_size, data, data_size_bytes);
+  AppendEntryKnownToFit(queue, prefix, prefix_size, data, data_size_bytes);
 }
 
-void pw_VariableLengthEntryDeque_PopFront(
-    pw_VariableLengthEntryDeque_Handle deque) {
-  PW_CHECK(!pw_VariableLengthEntryDeque_Empty(deque));
-  PopFrontNonEmpty(deque);
+void pw_VariableLengthEntryQueue_Pop(pw_VariableLengthEntryQueue_Handle queue) {
+  PW_CHECK(!pw_VariableLengthEntryQueue_Empty(queue));
+  PopNonEmpty(queue);
 }
 
-void pw_VariableLengthEntryDeque_Iterator_Advance(
-    pw_VariableLengthEntryDeque_Iterator* iterator) {
+void pw_VariableLengthEntryQueue_Iterator_Advance(
+    pw_VariableLengthEntryQueue_Iterator* iterator) {
   iterator->_pw_offset = WrapIndex(
-      iterator->_pw_deque,
+      iterator->_pw_queue,
       iterator->_pw_offset +
-          ReadEncodedEntrySize(iterator->_pw_deque, iterator->_pw_offset));
+          ReadEncodedEntrySize(iterator->_pw_queue, iterator->_pw_offset));
 }
 
-pw_VariableLengthEntryDeque_Entry pw_VariableLengthEntryDeque_GetEntry(
-    const pw_VariableLengthEntryDeque_Iterator* iterator) {
-  pw_VariableLengthEntryDeque_ConstHandle deque = iterator->_pw_deque;
+pw_VariableLengthEntryQueue_Entry pw_VariableLengthEntryQueue_GetEntry(
+    const pw_VariableLengthEntryQueue_Iterator* iterator) {
+  pw_VariableLengthEntryQueue_ConstHandle queue = iterator->_pw_queue;
 
-  pw_VariableLengthEntryDeque_Entry entry;
-  EntrySize size = ReadEntrySize(deque, iterator->_pw_offset);
-  uint32_t offset_1 = WrapIndex(deque, iterator->_pw_offset + size.prefix);
+  pw_VariableLengthEntryQueue_Entry entry;
+  EntrySize size = ReadEntrySize(queue, iterator->_pw_offset);
+  uint32_t offset_1 = WrapIndex(queue, iterator->_pw_offset + size.prefix);
 
-  const uint32_t first_chunk = BufferSize(deque) - offset_1;
+  const uint32_t first_chunk = BufferSize(queue) - offset_1;
 
   if (size.data <= first_chunk) {
     entry.size_1 = size.data;
@@ -181,13 +179,13 @@
     entry.size_2 = size.data - first_chunk;
   }
 
-  entry.data_1 = Data(deque) + offset_1;
-  entry.data_2 = Data(deque) + WrapIndex(deque, offset_1 + entry.size_1);
+  entry.data_1 = Data(queue) + offset_1;
+  entry.data_2 = Data(queue) + WrapIndex(queue, offset_1 + entry.size_1);
   return entry;
 }
 
-uint32_t pw_VariableLengthEntryDeque_Entry_Copy(
-    const pw_VariableLengthEntryDeque_Entry* entry,
+uint32_t pw_VariableLengthEntryQueue_Entry_Copy(
+    const pw_VariableLengthEntryQueue_Entry* entry,
     void* dest,
     uint32_t count) {
   PW_DCHECK(dest != NULL || count == 0u);
@@ -209,13 +207,13 @@
   return to_copy;
 }
 
-uint32_t pw_VariableLengthEntryDeque_Size(
-    pw_VariableLengthEntryDeque_ConstHandle deque) {
+uint32_t pw_VariableLengthEntryQueue_Size(
+    pw_VariableLengthEntryQueue_ConstHandle queue) {
   uint32_t entry_count = 0;
-  uint32_t offset = HEAD(deque);
+  uint32_t offset = HEAD(queue);
 
-  while (offset != TAIL(deque)) {
-    offset = WrapIndex(deque, offset + ReadEncodedEntrySize(deque, offset));
+  while (offset != TAIL(queue)) {
+    offset = WrapIndex(queue, offset + ReadEncodedEntrySize(queue, offset));
     entry_count += 1;
   }
   return entry_count;
diff --git a/pw_containers/variable_length_entry_queue_test.cc b/pw_containers/variable_length_entry_queue_test.cc
index a0262ca..f329f60 100644
--- a/pw_containers/variable_length_entry_queue_test.cc
+++ b/pw_containers/variable_length_entry_queue_test.cc
@@ -40,69 +40,69 @@
 
 // Copies an entry, which might be wrapped, to a single std::vector.
 std::vector<std::byte> ReadEntry(
-    const pw_VariableLengthEntryDeque_Iterator& it) {
-  auto entry = pw_VariableLengthEntryDeque_GetEntry(&it);
+    const pw_VariableLengthEntryQueue_Iterator& it) {
+  auto entry = pw_VariableLengthEntryQueue_GetEntry(&it);
   std::vector<std::byte> value(entry.size_1 + entry.size_2);
   EXPECT_EQ(value.size(),
-            pw_VariableLengthEntryDeque_Entry_Copy(
+            pw_VariableLengthEntryQueue_Entry_Copy(
                 &entry, value.data(), entry.size_1 + entry.size_2));
   return value;
 }
 
-#define ASSERT_CONTENTS_EQ(oracle, deque)                                      \
+#define ASSERT_CONTENTS_EQ(oracle, queue)                                      \
   auto oracle_it = oracle.begin();                                             \
-  auto deque_it = pw_VariableLengthEntryDeque_Begin(deque);                    \
-  const auto deque_end = pw_VariableLengthEntryDeque_End(deque);               \
+  auto queue_it = pw_VariableLengthEntryQueue_Begin(queue);                    \
+  const auto queue_end = pw_VariableLengthEntryQueue_End(queue);               \
   uint32_t entries_compared = 0;                                               \
   while (oracle_it != oracle.end() &&                                          \
-         !pw_VariableLengthEntryDeque_Iterator_Equal(&deque_it, &deque_end)) { \
-    ASSERT_EQ(*oracle_it++, ReadEntry(deque_it));                              \
-    pw_VariableLengthEntryDeque_Iterator_Advance(&deque_it);                   \
+         !pw_VariableLengthEntryQueue_Iterator_Equal(&queue_it, &queue_end)) { \
+    ASSERT_EQ(*oracle_it++, ReadEntry(queue_it));                              \
+    pw_VariableLengthEntryQueue_Iterator_Advance(&queue_it);                   \
     entries_compared += 1;                                                     \
   }                                                                            \
   ASSERT_EQ(entries_compared, oracle.size())
 
 // Declares a test that performs a series of operations on a
-// VariableLengthEntryDeque and the "oracle" class, and checks that they match
+// VariableLengthEntryQueue and the "oracle" class, and checks that they match
 // after every step.
 #define DATA_DRIVEN_TEST(program, max_entry_size)                              \
-  TEST(VariableLengthEntryDeque,                                               \
+  TEST(VariableLengthEntryQueue,                                               \
        DataDrivenTest_##program##_MaxEntrySize##max_entry_size) {              \
-    pw::containers::VariableLengthEntryDequeTestOracle oracle(max_entry_size); \
-    PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(c_deque, max_entry_size);           \
+    pw::containers::VariableLengthEntryQueueTestOracle oracle(max_entry_size); \
+    PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(c_queue, max_entry_size);           \
                                                                                \
     for (const TestStep& step : program) {                                     \
       /* Take the action */                                                    \
       if (auto ow = std::get_if<PushOverwrite>(&step); ow != nullptr) {        \
-        pw_VariableLengthEntryDeque_PushBackOverwrite(                         \
-            c_deque, ow->data.data(), static_cast<uint32_t>(ow->data.size())); \
-        oracle.push_back_overwrite(pw::as_bytes(pw::span(ow->data)));          \
+        pw_VariableLengthEntryQueue_PushOverwrite(                             \
+            c_queue, ow->data.data(), static_cast<uint32_t>(ow->data.size())); \
+        oracle.push_overwrite(pw::as_bytes(pw::span(ow->data)));               \
       } else if (auto push = std::get_if<Push>(&step); push != nullptr) {      \
-        pw_VariableLengthEntryDeque_PushBack(                                  \
-            c_deque,                                                           \
+        pw_VariableLengthEntryQueue_Push(                                      \
+            c_queue,                                                           \
             push->data.data(),                                                 \
             static_cast<uint32_t>(push->data.size()));                         \
-        oracle.push_back(pw::as_bytes(pw::span(push->data)));                  \
+        oracle.push(pw::as_bytes(pw::span(push->data)));                       \
       } else if (auto pop = std::get_if<Pop>(&step); pop != nullptr) {         \
-        pw_VariableLengthEntryDeque_PopFront(c_deque);                         \
-        oracle.pop_front();                                                    \
+        pw_VariableLengthEntryQueue_Pop(c_queue);                              \
+        oracle.pop();                                                          \
       } else if (auto size = std::get_if<SizeEquals>(&step);                   \
                  size != nullptr) {                                            \
-        size_t actual = pw_VariableLengthEntryDeque_Size(c_deque);             \
+        size_t actual = pw_VariableLengthEntryQueue_Size(c_queue);             \
         ASSERT_EQ(oracle.size(), actual);                                      \
         ASSERT_EQ(size->expected, actual);                                     \
       } else {                                                                 \
         FAIL() << "Unhandled case";                                            \
       }                                                                        \
       /* Check size and other functions */                                     \
-      ASSERT_EQ(pw_VariableLengthEntryDeque_Size(c_deque), oracle.size());     \
-      ASSERT_EQ(pw_VariableLengthEntryDeque_RawSizeBytes(c_deque),             \
+      ASSERT_EQ(pw_VariableLengthEntryQueue_Size(c_queue), oracle.size());     \
+      ASSERT_EQ(pw_VariableLengthEntryQueue_RawSizeBytes(c_queue),             \
                 oracle.raw_size_bytes());                                      \
-      ASSERT_EQ(pw_VariableLengthEntryDeque_RawCapacityBytes(c_deque),         \
+      ASSERT_EQ(pw_VariableLengthEntryQueue_RawCapacityBytes(c_queue),         \
                 oracle.raw_capacity_bytes());                                  \
-      ASSERT_EQ(pw_VariableLengthEntryDeque_MaxEntrySizeBytes(c_deque),        \
+      ASSERT_EQ(pw_VariableLengthEntryQueue_MaxEntrySizeBytes(c_queue),        \
                 oracle.max_entry_size_bytes());                                \
-      ASSERT_CONTENTS_EQ(oracle, c_deque);                                     \
+      ASSERT_CONTENTS_EQ(oracle, c_queue);                                     \
     }                                                                          \
   }                                                                            \
   static_assert(true, "use a semicolon")
@@ -188,68 +188,68 @@
 };
 DATA_DRIVEN_TEST(kTwoBytePrefix, 130);
 
-TEST(VariableLengthEntryDeque, DeclareMacro) {
-  PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(deque, 123);
+TEST(VariableLengthEntryQueue, DeclareMacro) {
+  PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(queue, 123);
 
   constexpr size_t kArraySizeBytes =
       123 + 1 /*prefix*/ + 1 /* end */ + 3 /* round up */ +
-      PW_VARIABLE_LENGTH_ENTRY_DEQUE_HEADER_SIZE_UINT32 * 4;
-  static_assert(sizeof(deque) == kArraySizeBytes);
-  EXPECT_EQ(pw_VariableLengthEntryDeque_RawStorageSizeBytes(deque),
+      PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32 * 4;
+  static_assert(sizeof(queue) == kArraySizeBytes);
+  EXPECT_EQ(pw_VariableLengthEntryQueue_RawStorageSizeBytes(queue),
             kArraySizeBytes - 3 /* padding isn't included */);
 
-  EXPECT_EQ(pw_VariableLengthEntryDeque_MaxEntrySizeBytes(deque), 123u);
-  EXPECT_EQ(pw_VariableLengthEntryDeque_RawSizeBytes(deque), 0u);
-  EXPECT_TRUE(pw_VariableLengthEntryDeque_Empty(deque));
+  EXPECT_EQ(pw_VariableLengthEntryQueue_MaxEntrySizeBytes(queue), 123u);
+  EXPECT_EQ(pw_VariableLengthEntryQueue_RawSizeBytes(queue), 0u);
+  EXPECT_TRUE(pw_VariableLengthEntryQueue_Empty(queue));
 }
 
-TEST(VariableLengthEntryDeque, InitializeExistingBuffer) {
+TEST(VariableLengthEntryQueue, InitializeExistingBuffer) {
   constexpr size_t kArraySize =
-      10 + PW_VARIABLE_LENGTH_ENTRY_DEQUE_HEADER_SIZE_UINT32;
-  uint32_t deque[kArraySize];
-  pw_VariableLengthEntryDeque_Init(deque, kArraySize);
+      10 + PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32;
+  uint32_t queue[kArraySize];
+  pw_VariableLengthEntryQueue_Init(queue, kArraySize);
 
-  EXPECT_EQ(pw_VariableLengthEntryDeque_RawStorageSizeBytes(deque),
-            sizeof(deque));
-  EXPECT_EQ(pw_VariableLengthEntryDeque_MaxEntrySizeBytes(deque),
+  EXPECT_EQ(pw_VariableLengthEntryQueue_RawStorageSizeBytes(queue),
+            sizeof(queue));
+  EXPECT_EQ(pw_VariableLengthEntryQueue_MaxEntrySizeBytes(queue),
             sizeof(uint32_t) * 10u - 1 /*prefix*/ - 1 /*end*/);
-  EXPECT_EQ(pw_VariableLengthEntryDeque_RawSizeBytes(deque), 0u);
-  EXPECT_EQ(pw_VariableLengthEntryDeque_Size(deque), 0u);
-  EXPECT_TRUE(pw_VariableLengthEntryDeque_Empty(deque));
+  EXPECT_EQ(pw_VariableLengthEntryQueue_RawSizeBytes(queue), 0u);
+  EXPECT_EQ(pw_VariableLengthEntryQueue_Size(queue), 0u);
+  EXPECT_TRUE(pw_VariableLengthEntryQueue_Empty(queue));
 }
 
-TEST(VariableLengthEntryDeque, MaxSizeElement) {
+TEST(VariableLengthEntryQueue, MaxSizeElement) {
   // Test max size elements for a few sizes. Commented out statements fail an
   // assert because the elements are too large.
-  PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(dq16, 126);
-  PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(dq17, 127);
-  PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(dq18, 128);
-  PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(dq19, 129);
+  PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(q16, 126);
+  PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(q17, 127);
+  PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(q18, 128);
+  PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(q19, 129);
 
-  pw_VariableLengthEntryDeque_PushBackOverwrite(dq16, kBigEntryBytes, 126);
-  pw_VariableLengthEntryDeque_PushBackOverwrite(dq17, kBigEntryBytes, 126);
-  pw_VariableLengthEntryDeque_PushBackOverwrite(dq18, kBigEntryBytes, 126);
-  pw_VariableLengthEntryDeque_PushBackOverwrite(dq19, kBigEntryBytes, 126);
+  pw_VariableLengthEntryQueue_PushOverwrite(q16, kBigEntryBytes, 126);
+  pw_VariableLengthEntryQueue_PushOverwrite(q17, kBigEntryBytes, 126);
+  pw_VariableLengthEntryQueue_PushOverwrite(q18, kBigEntryBytes, 126);
+  pw_VariableLengthEntryQueue_PushOverwrite(q19, kBigEntryBytes, 126);
 
-  // pw_VariableLengthEntryDeque_PushBackOverwrite(dq16, kBigEntryBytes, 127);
-  pw_VariableLengthEntryDeque_PushBackOverwrite(dq17, kBigEntryBytes, 127);
-  pw_VariableLengthEntryDeque_PushBackOverwrite(dq18, kBigEntryBytes, 127);
-  pw_VariableLengthEntryDeque_PushBackOverwrite(dq19, kBigEntryBytes, 127);
+  // pw_VariableLengthEntryQueue_PushOverwrite(q16, kBigEntryBytes, 127);
+  pw_VariableLengthEntryQueue_PushOverwrite(q17, kBigEntryBytes, 127);
+  pw_VariableLengthEntryQueue_PushOverwrite(q18, kBigEntryBytes, 127);
+  pw_VariableLengthEntryQueue_PushOverwrite(q19, kBigEntryBytes, 127);
 
-  // pw_VariableLengthEntryDeque_PushBackOverwrite(dq16, kBigEntryBytes, 128);
-  // pw_VariableLengthEntryDeque_PushBackOverwrite(dq17, kBigEntryBytes, 128);
-  pw_VariableLengthEntryDeque_PushBackOverwrite(dq18, kBigEntryBytes, 128);
-  pw_VariableLengthEntryDeque_PushBackOverwrite(dq19, kBigEntryBytes, 128);
+  // pw_VariableLengthEntryQueue_PushOverwrite(q16, kBigEntryBytes, 128);
+  // pw_VariableLengthEntryQueue_PushOverwrite(q17, kBigEntryBytes, 128);
+  pw_VariableLengthEntryQueue_PushOverwrite(q18, kBigEntryBytes, 128);
+  pw_VariableLengthEntryQueue_PushOverwrite(q19, kBigEntryBytes, 128);
 
-  // pw_VariableLengthEntryDeque_PushBackOverwrite(dq16, kBigEntryBytes, 129);
-  // pw_VariableLengthEntryDeque_PushBackOverwrite(dq17, kBigEntryBytes, 129);
-  // pw_VariableLengthEntryDeque_PushBackOverwrite(dq18, kBigEntryBytes, 129);
-  pw_VariableLengthEntryDeque_PushBackOverwrite(dq19, kBigEntryBytes, 129);
+  // pw_VariableLengthEntryQueue_PushOverwrite(q16, kBigEntryBytes, 129);
+  // pw_VariableLengthEntryQueue_PushOverwrite(q17, kBigEntryBytes, 129);
+  // pw_VariableLengthEntryQueue_PushOverwrite(q18, kBigEntryBytes, 129);
+  pw_VariableLengthEntryQueue_PushOverwrite(q19, kBigEntryBytes, 129);
 
-  EXPECT_EQ(pw_VariableLengthEntryDeque_Size(dq16), 1u);
-  EXPECT_EQ(pw_VariableLengthEntryDeque_Size(dq17), 1u);
-  EXPECT_EQ(pw_VariableLengthEntryDeque_Size(dq18), 1u);
-  EXPECT_EQ(pw_VariableLengthEntryDeque_Size(dq19), 1u);
+  EXPECT_EQ(pw_VariableLengthEntryQueue_Size(q16), 1u);
+  EXPECT_EQ(pw_VariableLengthEntryQueue_Size(q17), 1u);
+  EXPECT_EQ(pw_VariableLengthEntryQueue_Size(q18), 1u);
+  EXPECT_EQ(pw_VariableLengthEntryQueue_Size(q19), 1u);
 }
 
 }  // namespace
diff --git a/pw_tokenizer/tokenize_c99_test.c b/pw_tokenizer/tokenize_c99_test.c
index 2fe0b43..62bd7c4 100644
--- a/pw_tokenizer/tokenize_c99_test.c
+++ b/pw_tokenizer/tokenize_c99_test.c
@@ -43,7 +43,7 @@
 #error "This test should be compiled with -std=c99."
 #endif  // __STDC_VERSION__ != 199901L
 
-PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(buffer, 256);
+PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(buffer, 256);
 
 // Encodes a tokenized message with any number of int arguments.
 static void TokenizeIntegersOnly(uint32_t token, int arg_count, ...) {
@@ -66,7 +66,7 @@
   }
 
   // Write the encoded log to the ring buffer
-  pw_VariableLengthEntryDeque_PushBackOverwrite(buffer, encoded, index);
+  pw_VariableLengthEntryQueue_PushOverwrite(buffer, encoded, index);
 
   va_end(args);
 }
@@ -100,35 +100,35 @@
   TOKENIZE_INTS("One arg, 5 bytes: %ld", (long)INT32_MAX);
   TOKENIZE_INTS("Three args, 4 bytes: %d %d %d", 1, 63, 128);
 
-  ASSERT_EQ(pw_VariableLengthEntryDeque_Size(buffer), 4u);
+  ASSERT_EQ(pw_VariableLengthEntryQueue_Size(buffer), 4u);
 
-  pw_VariableLengthEntryDeque_Iterator it =
-      pw_VariableLengthEntryDeque_Begin(buffer);
-  pw_VariableLengthEntryDeque_Entry entry =
-      pw_VariableLengthEntryDeque_GetEntry(&it);
+  pw_VariableLengthEntryQueue_Iterator it =
+      pw_VariableLengthEntryQueue_Begin(buffer);
+  pw_VariableLengthEntryQueue_Entry entry =
+      pw_VariableLengthEntryQueue_GetEntry(&it);
 
   ASSERT_EQ(entry.size_1, sizeof(uint32_t) + 0);
   ASSERT_EQ(entry.size_2, 0u);
 
-  pw_VariableLengthEntryDeque_Iterator_Advance(&it);
-  entry = pw_VariableLengthEntryDeque_GetEntry(&it);
+  pw_VariableLengthEntryQueue_Iterator_Advance(&it);
+  entry = pw_VariableLengthEntryQueue_GetEntry(&it);
   ASSERT_EQ(entry.size_1, sizeof(uint32_t) + 1);
   ASSERT_EQ(entry.size_2, 0u);
 
-  pw_VariableLengthEntryDeque_Iterator_Advance(&it);
-  entry = pw_VariableLengthEntryDeque_GetEntry(&it);
+  pw_VariableLengthEntryQueue_Iterator_Advance(&it);
+  entry = pw_VariableLengthEntryQueue_GetEntry(&it);
   ASSERT_EQ(entry.size_1, sizeof(uint32_t) + 5);
   ASSERT_EQ(entry.size_2, 0u);
 
-  pw_VariableLengthEntryDeque_Iterator_Advance(&it);
-  entry = pw_VariableLengthEntryDeque_GetEntry(&it);
+  pw_VariableLengthEntryQueue_Iterator_Advance(&it);
+  entry = pw_VariableLengthEntryQueue_GetEntry(&it);
   ASSERT_EQ(entry.size_1, sizeof(uint32_t) + 4);
   ASSERT_EQ(entry.size_2, 0u);
 
-  pw_VariableLengthEntryDeque_Iterator_Advance(&it);
-  pw_VariableLengthEntryDeque_Iterator end =
-      pw_VariableLengthEntryDeque_End(buffer);
-  ASSERT_EQ(pw_VariableLengthEntryDeque_Iterator_Equal(&it, &end), true);
+  pw_VariableLengthEntryQueue_Iterator_Advance(&it);
+  pw_VariableLengthEntryQueue_Iterator end =
+      pw_VariableLengthEntryQueue_End(buffer);
+  ASSERT_EQ(pw_VariableLengthEntryQueue_Iterator_Equal(&it, &end), true);
 
   return "passed";
 }