diff --git a/src-self-hosted/compilation.zig b/src-self-hosted/compilation.zig
index 5171b80ddc1b697223d46a00c305af15fac3d340..bd20442d4becdfe9e9c0c1199cfdb863b606f68f 100644
--- a/src-self-hosted/compilation.zig
+++ b/src-self-hosted/compilation.zig
@@ -160,7 +160,7 @@ pub const Compilation = struct {
     /// it uses an optional pointer so that tombstone removals are possible
     fn_link_set: event.Locked(FnLinkSet),
 
-    pub const FnLinkSet = std.LinkedList(?*Value.Fn);
+    pub const FnLinkSet = std.TailQueue(?*Value.Fn);
 
     windows_subsystem_windows: bool,
     windows_subsystem_console: bool,
diff --git a/src-self-hosted/value.zig b/src-self-hosted/value.zig
index 328646d2cdaf97a25af8ada355f2eb33889368cf..6908307c560acb5b24bdc4bcdd250e7da4058eeb 100644
--- a/src-self-hosted/value.zig
+++ b/src-self-hosted/value.zig
@@ -186,7 +186,7 @@ pub const Value = struct {
         /// Path to the object file that contains this function
         containing_object: Buffer,
 
-        link_set_node: *std.LinkedList(?*Value.Fn).Node,
+        link_set_node: *std.TailQueue(?*Value.Fn).Node,
 
         /// Creates a Fn value with 1 ref
         /// Takes ownership of symbol_name
diff --git a/std/atomic/queue.zig b/std/atomic/queue.zig
index bf5700c51eebe58a70ac314c243b6dc84a783819..e8d03c4f13c3130623420835e3ad4eb72f60fa6f 100644
--- a/std/atomic/queue.zig
+++ b/std/atomic/queue.zig
@@ -14,7 +14,7 @@ pub fn Queue(comptime T: type) type {
         mutex: std.Mutex,
 
         pub const Self = @This();
-        pub const Node = std.LinkedList(T).Node;
+        pub const Node = std.TailQueue(T).Node;
 
         pub fn init() Self {
             return Self{
diff --git a/std/child_process.zig b/std/child_process.zig
index 2a2a294e9ba157753c55e2a16ace85483e28a3da..8e4c086d1d092179808a46ae58c5a03b2acbfde4 100644
--- a/std/child_process.zig
+++ b/std/child_process.zig
@@ -13,7 +13,7 @@ const BufMap = std.BufMap;
 const Buffer = std.Buffer;
 const builtin = @import("builtin");
 const Os = builtin.Os;
-const LinkedList = std.LinkedList;
+const TailQueue = std.TailQueue;
 const maxInt = std.math.maxInt;
 
 pub const ChildProcess = struct {
@@ -48,7 +48,7 @@ pub const ChildProcess = struct {
     pub cwd: ?[]const u8,
 
     err_pipe: if (os.windows.is_the_target) void else [2]os.fd_t,
-    llnode: if (os.windows.is_the_target) void else LinkedList(*ChildProcess).Node,
+    llnode: if (os.windows.is_the_target) void else TailQueue(*ChildProcess).Node,
 
     pub const SpawnError = error{OutOfMemory} || os.ExecveError || os.SetIdError ||
         os.ChangeCurDirError || windows.CreateProcessError;
@@ -388,7 +388,7 @@ pub const ChildProcess = struct {
 
         self.pid = pid;
         self.err_pipe = err_pipe;
-        self.llnode = LinkedList(*ChildProcess).Node.init(self);
+        self.llnode = TailQueue(*ChildProcess).Node.init(self);
         self.term = null;
 
         if (self.stdin_behavior == StdIo.Pipe) {
diff --git a/std/event/net.zig b/std/event/net.zig
index f4398196e3340202113ec1bd5bcf2ac6ec1c2f5b..413bf1432cbf4e5dd050788d51a83406ef1a9181 100644
--- a/std/event/net.zig
+++ b/std/event/net.zig
@@ -19,7 +19,7 @@ pub const Server = struct {
     waiting_for_emfile_node: PromiseNode,
     listen_resume_node: event.Loop.ResumeNode,
 
-    const PromiseNode = std.LinkedList(promise).Node;
+    const PromiseNode = std.TailQueue(promise).Node;
 
     pub fn init(loop: *Loop) Server {
         // TODO can't initialize handler coroutine here because we need well defined copy elision
diff --git a/std/heap.zig b/std/heap.zig
index 7d7774f4530b98c249ca1f6c3d74de8982263745..ba2b4c816c4ce0c3bc77d812f3ab52e1dbfb0a11 100644
--- a/std/heap.zig
+++ b/std/heap.zig
@@ -347,10 +347,10 @@ pub const ArenaAllocator = struct {
     pub allocator: Allocator,
 
     child_allocator: *Allocator,
-    buffer_list: std.LinkedList([]u8),
+    buffer_list: std.TailQueue([]u8),
     end_index: usize,
 
-    const BufNode = std.LinkedList([]u8).Node;
+    const BufNode = std.TailQueue([]u8).Node;
 
     pub fn init(child_allocator: *Allocator) ArenaAllocator {
         return ArenaAllocator{
@@ -359,7 +359,7 @@ pub const ArenaAllocator = struct {
                 .shrinkFn = shrink,
             },
             .child_allocator = child_allocator,
-            .buffer_list = std.LinkedList([]u8).init(),
+            .buffer_list = std.TailQueue([]u8).init(),
             .end_index = 0,
         };
     }
diff --git a/std/linked_list.zig b/std/linked_list.zig
index c4ad525913f528cf02564ac3b58c1c28489b867a..65fbd707f5cbb11a43ce29a50ca7e81fc0b85651 100644
--- a/std/linked_list.zig
+++ b/std/linked_list.zig
@@ -5,8 +5,13 @@ const testing = std.testing;
 const mem = std.mem;
 const Allocator = mem.Allocator;
 
-/// Generic doubly linked list.
-pub fn LinkedList(comptime T: type) type {
+/// A tail queue is headed by a pair of pointers, one to the head of the
+/// list and the other to the tail of the list. The elements are doubly
+/// linked so that an arbitrary element can be removed without a need to
+/// traverse the list. New elements can be added to the list before or
+/// after an existing element, at the head of the list, or at the end of
+/// the list. A tail queue may be traversed in either direction.
+pub fn TailQueue(comptime T: type) type {
     return struct {
         const Self = @This();
 
@@ -219,9 +224,9 @@ pub fn LinkedList(comptime T: type) type {
     };
 }
 
-test "basic linked list test" {
+test "basic TailQueue test" {
     const allocator = debug.global_allocator;
-    var list = LinkedList(u32).init();
+    var list = TailQueue(u32).init();
 
     var one = try list.createNode(1, allocator);
     var two = try list.createNode(2, allocator);
@@ -271,10 +276,10 @@ test "basic linked list test" {
     testing.expect(list.len == 2);
 }
 
-test "linked list concatenation" {
+test "TailQueue concatenation" {
     const allocator = debug.global_allocator;
-    var list1 = LinkedList(u32).init();
-    var list2 = LinkedList(u32).init();
+    var list1 = TailQueue(u32).init();
+    var list2 = TailQueue(u32).init();
 
     var one = try list1.createNode(1, allocator);
     defer list1.destroyNode(one, allocator);
diff --git a/std/std.zig b/std/std.zig
index a621af1e842be49c6bda3fcb5c9de469d0d84c56..d429ca8a21098100bc16f776afbae16a739242fd 100644
--- a/std/std.zig
+++ b/std/std.zig
@@ -7,7 +7,6 @@ pub const Buffer = @import("buffer.zig").Buffer;
 pub const BufferOutStream = @import("io.zig").BufferOutStream;
 pub const DynLib = @import("dynamic_library.zig").DynLib;
 pub const HashMap = @import("hash_map.zig").HashMap;
-pub const LinkedList = @import("linked_list.zig").LinkedList;
 pub const Mutex = @import("mutex.zig").Mutex;
 pub const PackedIntArrayEndian = @import("packed_int_array.zig").PackedIntArrayEndian;
 pub const PackedIntArray = @import("packed_int_array.zig").PackedIntArray;
@@ -18,6 +17,7 @@ pub const StaticallyInitializedMutex = @import("statically_initialized_mutex.zig
 pub const SegmentedList = @import("segmented_list.zig").SegmentedList;
 pub const SpinLock = @import("spinlock.zig").SpinLock;
 pub const ChildProcess = @import("child_process.zig").ChildProcess;
+pub const TailQueue = @import("linked_list.zig").TailQueue;
 pub const Thread = @import("thread.zig").Thread;
 
 pub const atomic = @import("atomic.zig");