diff --git a/CHANGELOG.md b/CHANGELOG.md
index 27d5e10d859..d4681179e34 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,3 +7,4 @@
 - Add emulator support to firestore MCP tools. (#8700)
 - Increased npm timeout for web frameworks to 60s. (#8702)
 - Fallback to reading web framework dependencies version directly from node_modules package.json when the npm timeout is reached. (#8702)
+- Added support for loading TypeScript functions using tsx in the Functions Emulator. (#8663)
diff --git a/src/deploy/functions/runtimes/index.ts b/src/deploy/functions/runtimes/index.ts
index cb3aa66d1ab..207495d969e 100644
--- a/src/deploy/functions/runtimes/index.ts
+++ b/src/deploy/functions/runtimes/index.ts
@@ -67,6 +67,8 @@ export interface DelegateContext {
   // Absolute path of the source directory.
   sourceDir: string;
   runtime?: supported.Runtime;
+  // Whether this delegate is being created for the emulator
+  isEmulator?: boolean;
 }
 
 type Factory = (context: DelegateContext) => Promise<RuntimeDelegate | undefined>;
diff --git a/src/deploy/functions/runtimes/node/index.ts b/src/deploy/functions/runtimes/node/index.ts
index 2649e59821e..8414a7451f0 100644
--- a/src/deploy/functions/runtimes/node/index.ts
+++ b/src/deploy/functions/runtimes/node/index.ts
@@ -25,6 +25,33 @@ import * as versioning from "./versioning";
 import * as parseTriggers from "./parseTriggers";
 import { fileExistsSync } from "../../../../fsutils";
 
+/**
+ * Get the TypeScript source entry point for a functions directory.
+ * Used by the emulator to load TypeScript directly with tsx.
+ */
+export function getTypeScriptEntryPoint(functionsDir: string): string | null {
+  const tsconfigPath = path.join(functionsDir, "tsconfig.json");
+  if (!fileExistsSync(tsconfigPath)) {
+    return null;
+  }
+
+  try {
+    const mainPath = require.resolve(functionsDir);
+    // Transform compiled JS path to TypeScript source
+    // e.g., /path/to/project/lib/index.js -> /path/to/project/src/index.ts
+    const tsSourcePath = mainPath.replace(/\/lib\//, "/src/").replace(/\.js$/, ".ts");
+
+    if (fileExistsSync(tsSourcePath)) {
+      return tsSourcePath;
+    }
+  } catch (e) {
+    logger.debug("Failed to resolve TS entrypoint", e);
+    // Fail-safe and fallback to assuming JS codebase.
+  }
+
+  return null;
+}
+
 // The versions of the Firebase Functions SDK that added support for the container contract.
 const MIN_FUNCTIONS_SDK_VERSION = "3.20.0";
 
@@ -54,7 +81,13 @@ export async function tryCreateDelegate(context: DelegateContext): Promise<Deleg
     throw new FirebaseError(`Unexpected runtime ${runtime}`);
   }
 
-  return new Delegate(context.projectId, context.projectDir, context.sourceDir, runtime);
+  return new Delegate(
+    context.projectId,
+    context.projectDir,
+    context.sourceDir,
+    runtime,
+    context.isEmulator,
+  );
 }
 
 // TODO(inlined): Consider moving contents in parseRuntimeAndValidateSDK and validate around.
@@ -69,6 +102,7 @@ export class Delegate {
     private readonly projectDir: string,
     private readonly sourceDir: string,
     public readonly runtime: supported.Runtime,
+    private readonly isEmulator: boolean = false,
   ) {}
 
   // Using a caching interface because we (may/will) eventually depend on the SDK version
@@ -90,6 +124,21 @@ export class Delegate {
     return this._bin;
   }
 
+  private isTypeScriptProject(): boolean {
+    const tsconfigPath = path.join(this.sourceDir, "tsconfig.json");
+    return fileExistsSync(tsconfigPath);
+  }
+
+  private getTsxPath(): string | null {
+    try {
+      const tsxPath = require.resolve("tsx/cli", { paths: [this.sourceDir] });
+      return tsxPath;
+    } catch (e) {
+      // tsx not found. fail-safe
+    }
+    return null;
+  }
+
   getNodeBinary(): string {
     const requestedVersion = semver.coerce(this.runtime);
     if (!requestedVersion) {
@@ -99,6 +148,25 @@ export class Delegate {
     }
     const hostVersion = process.versions.node;
 
+    // Check if this is a TypeScript project and tsx is available (only in emulator)
+    if (this.isEmulator && this.isTypeScriptProject()) {
+      const tsxPath = this.getTsxPath();
+      if (tsxPath) {
+        logLabeledSuccess(
+          "functions",
+          "TypeScript project detected. Using tsx for automatic TypeScript compilation.",
+        );
+        return tsxPath;
+      } else {
+        logLabeledWarning(
+          "functions",
+          "TypeScript project detected but tsx is not installed. " +
+            "Consider running 'npm install --save-dev tsx' for automatic TypeScript compilation. " +
+            "Falling back to standard node runtime.",
+        );
+      }
+    }
+
     const localNodePath = path.join(this.sourceDir, "node_modules/node");
     const localNodeVersion = versioning.findModuleVersion("node", localNodePath);
 
diff --git a/src/emulator/functionsEmulator.ts b/src/emulator/functionsEmulator.ts
index c8f69de5343..7bb137983dc 100644
--- a/src/emulator/functionsEmulator.ts
+++ b/src/emulator/functionsEmulator.ts
@@ -54,6 +54,7 @@ import { functionIdsAreValid } from "../deploy/functions/validate";
 import { Extension, ExtensionSpec, ExtensionVersion } from "../extensions/types";
 import { accessSecretVersion } from "../gcp/secretManager";
 import * as runtimes from "../deploy/functions/runtimes";
+import * as node from "../deploy/functions/runtimes/node";
 import * as backend from "../deploy/functions/backend";
 import * as functionsEnv from "../functions/env";
 import { AUTH_BLOCKING_EVENTS, BEFORE_CREATE_EVENT } from "../functions/events/v1";
@@ -529,6 +530,7 @@ export class FunctionsEmulator implements EmulatorInstance {
         projectDir: this.args.projectDir,
         sourceDir: emulatableBackend.functionsDir,
         runtime: emulatableBackend.runtime,
+        isEmulator: true,
       };
       const runtimeDelegate = await runtimes.getRuntimeDelegate(runtimeDelegateContext);
       logger.debug(`Validating ${runtimeDelegate.language} source`);
@@ -1600,6 +1602,17 @@ export class FunctionsEmulator implements EmulatorInstance {
     }
 
     const socketPath = getTemporarySocketPath();
+
+    // Check if we're using tsx and get TypeScript entry point
+    let overrideFunctionSource: string | undefined;
+    if (backend.bin && backend.bin.includes("tsx")) {
+      const tsEntryPoint = node.getTypeScriptEntryPoint(backend.functionsDir);
+      if (tsEntryPoint) {
+        overrideFunctionSource = tsEntryPoint;
+        this.logger.logLabeled("DEBUG", "functions", `Using TypeScript source in ${tsEntryPoint}`);
+      }
+    }
+
     const childProcess = spawn(bin, args, {
       cwd: backend.functionsDir,
       env: {
@@ -1608,6 +1621,8 @@ export class FunctionsEmulator implements EmulatorInstance {
         ...process.env,
         ...envs,
         PORT: socketPath,
+        // Override the entry point if we have any
+        ...(overrideFunctionSource ? { FUNCTIONS_SOURCE: overrideFunctionSource } : {}),
       },
       stdio: ["pipe", "pipe", "pipe", "ipc"],
     });
diff --git a/src/emulator/functionsEmulatorRuntime.ts b/src/emulator/functionsEmulatorRuntime.ts
index 8720c3b08ab..a6a2a4fc1ab 100644
--- a/src/emulator/functionsEmulatorRuntime.ts
+++ b/src/emulator/functionsEmulatorRuntime.ts
@@ -906,15 +906,24 @@ async function initializeRuntime(): Promise<void> {
 
 async function loadTriggers(): Promise<any> {
   let triggerModule;
+
+  // Check if we have an override entry point (e.g., for TypeScript with tsx)
+  const entryPoint = process.env.FUNCTIONS_SOURCE;
+
   try {
-    triggerModule = require(process.cwd());
+    if (entryPoint) {
+      logDebug(`Loading functions from specified entry point: ${entryPoint}`);
+      triggerModule = require(entryPoint);
+    } else {
+      triggerModule = require(process.cwd());
+    }
   } catch (err: any) {
     if (err.code !== "ERR_REQUIRE_ESM") {
       // Try to run diagnostics to see what could've gone wrong before rethrowing the error.
       await moduleResolutionDetective(err);
       throw err;
     }
-    const modulePath = require.resolve(process.cwd());
+    const modulePath = entryPoint || require.resolve(process.cwd());
     // Resolve module path to file:// URL. Required for windows support.
     const moduleURL = pathToFileURL(modulePath).href;
     triggerModule = await dynamicImport(moduleURL);
diff --git a/templates/init/functions/typescript/package.lint.json b/templates/init/functions/typescript/package.lint.json
index c2d4f5493e6..57deecb2036 100644
--- a/templates/init/functions/typescript/package.lint.json
+++ b/templates/init/functions/typescript/package.lint.json
@@ -25,7 +25,8 @@
     "eslint-config-google": "^0.14.0",
     "eslint-plugin-import": "^2.25.4",
     "firebase-functions-test": "^3.1.0",
-    "typescript": "^5.7.3"
+    "typescript": "^5.7.3",
+    "tsx": "^4.19.4"
   },
   "private": true
 }
diff --git a/templates/init/functions/typescript/package.nolint.json b/templates/init/functions/typescript/package.nolint.json
index 066161c31cd..5ce934823b2 100644
--- a/templates/init/functions/typescript/package.nolint.json
+++ b/templates/init/functions/typescript/package.nolint.json
@@ -19,7 +19,8 @@
   },
   "devDependencies": {
     "typescript": "^5.7.3",
-    "firebase-functions-test": "^3.1.0"
+    "firebase-functions-test": "^3.1.0",
+    "tsx": "^4.19.4"
   },
   "private": true
 }