@@ -755,6 +755,21 @@ describe("ns:swift", function () {
         });
     });
 
+    describe("SwiftUI views", function () {
+        it("hosts a view in a UIHostingController", function () {
+            var badge = new SwiftDemo.Badge("Inbox", 3);
+            var controller = badge.hostingController();
+            expect(controller instanceof UIViewController).toBe(true);
+            expect(controller.view instanceof UIView).toBe(true);
+            var size = controller.view.sizeThatFits(CGSizeMake(1000, 1000));
+            expect(size.width).toBeGreaterThan(0);
+            expect(size.height).toBeGreaterThan(0);
+            // The struct is copied in: later changes do not reach the host.
+            badge.count = 4;
+            expect(badge.hostingController()).not.toBe(controller);
+        });
+    });
+
     describe("Objective-C objects", function () {
         it("passes NativeScript's Objective-C wrappers", function () {
             var view = UIView.new();
 
@@ -205,6 +205,24 @@ Protocols with associated types, `Self` requirements, static or `async`
 requirements, initializers, or more than one refined module protocol stay
 type-only.
 
+## SwiftUI views
+
+A bridged struct that conforms to SwiftUI's `View` gains
+`hostingController()`, which returns a `UIHostingController` showing a copy
+of the view, as an ordinary NativeScript `UIViewController` (main thread
+only):
+
+```ts
+const controller = new Badge("Inbox", 3).hostingController();
+```
+
+To place it in a NativeScript layout, return `controller.view` from a
+custom view's `createNativeView()` and add the controller as a child of the
+page's view controller (`addChildViewController`, then
+`didMoveToParentViewController`). The view is copied in: to change what it
+shows, create a new controller, or drive it from an `@Observable` model the
+view reads.
+
 ## Asynchronous sequences
 
 A function or property returning `AsyncStream<T>`, `AsyncThrowingStream<T, E>`
 
@@ -0,0 +1,21 @@
+// A SwiftUI view JavaScript hosts in a UIHostingController.
+
+import SwiftUI
+
+public struct Badge: View {
+    public var title: String
+    public var count: Int
+
+    public init(title: String, count: Int) {
+        self.title = title
+        self.count = count
+    }
+
+    public var body: some View {
+        HStack {
+            Text(title)
+            Text("\(count)").bold()
+        }
+        .padding()
+    }
+}
@@ -6,6 +6,8 @@
 #include <set>
 #include <tuple>
 
+#include "SwiftSurface.h"
+
 namespace Swift {
 
 std::string declaringModuleName(const Module& module, const Symbol& symbol) {
@@ -220,6 +222,16 @@ std::string swiftImports(const Module& module,
     collectObjCClasses(capability->result, classes);
   }
   std::set<std::string> frameworks;
+  for (const auto& entry : module.symbols) {
+    const Capability* capability = classification.find(entry.first);
+    if (capability && capability->tier == Tier::SwiftGenerated &&
+        entry.second.kind == SymbolKind::Struct &&
+        isSwiftUIView(entry.second)) {
+      // hostingController() (SwiftSurface).
+      frameworks.insert("SwiftUI");
+      frameworks.insert("UIKit");
+    }
+  }
   for (const auto& name : classes) {
     const char* framework = frameworkOfObjCClass(name);
     if (framework && llvm::StringRef(framework) != "Foundation" &&
 
@@ -1,5 +1,7 @@
 #include "SwiftSurface.h"
 
+#include <algorithm>
+
 namespace Swift {
 
 namespace {
@@ -42,6 +44,11 @@ SwiftSurface::MemberKind memberKind(SymbolKind kind) {
 
 }  // namespace
 
+bool isSwiftUIView(const Symbol& symbol) {
+  return std::find(symbol.conformances.begin(), symbol.conformances.end(),
+                   "s:7SwiftUI4ViewP") != symbol.conformances.end();
+}
+
 int SwiftSurface::indexOf(const std::string& symbolId) const {
   auto it = typeIndex.find(symbolId);
   return it == typeIndex.end() ? -1 : it->second;
@@ -233,6 +240,53 @@ SwiftSurface describeSurface(const Module& module,
     member.signature += ">" + signatureCode(surface, member.result);
     surface.members.push_back(std::move(member));
   }
+
+  for (const auto& type : surface.types) {
+    const Symbol& view = *type.symbol;
+    if (type.kind != SwiftSurface::kStruct || !isSwiftUIView(view)) {
+      continue;
+    }
+    bool taken = false;
+    for (const auto& member : surface.members) {
+      taken |= member.owner == type.index &&
+               member.capability->jsName == "hostingController";
+    }
+    if (taken) {
+      continue;
+    }
+    Symbol symbol;
+    symbol.preciseId = view.preciseId;
+    symbol.kind = SymbolKind::InstanceMethod;
+    symbol.name = "hostingController()";
+    symbol.baseName = "hostingController";
+    symbol.pathComponents = view.pathComponents;
+    symbol.pathComponents.push_back(symbol.name);
+    symbol.parentId = view.preciseId;
+    symbol.module = view.module;
+    symbol.docComment =
+        "A UIHostingController showing this view (main thread only).";
+    surface.syntheticSymbols.push_back(std::move(symbol));
+
+    Capability capability;
+    capability.tier = Tier::SwiftGenerated;
+    capability.jsName = "hostingController";
+    capability.isMainActor = true;
+    capability.result.bridge = Bridge::ObjCObject;
+    capability.result.objcClass = "UIViewController";
+    surface.syntheticCapabilities.push_back(std::move(capability));
+
+    SwiftSurface::Member member;
+    member.symbol = &surface.syntheticSymbols.back();
+    member.capability = &surface.syntheticCapabilities.back();
+    member.owner = type.index;
+    member.module = type.module;
+    member.kind = SwiftSurface::kInstanceMethod;
+    member.flags = SwiftSurface::kMainActor;
+    member.result = member.capability->result;
+    member.signature = ">" + signatureCode(surface, member.result);
+    member.hostsView = true;
+    surface.members.push_back(std::move(member));
+  }
   return surface;
 }
 
 
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <deque>
 #include <map>
 #include <string>
 #include <vector>
@@ -67,6 +68,9 @@ struct SwiftSurface {
     // The value the member produces: the owner for initializers and enum
     // cases, the property type for properties.
     BridgedType result;
+    // `hostingController()`, added to SwiftUI views: a UIHostingController
+    // showing the view.
+    bool hostsView = false;
   };
 
   // A tagged enum's cases in registration order, which is the case index
@@ -83,8 +87,16 @@ struct SwiftSurface {
   int indexOf(const std::string& symbolId) const;
 
   std::map<std::string, int> typeIndex;
+
+  // Declarations of members the surface adds (hostsView), which Member
+  // points into.
+  std::deque<Symbol> syntheticSymbols;
+  std::deque<Capability> syntheticCapabilities;
 };
 
+// Whether `symbol` conforms to SwiftUI.View.
+bool isSwiftUIView(const Symbol& symbol);
+
 SwiftSurface describeSurface(const Module& module,
                              const Classification& classification);
 
 
@@ -430,6 +430,9 @@ class Emitter {
     int flags = member.flags;
     const BridgedType& result = member.result;
 
+    if (member.hostsView) {
+      return emitHosting(member);
+    }
     if (member.kind == SwiftSurface::kEnumCase) {
       // Cases are values (names, or objects JS builds); nothing to call.
       addRegistration(member, "nil", "nil");
@@ -527,6 +530,31 @@ class Emitter {
     return code;
   }
 
+  // `view.hostingController()`: the boxed view in a UIHostingController,
+  // created on the main actor.
+  std::string emitHosting(const SwiftSurface::Member& member) {
+    const Symbol& view = *_module.find(member.symbol->parentId);
+    int index = _thunkCount++;
+    std::string code =
+        "// " + view.preciseId + " (hosting)\n" + thunkHeader(index);
+    std::string availability = availabilityCondition(_module, view);
+    if (!availability.empty()) {
+      code +=
+          "  guard #available(" + availability +
+          ") else { return rt.throwMessage(" +
+          quoted(view.name + " requires " +
+                 llvm::StringRef(availability).rsplit(',').first.trim().str()) +
+          ") }\n";
+    }
+    std::string receiver = bindReceiver(view, code);
+    code += onMainActor(
+        *member.symbol,
+        "  rt.returnObjC(UIHostingController(rootView: " + receiver + "))\n");
+    code += "}\n\n";
+    addRegistration(member, "__nsThunk" + std::to_string(index), "nil");
+    return code;
+  }
+
   void addRegistration(const SwiftSurface::Member& member,
                        const std::string& thunk, const std::string& setter) {
     _registrations.push_back(
 
@@ -75,7 +75,8 @@ TEST(TopLevelDeclarationsInSourceOrder) {
   for (const auto& id : demo().topLevelIds) {
     names.push_back(demo().find(id)->name);
   }
-  std::vector<std::string> expected = {"Greeter",
+  std::vector<std::string> expected = {"Badge",
+                                       "Greeter",
                                        "Demo",
                                        "Point",
                                        "Flavor",