@@ -235,6 +235,21 @@ what the application does. Detection is cached per extension, so a later `Initia
 that an earlier call left out still finds it. Hexa's ImNodes and ImPlot bindings have no
 `BeginFrame`, so their `Is...Available` is answered by `CreateContext`.
 
+`ImGuiApp.EnableExtensions(ImGuiAppExtensions)` turns extensions on after launch, for an
+application that launches with `None` and wants ImNodes the first time a node editor opens. It goes
+through `ImGuiExtensionManager.Enable`, which **adds** to `Enabled` where `Initialize` replaces it,
+so an extension already on keeps its context; it probes, hands over the ImGui context and creates
+the dark-styled context exactly as launch does, and is idempotent. It returns which of the requested
+extensions are ready (ImGuizmo found; ImNodes and ImPlot with a context). Call it on the render
+thread, between frames or inside `OnRender` before the extension is drawn with; it throws before
+launch, where `ImGuiAppConfig.Extensions` is the setting and launch would replace anything enabled
+earlier. One trap: ImGuizmo draws into the window its `BeginFrame` opens, and inside a frame the
+per-frame `BeginFrame` has already run, so `Enable` begins ImGuizmo itself when the ImGui context is
+`WithinFrameScope`. Without that, `Manipulate` in the same frame segfaults (verified by
+`EnableExtensionsTests`). ImNodes and ImPlot have no `BeginFrame` and need nothing extra. The
+harness shares its context the same way the controller does, so it works there unchanged;
+`tests/ImGui.App.Testing.Tests/EnableExtensionsTests.cs` drives it through real frames.
+
 ### Built-in menus
 
 `ImGuiApp.RenderAppMenu` appends an Accessibility menu (UI scale) and a Debug menu (ImGui demo,
 
@@ -101,6 +101,10 @@ application gets: ImGuizmo, ImNodes and ImPlot are detected, handed the ImGui co
 own contexts, and ticked once per frame. An application that draws with any of them renders under
 the harness rather than faulting inside native code.
 
+`ImGuiAppConfig.Extensions` is honoured, and `ImGuiApp.EnableExtensions` works mid-run exactly as it
+does in the application: a harness started with `ImGuiAppExtensions.None` can enable ImNodes between
+steps, or inside `OnRender` before the first node editor draws, and draw with it in that frame.
+
 `ImGuiAppConfig.EnableDocking` is honored too, and applied before the first frame, which is the only
 point ImGui accepts it. A configuration that sets it can therefore use
 `ImGuiWidgets.DrawDeferredDocked()` in a test exactly as it does in the application.
 
@@ -907,6 +907,48 @@ public static bool TryGetRenderer3D([NotNullWhen(true)] out IRenderer3D? rendere
 		return renderer3D is not null;
 	}
 
+	/// <summary>
+	/// Turns on ImGui extensions after launch, adding them to those
+	/// <see cref="ImGuiAppConfig.Extensions"/> already set up.
+	/// </summary>
+	/// <remarks>
+	/// <para>
+	/// This is for an application that launches with fewer extensions than it may eventually draw
+	/// with, to keep their start-up cost off the launch path: launch with
+	/// <see cref="ImGuiAppExtensions.None"/>, then enable <see cref="ImGuiAppExtensions.ImNodes"/>
+	/// the first time a node editor opens. Each extension is set up exactly as it would have been at
+	/// launch — probed, handed the ImGui context, and for ImNodes and ImPlot given a context of its
+	/// own with the dark style — and extensions already on are left as they are.
+	/// </para>
+	/// <para>
+	/// Call it on the render thread, between frames or inside <see cref="ImGuiAppConfig.OnRender"/>
+	/// before the extension is drawn with. It is idempotent, so calling it every time a window opens
+	/// is fine. It works the same under <c>ImGuiAppHarness</c>, which shares the ImGui context the
+	/// same way the application does.
+	/// </para>
+	/// </remarks>
+	/// <param name="extensions">The extensions to turn on.</param>
+	/// <returns>
+	/// Which of <paramref name="extensions"/> are ready to draw with. One asked for and missing from
+	/// the result is not referenced by the application, and drawing with it faults in native code.
+	/// <see cref="ImGuiExtensionManager.IsImNodesContextCreated"/> and its siblings answer the same
+	/// question later.
+	/// </returns>
+	/// <exception cref="InvalidOperationException">
+	/// No application or harness has shared its ImGui context yet. Before launch, set
+	/// <see cref="ImGuiAppConfig.Extensions"/> instead, which launch would otherwise replace.
+	/// </exception>
+	public static ImGuiAppExtensions EnableExtensions(ImGuiAppExtensions extensions)
+	{
+		if (!ImGuiExtensionManager.IsImGuiContextShared)
+		{
+			throw new InvalidOperationException(
+				"No ImGui context has been shared with the extensions yet. Call EnableExtensions after launch, or set ImGuiAppConfig.Extensions before it.");
+		}
+
+		return ImGuiExtensionManager.Enable(extensions);
+	}
+
 	/// <summary>
 	/// Releases the state established by <see cref="BeginExternalFrameSession()"/>.
 	/// </summary>
 
@@ -296,6 +296,11 @@ public class ImGuiAppConfig
 	/// <para>
 	/// <see cref="AutoDiscoverExtensions"/> set to false overrides this and sets up none.
 	/// </para>
+	/// <para>
+	/// An extension left out here can still be turned on after launch with
+	/// <c>ImGuiApp.EnableExtensions</c>, which adds to this set, so an application can launch with
+	/// <see cref="ImGuiAppExtensions.None"/> and enable ImNodes the first time a node editor opens.
+	/// </para>
 	/// </summary>
 	public ImGuiAppExtensions Extensions { get; init; } = ImGuiAppExtensions.All;
 
 
@@ -33,9 +33,6 @@ public static class ImGuiExtensionManager
 	private static object? nodesContext;
 	private static object? plotContext;
 
-	// Track whether the ImGui context has been shared with extensions
-	private static bool imGuiContextSet;
-
 	// Extensions whose assembly has been probed, so each is loaded and reflected over at most once
 	private static ImGuiAppExtensions probed;
 
@@ -58,8 +55,102 @@ public static class ImGuiExtensionManager
 	public static void Initialize(ImGuiAppExtensions extensions)
 	{
 		Enabled = extensions & ImGuiAppExtensions.All;
+		Probe(Enabled);
+	}
+
+	/// <summary>
+	/// Turns on the given extensions in addition to those already enabled, after launch. Unlike
+	/// <see cref="Initialize(ImGuiAppExtensions)"/>, which replaces the enabled set, this only adds
+	/// to it, so an extension that is already on keeps its context and its state.
+	/// </summary>
+	/// <remarks>
+	/// <para>
+	/// Each newly enabled extension is set up exactly as it is at launch: its assembly is probed if
+	/// it has not been, it is handed the ImGui context when <see cref="SetImGuiContext(ImGuiContextPtr?)"/>
+	/// has already run, and ImNodes and ImPlot are given a context of their own with the dark
+	/// style. ImGuizmo, which needs a <c>BeginFrame</c> every frame, gets one at once when this is
+	/// called inside a frame, so it can be drawn with in the same frame; <see cref="BeginFrame"/>
+	/// covers it from the next frame on.
+	/// </para>
+	/// <para>
+	/// Call it on the render thread, between frames or inside <c>OnRender</c> before the extension
+	/// is drawn with. Enabling an extension that is already on does nothing.
+	/// </para>
+	/// </remarks>
+	/// <param name="extensions">The extensions to turn on.</param>
+	/// <returns>
+	/// Which of <paramref name="extensions"/> are ready to draw with: ImGuizmo when its assembly was
+	/// found, ImNodes and ImPlot when their context exists. Before the ImGui context has been shared,
+	/// no context can exist yet, so ImNodes and ImPlot are reported when their assembly was found.
+	/// An extension asked for and missing from the result is not referenced, and drawing with it
+	/// faults in native code.
+	/// </returns>
+	public static ImGuiAppExtensions Enable(ImGuiAppExtensions extensions)
+	{
+		ImGuiAppExtensions requested = extensions & ImGuiAppExtensions.All;
+		ImGuiAppExtensions added = requested & ~Enabled;
+
+		if (added != ImGuiAppExtensions.None)
+		{
+			Enabled |= added;
+			Probe(added);
+
+			// Before the context is shared, launch will set these up along with everything else.
+			if (IsImGuiContextShared)
+			{
+				ImGuiContextPtr context = ImGui.GetCurrentContext();
+				SetImGuiContextFor(added, context);
+				CreateExtensionContexts();
+
+				// ImGuizmo draws into a window its BeginFrame opens; inside a frame that has already
+				// begun, BeginFrame has passed it by, so it is begun here instead.
+				if (added.HasFlag(ImGuiAppExtensions.ImGuizmo) && context.WithinFrameScope)
+				{
+					BeginFrameFor(ImGuiAppExtensions.ImGuizmo);
+				}
+			}
+		}
+
+		return Ready(requested);
+	}
+
+	/// <summary>
+	/// Gets which of the given extensions are ready to draw with. See <see cref="Enable(ImGuiAppExtensions)"/>.
+	/// </summary>
+	private static ImGuiAppExtensions Ready(ImGuiAppExtensions extensions)
+	{
+		ImGuiAppExtensions ready = ImGuiAppExtensions.None;
+
+		if (IsImGuizmoAvailable)
+		{
+			ready |= ImGuiAppExtensions.ImGuizmo;
+		}
+
+		if (IsImGuiContextShared ? IsImNodesContextCreated : IsImNodesAvailable)
+		{
+			ready |= ImGuiAppExtensions.ImNodes;
+		}
+
+		if (IsImGuiContextShared ? IsImPlotContextCreated : IsImPlotAvailable)
+		{
+			ready |= ImGuiAppExtensions.ImPlot;
+		}
+
+		return ready & extensions;
+	}
 
-		ImGuiAppExtensions toProbe = Enabled & ~probed;
+	/// <summary>
+	/// Gets whether <see cref="SetImGuiContext(ImGuiContextPtr?)"/> has run since the last
+	/// <see cref="Cleanup"/>, which is what a launched application or a started harness has done.
+	/// </summary>
+	internal static bool IsImGuiContextShared { get; private set; }
+
+	/// <summary>
+	/// Loads and reflects over each of the given extensions that has not been probed already.
+	/// </summary>
+	private static void Probe(ImGuiAppExtensions extensions)
+	{
+		ImGuiAppExtensions toProbe = extensions & ~probed;
 		probed |= toProbe;
 
 		if (toProbe.HasFlag(ImGuiAppExtensions.ImGuizmo))
@@ -213,15 +304,25 @@ private static void InitializeImPlot()
 	public static void BeginFrame()
 	{
 		// Guard: extension BeginFrame calls require a valid ImGui context
-		if (!imGuiContextSet)
+		if (!IsImGuiContextShared)
 		{
 			return;
 		}
 
+		BeginFrameFor(Enabled);
+	}
+
+	/// <summary>
+	/// Calls BeginFrame for each of the given extensions that is enabled and has one.
+	/// </summary>
+	private static void BeginFrameFor(ImGuiAppExtensions extensions)
+	{
+		ImGuiAppExtensions toBegin = extensions & Enabled;
+
 		// Call ImGuizmo.BeginFrame() if available
 		try
 		{
-			if (IsEnabled(ImGuiAppExtensions.ImGuizmo))
+			if (toBegin.HasFlag(ImGuiAppExtensions.ImGuizmo))
 			{
 				imGuizmoBeginFrame?.Invoke(null, null);
 			}
@@ -234,7 +335,7 @@ public static void BeginFrame()
 		// Call ImNodes.BeginFrame() if available
 		try
 		{
-			if (IsEnabled(ImGuiAppExtensions.ImNodes))
+			if (toBegin.HasFlag(ImGuiAppExtensions.ImNodes))
 			{
 				imNodesBeginFrame?.Invoke(null, null);
 			}
@@ -247,7 +348,7 @@ public static void BeginFrame()
 		// Call ImPlot.BeginFrame() if available
 		try
 		{
-			if (IsEnabled(ImGuiAppExtensions.ImPlot))
+			if (toBegin.HasFlag(ImGuiAppExtensions.ImPlot))
 			{
 				imPlotBeginFrame?.Invoke(null, null);
 			}
@@ -265,12 +366,21 @@ public static void BeginFrame()
 	public static void SetImGuiContext(ImGuiContextPtr? context = null)
 	{
 		// Use current context if none provided
-		ImGuiContextPtr contextToSet = context ?? ImGui.GetCurrentContext();
+		SetImGuiContextFor(Enabled, context ?? ImGui.GetCurrentContext());
+		IsImGuiContextShared = true;
+	}
+
+	/// <summary>
+	/// Hands the ImGui context to each of the given extensions that is enabled.
+	/// </summary>
+	private static void SetImGuiContextFor(ImGuiAppExtensions extensions, ImGuiContextPtr contextToSet)
+	{
+		ImGuiAppExtensions toSet = extensions & Enabled;
 
 		// Set context for ImGuizmo if available
 		try
 		{
-			if (IsEnabled(ImGuiAppExtensions.ImGuizmo))
+			if (toSet.HasFlag(ImGuiAppExtensions.ImGuizmo))
 			{
 				imGuizmoSetImGuiContext?.Invoke(null, [contextToSet]);
 			}
@@ -283,7 +393,7 @@ public static void SetImGuiContext(ImGuiContextPtr? context = null)
 		// Set context for ImNodes if available
 		try
 		{
-			if (IsEnabled(ImGuiAppExtensions.ImNodes))
+			if (toSet.HasFlag(ImGuiAppExtensions.ImNodes))
 			{
 				imNodesSetImGuiContext?.Invoke(null, [contextToSet]);
 			}
@@ -296,7 +406,7 @@ public static void SetImGuiContext(ImGuiContextPtr? context = null)
 		// Set context for ImPlot if available
 		try
 		{
-			if (IsEnabled(ImGuiAppExtensions.ImPlot))
+			if (toSet.HasFlag(ImGuiAppExtensions.ImPlot))
 			{
 				imPlotSetImGuiContext?.Invoke(null, [contextToSet]);
 			}
@@ -305,8 +415,6 @@ public static void SetImGuiContext(ImGuiContextPtr? context = null)
 		{
 			DebugLogger.Log($"ImGuiExtensionManager: Error calling ImPlot.SetImGuiContext(): {ex.InnerException?.Message ?? ex.Message}");
 		}
-
-		imGuiContextSet = true;
 	}
 
 	/// <summary>
@@ -424,7 +532,7 @@ public static void Cleanup()
 			}
 		}
 
-		imGuiContextSet = false;
+		IsImGuiContextShared = false;
 	}
 
 	/// <summary>
 
@@ -509,6 +509,7 @@ The main entry point for creating and managing ImGui applications.
 | `EmsToPx` | `float ems` | `int` | Converts a value in ems to pixels based on current font size |
 | `PtsToPx` | `int pts` | `int` | Converts a value in points to pixels based on current scale factor |
 | `UseImageBytes` | `ImagePixels image, Action<byte[]> action` | `void` | Executes an action with temporary access to image bytes using pooled memory |
+| `EnableExtensions` | `ImGuiAppExtensions extensions` | `ImGuiAppExtensions` | Turns on ImGuizmo, ImNodes or ImPlot after launch, adding to those `Extensions` set up; returns which of them are ready to draw with. Call on the render thread, between frames or in `OnRender` before drawing with the extension. Idempotent |
 
 ### `ImGuiAppConfig` Class
 
@@ -526,6 +527,7 @@ Configuration for the ImGui application.
 | `Fonts` | `Dictionary<string, byte[]>` | `[]` | Font name to font data mapping |
 | `EnableUnicodeSupport` | `bool` | `true` | Whether to enable Unicode and emoji support |
 | `SaveIniSettings` | `bool` | `true` | Whether ImGui should save window settings to imgui.ini |
+| `Extensions` | `ImGuiAppExtensions` | `All` | Which of ImGuizmo, ImNodes and ImPlot are set up at launch. One left out costs nothing at startup and can be turned on later with `ImGuiApp.EnableExtensions` |
 | `PerformanceSettings` | `ImGuiAppPerformanceSettings` | `new()` | Performance settings for throttled rendering |
 | `OnStart` | `Action` | `() => { }` | Called when the application starts |
 | `FrameWrapperFactory` | `Func<ScopedAction?>` | `() => null` | Factory for creating frame wrappers |