diff --git a/src/tint/lang/core/ir/referenced_module_vars.h b/src/tint/lang/core/ir/referenced_module_vars.h
index 47204ea..bdf1532 100644
--- a/src/tint/lang/core/ir/referenced_module_vars.h
+++ b/src/tint/lang/core/ir/referenced_module_vars.h
@@ -30,6 +30,7 @@
 
 #include <functional>
 
+#include "src/tint/lang/core/ir/control_instruction.h"
 #include "src/tint/lang/core/ir/module.h"
 #include "src/tint/lang/core/ir/user_call.h"
 #include "src/tint/lang/core/ir/var.h"
diff --git a/src/tint/lang/core/ir/transform/BUILD.bazel b/src/tint/lang/core/ir/transform/BUILD.bazel
index d303af5..e82b9c7 100644
--- a/src/tint/lang/core/ir/transform/BUILD.bazel
+++ b/src/tint/lang/core/ir/transform/BUILD.bazel
@@ -58,6 +58,7 @@
     "rename_conflicts.cc",
     "robustness.cc",
     "shader_io.cc",
+    "single_entry_point.cc",
     "std140.cc",
     "value_to_let.cc",
     "vectorize_scalar_matrix_constructors.cc",
@@ -83,6 +84,7 @@
     "rename_conflicts.h",
     "robustness.h",
     "shader_io.h",
+    "single_entry_point.h",
     "std140.h",
     "value_to_let.h",
     "vectorize_scalar_matrix_constructors.h",
@@ -137,6 +139,7 @@
     "remove_terminator_args_test.cc",
     "rename_conflicts_test.cc",
     "robustness_test.cc",
+    "single_entry_point_test.cc",
     "std140_test.cc",
     "value_to_let_test.cc",
     "vectorize_scalar_matrix_constructors_test.cc",
diff --git a/src/tint/lang/core/ir/transform/BUILD.cmake b/src/tint/lang/core/ir/transform/BUILD.cmake
index 3d32225..5496c4b 100644
--- a/src/tint/lang/core/ir/transform/BUILD.cmake
+++ b/src/tint/lang/core/ir/transform/BUILD.cmake
@@ -77,6 +77,8 @@
   lang/core/ir/transform/robustness.h
   lang/core/ir/transform/shader_io.cc
   lang/core/ir/transform/shader_io.h
+  lang/core/ir/transform/single_entry_point.cc
+  lang/core/ir/transform/single_entry_point.h
   lang/core/ir/transform/std140.cc
   lang/core/ir/transform/std140.h
   lang/core/ir/transform/value_to_let.cc
@@ -138,6 +140,7 @@
   lang/core/ir/transform/remove_terminator_args_test.cc
   lang/core/ir/transform/rename_conflicts_test.cc
   lang/core/ir/transform/robustness_test.cc
+  lang/core/ir/transform/single_entry_point_test.cc
   lang/core/ir/transform/std140_test.cc
   lang/core/ir/transform/value_to_let_test.cc
   lang/core/ir/transform/vectorize_scalar_matrix_constructors_test.cc
diff --git a/src/tint/lang/core/ir/transform/BUILD.gn b/src/tint/lang/core/ir/transform/BUILD.gn
index 900e4da..d3cbca3 100644
--- a/src/tint/lang/core/ir/transform/BUILD.gn
+++ b/src/tint/lang/core/ir/transform/BUILD.gn
@@ -83,6 +83,8 @@
     "robustness.h",
     "shader_io.cc",
     "shader_io.h",
+    "single_entry_point.cc",
+    "single_entry_point.h",
     "std140.cc",
     "std140.h",
     "value_to_let.cc",
@@ -138,6 +140,7 @@
       "remove_terminator_args_test.cc",
       "rename_conflicts_test.cc",
       "robustness_test.cc",
+      "single_entry_point_test.cc",
       "std140_test.cc",
       "value_to_let_test.cc",
       "vectorize_scalar_matrix_constructors_test.cc",
diff --git a/src/tint/lang/core/ir/transform/single_entry_point.cc b/src/tint/lang/core/ir/transform/single_entry_point.cc
new file mode 100644
index 0000000..2282813
--- /dev/null
+++ b/src/tint/lang/core/ir/transform/single_entry_point.cc
@@ -0,0 +1,102 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/lang/core/ir/transform/single_entry_point.h"
+
+#include <utility>
+
+#include "src/tint/lang/core/ir/module.h"
+#include "src/tint/lang/core/ir/referenced_functions.h"
+#include "src/tint/lang/core/ir/referenced_module_vars.h"
+#include "src/tint/lang/core/ir/validator.h"
+
+namespace tint::core::ir::transform {
+
+namespace {
+
+Result<SuccessType> Run(ir::Module& ir, std::string_view entry_point_name) {
+    // Find the entry point.
+    ir::Function* entry_point = nullptr;
+    for (auto& func : ir.functions) {
+        if (func->Stage() == Function::PipelineStage::kUndefined) {
+            continue;
+        }
+        if (ir.NameOf(func).NameView() == entry_point_name) {
+            if (entry_point) {
+                TINT_ICE() << "multiple entry points named '" << entry_point_name << "' were found";
+            }
+            entry_point = func;
+        }
+    }
+    if (!entry_point) {
+        TINT_ICE() << "entry point '" << entry_point_name << "' not found";
+    }
+
+    // Remove unused functions.
+    ReferencedFunctions<Module> referenced_function_cache(ir);
+    auto& referenced_functions = referenced_function_cache.TransitiveReferences(entry_point);
+    for (uint32_t i = 0; i < ir.functions.Length();) {
+        auto func = ir.functions[i];
+        if (func == entry_point || referenced_functions.Contains(func)) {
+            i++;
+            continue;
+        }
+
+        func->Destroy();
+        ir.functions.Erase(i);
+    }
+
+    // Remove unused module-scope variables.
+    ReferencedModuleVars<Module> referenced_var_cache(ir);
+    auto& referenced_vars = referenced_var_cache.TransitiveReferences(entry_point);
+    for (auto* decl : *ir.root_block) {
+        // Assume that we only have var instructions for now, until override support is added.
+        auto* var = decl->As<Var>();
+        TINT_ASSERT(var);
+        if (!referenced_vars.Contains(var)) {
+            // There shouldn't be any remaining references to the variable.
+            // This will not always be the case once we have override support.
+            TINT_ASSERT(var->Result(0)->NumUsages() == 0);
+            var->Destroy();
+        }
+    }
+
+    return Success;
+}
+
+}  // namespace
+
+Result<SuccessType> SingleEntryPoint(Module& ir, std::string_view entry_point_name) {
+    auto result = ValidateAndDumpIfNeeded(ir, "SingleEntryPoint transform");
+    if (result != Success) {
+        return result.Failure();
+    }
+
+    return Run(ir, entry_point_name);
+}
+
+}  // namespace tint::core::ir::transform
diff --git a/src/tint/lang/core/ir/transform/single_entry_point.h b/src/tint/lang/core/ir/transform/single_entry_point.h
new file mode 100644
index 0000000..2ce152b
--- /dev/null
+++ b/src/tint/lang/core/ir/transform/single_entry_point.h
@@ -0,0 +1,49 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef SRC_TINT_LANG_CORE_IR_TRANSFORM_SINGLE_ENTRY_POINT_H_
+#define SRC_TINT_LANG_CORE_IR_TRANSFORM_SINGLE_ENTRY_POINT_H_
+
+#include "src/tint/utils/result/result.h"
+
+// Forward declarations.
+namespace tint::core::ir {
+class Module;
+}
+
+namespace tint::core::ir::transform {
+
+/// Strip a module down to a single entry point, removing any unused functions and module-scope
+/// declarations.
+/// @param module the module to transform
+/// @param entry_point_name the entry point name
+/// @returns success or failure
+Result<SuccessType> SingleEntryPoint(Module& module, std::string_view entry_point_name);
+
+}  // namespace tint::core::ir::transform
+
+#endif  // SRC_TINT_LANG_CORE_IR_TRANSFORM_SINGLE_ENTRY_POINT_H_
diff --git a/src/tint/lang/core/ir/transform/single_entry_point_test.cc b/src/tint/lang/core/ir/transform/single_entry_point_test.cc
new file mode 100644
index 0000000..d969f0a
--- /dev/null
+++ b/src/tint/lang/core/ir/transform/single_entry_point_test.cc
@@ -0,0 +1,473 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/lang/core/ir/transform/single_entry_point.h"
+
+#include <utility>
+
+#include "src/tint/lang/core/ir/transform/helper_test.h"
+
+using namespace tint::core::fluent_types;  // NOLINT
+
+namespace tint::core::ir::transform {
+namespace {
+
+class IR_SingleEntryPointTest : public TransformTest {
+  protected:
+    /// @returns a new entry point called @p name that references @p refs
+    Function* EntryPoint(const char* name, std::initializer_list<Value*> refs = {}) {
+        auto* func = Func(name, std::move(refs));
+        func->SetStage(Function::PipelineStage::kFragment);
+        return func;
+    }
+
+    /// @returns a new function called @p name that references @p refs
+    Function* Func(const char* name, std::initializer_list<Value*> refs = {}) {
+        auto* func = b.Function(name, ty.void_());
+        b.Append(func->Block(), [&] {
+            for (auto* ref : refs) {
+                if (auto* f = ref->As<Function>()) {
+                    b.Call(f);
+                } else {
+                    b.Let(ref->Type())->SetValue(ref);
+                }
+            }
+            b.Return(func);
+        });
+        return func;
+    }
+
+    /// @returns a new module-scope variable called @p name
+    InstructionResult* Var(const char* name) {
+        auto* var = b.Var<private_, i32>(name);
+        mod.root_block->Append(var);
+        return var->Result(0);
+    }
+};
+using IR_SingleEntryPointDeathTest = IR_SingleEntryPointTest;
+
+TEST_F(IR_SingleEntryPointTest, EntryPointNotFound) {
+    EntryPoint("main");
+
+    auto* src = R"(
+%main = @fragment func():void {
+  $B1: {
+    ret
+  }
+}
+)";
+
+    EXPECT_EQ(src, str());
+
+    EXPECT_DEATH_IF_SUPPORTED({ Run(SingleEntryPoint, "foo"); }, "internal compiler error");
+}
+
+TEST_F(IR_SingleEntryPointTest, MultipleEntryPointsMatch) {
+    EntryPoint("main");
+    EntryPoint("main");
+
+    auto* src = R"(
+%main = @fragment func():void {
+  $B1: {
+    ret
+  }
+}
+%main_1 = @fragment func():void {  # %main_1: 'main'
+  $B2: {
+    ret
+  }
+}
+)";
+
+    EXPECT_EQ(src, str());
+
+    EXPECT_DEATH_IF_SUPPORTED({ Run(SingleEntryPoint, "main"); }, "internal compiler error");
+}
+
+TEST_F(IR_SingleEntryPointTest, NoChangesNeeded) {
+    EntryPoint("main");
+
+    auto* src = R"(
+%main = @fragment func():void {
+  $B1: {
+    ret
+  }
+}
+)";
+
+    auto* expect = src;
+
+    EXPECT_EQ(src, str());
+
+    Run(SingleEntryPoint, "main");
+
+    EXPECT_EQ(expect, str());
+}
+
+TEST_F(IR_SingleEntryPointTest, TwoEntryPoints) {
+    EntryPoint("foo");
+    EntryPoint("bar");
+
+    auto* src = R"(
+%foo = @fragment func():void {
+  $B1: {
+    ret
+  }
+}
+%bar = @fragment func():void {
+  $B2: {
+    ret
+  }
+}
+)";
+
+    auto* expect = R"(
+%foo = @fragment func():void {
+  $B1: {
+    ret
+  }
+}
+)";
+
+    EXPECT_EQ(src, str());
+
+    Run(SingleEntryPoint, "foo");
+
+    EXPECT_EQ(expect, str());
+}
+
+TEST_F(IR_SingleEntryPointTest, DirectFunctionCalls) {
+    auto* f1 = Func("f1");
+    auto* f2 = Func("f2");
+    auto* f3 = Func("f3");
+
+    EntryPoint("foo", {f1, f2});
+    EntryPoint("bar", {f3});
+
+    auto* src = R"(
+%f1 = func():void {
+  $B1: {
+    ret
+  }
+}
+%f2 = func():void {
+  $B2: {
+    ret
+  }
+}
+%f3 = func():void {
+  $B3: {
+    ret
+  }
+}
+%foo = @fragment func():void {
+  $B4: {
+    %5:void = call %f1
+    %6:void = call %f2
+    ret
+  }
+}
+%bar = @fragment func():void {
+  $B5: {
+    %8:void = call %f3
+    ret
+  }
+}
+)";
+
+    auto* expect = R"(
+%f1 = func():void {
+  $B1: {
+    ret
+  }
+}
+%f2 = func():void {
+  $B2: {
+    ret
+  }
+}
+%foo = @fragment func():void {
+  $B3: {
+    %4:void = call %f1
+    %5:void = call %f2
+    ret
+  }
+}
+)";
+
+    EXPECT_EQ(src, str());
+
+    Run(SingleEntryPoint, "foo");
+
+    EXPECT_EQ(expect, str());
+}
+
+TEST_F(IR_SingleEntryPointTest, DirectVariables) {
+    auto* v1 = Var("v1");
+    auto* v2 = Var("v2");
+    auto* v3 = Var("v3");
+
+    EntryPoint("foo", {v1, v2});
+    EntryPoint("bar", {v3});
+
+    auto* src = R"(
+$B1: {  # root
+  %v1:ptr<private, i32, read_write> = var
+  %v2:ptr<private, i32, read_write> = var
+  %v3:ptr<private, i32, read_write> = var
+}
+
+%foo = @fragment func():void {
+  $B2: {
+    %5:ptr<private, i32, read_write> = let %v1
+    %6:ptr<private, i32, read_write> = let %v2
+    ret
+  }
+}
+%bar = @fragment func():void {
+  $B3: {
+    %8:ptr<private, i32, read_write> = let %v3
+    ret
+  }
+}
+)";
+
+    auto* expect = R"(
+$B1: {  # root
+  %v1:ptr<private, i32, read_write> = var
+  %v2:ptr<private, i32, read_write> = var
+}
+
+%foo = @fragment func():void {
+  $B2: {
+    %4:ptr<private, i32, read_write> = let %v1
+    %5:ptr<private, i32, read_write> = let %v2
+    ret
+  }
+}
+)";
+
+    EXPECT_EQ(src, str());
+
+    Run(SingleEntryPoint, "foo");
+
+    EXPECT_EQ(expect, str());
+}
+
+TEST_F(IR_SingleEntryPointTest, TransitiveReferences) {
+    Var("unused_var");
+    Func("unused_func");
+
+    auto* v1 = Var("v1");
+    auto* v2 = Var("v2");
+    auto* v3 = Var("v3");
+
+    auto* f1 = Func("f1", {v2, v3});
+    auto* f2 = Func("f2", {f1});
+    auto* f3 = Func("f3", {v1, f2});
+
+    EntryPoint("foo", {f3});
+
+    auto* src = R"(
+$B1: {  # root
+  %unused_var:ptr<private, i32, read_write> = var
+  %v1:ptr<private, i32, read_write> = var
+  %v2:ptr<private, i32, read_write> = var
+  %v3:ptr<private, i32, read_write> = var
+}
+
+%unused_func = func():void {
+  $B2: {
+    ret
+  }
+}
+%f1 = func():void {
+  $B3: {
+    %7:ptr<private, i32, read_write> = let %v2
+    %8:ptr<private, i32, read_write> = let %v3
+    ret
+  }
+}
+%f2 = func():void {
+  $B4: {
+    %10:void = call %f1
+    ret
+  }
+}
+%f3 = func():void {
+  $B5: {
+    %12:ptr<private, i32, read_write> = let %v1
+    %13:void = call %f2
+    ret
+  }
+}
+%foo = @fragment func():void {
+  $B6: {
+    %15:void = call %f3
+    ret
+  }
+}
+)";
+
+    auto* expect = R"(
+$B1: {  # root
+  %v1:ptr<private, i32, read_write> = var
+  %v2:ptr<private, i32, read_write> = var
+  %v3:ptr<private, i32, read_write> = var
+}
+
+%f1 = func():void {
+  $B2: {
+    %5:ptr<private, i32, read_write> = let %v2
+    %6:ptr<private, i32, read_write> = let %v3
+    ret
+  }
+}
+%f2 = func():void {
+  $B3: {
+    %8:void = call %f1
+    ret
+  }
+}
+%f3 = func():void {
+  $B4: {
+    %10:ptr<private, i32, read_write> = let %v1
+    %11:void = call %f2
+    ret
+  }
+}
+%foo = @fragment func():void {
+  $B5: {
+    %13:void = call %f3
+    ret
+  }
+}
+)";
+
+    EXPECT_EQ(src, str());
+
+    Run(SingleEntryPoint, "foo");
+
+    EXPECT_EQ(expect, str());
+}
+
+TEST_F(IR_SingleEntryPointTest, RemoveMultipleFunctions) {
+    auto* f1 = Func("f1");
+    auto* f2 = Func("f2");
+    auto* f3 = Func("f3");
+    auto* f4 = Func("f4");
+    auto* f5 = Func("f5");
+    auto* f6 = Func("f6");
+    auto* f7 = Func("f7");
+
+    EntryPoint("foo", {f1, f5});
+    EntryPoint("bar", {f2, f3, f4, f6, f7});
+
+    auto* src = R"(
+%f1 = func():void {
+  $B1: {
+    ret
+  }
+}
+%f2 = func():void {
+  $B2: {
+    ret
+  }
+}
+%f3 = func():void {
+  $B3: {
+    ret
+  }
+}
+%f4 = func():void {
+  $B4: {
+    ret
+  }
+}
+%f5 = func():void {
+  $B5: {
+    ret
+  }
+}
+%f6 = func():void {
+  $B6: {
+    ret
+  }
+}
+%f7 = func():void {
+  $B7: {
+    ret
+  }
+}
+%foo = @fragment func():void {
+  $B8: {
+    %9:void = call %f1
+    %10:void = call %f5
+    ret
+  }
+}
+%bar = @fragment func():void {
+  $B9: {
+    %12:void = call %f2
+    %13:void = call %f3
+    %14:void = call %f4
+    %15:void = call %f6
+    %16:void = call %f7
+    ret
+  }
+}
+)";
+
+    auto* expect = R"(
+%f1 = func():void {
+  $B1: {
+    ret
+  }
+}
+%f5 = func():void {
+  $B2: {
+    ret
+  }
+}
+%foo = @fragment func():void {
+  $B3: {
+    %4:void = call %f1
+    %5:void = call %f5
+    ret
+  }
+}
+)";
+
+    EXPECT_EQ(src, str());
+
+    Run(SingleEntryPoint, "foo");
+
+    EXPECT_EQ(expect, str());
+}
+
+}  // namespace
+}  // namespace tint::core::ir::transform