<!--
{
  "availability" : [
    "iOS: 26.0.0 -",
    "iPadOS: 26.0.0 -",
    "macCatalyst: 26.0.0 -",
    "macOS: 26.0.0 -",
    "tvOS: 26.0.0 -",
    "visionOS: 1.1.0 -",
    "watchOS: 26.0.0 -"
  ],
  "documentType" : "symbol",
  "framework" : "ExtensionFoundation",
  "identifier" : "/documentation/ExtensionFoundation/AppExtensionPoint",
  "metadataVersion" : "0.1.0",
  "role" : "Structure",
  "symbol" : {
    "kind" : "Structure",
    "modules" : [
      "ExtensionFoundation"
    ],
    "preciseIdentifier" : "s:19ExtensionFoundation03AppA5PointV"
  },
  "title" : "AppExtensionPoint"
}
-->

# AppExtensionPoint

A type you use to declare your host app’s extension points and bind to them from app extensions.

```
struct AppExtensionPoint
```

## Overview

Use this type both to declare your app’s supported extension points and to bind to those extension
points. To declare an extension point your app supports, extend this type by adding a static
variable with the details of your extension point. Annotate your variable with the
[`AppExtensionPoint.Definition`](/documentation/ExtensionFoundation/AppExtensionPoint/Definition) property wrapper and specify the name and other attributes of
your extension point. The following example adds two extension point with different configurations:

```
extension AppExtensionPoint {
    @Definition
    static var MySecureFeature : AppExtensionPoint {
        Name(“MySecureFeature”)
        UserInterface(false)
        EnhancedSecurity(true)
    }

    @Definition
    static var MyInterfaceFeature : AppExtensionPoint {
        Name(“MyInterfaceFeature”)
        UserInterface(true)
    }

}
```

In addition to defining your app’s extension points, use this type in an app extension to bind
to an extension point. In your app extension’s source code, add a variable that contains the
`AppExtensionPoint` type. Set the value of that variable to the extension point identifier you
support. Annotate your variable declaration with the [`AppExtensionPoint.Bind`](/documentation/ExtensionFoundation/AppExtensionPoint/Bind) property wrapper,
as shown in the following example:

```
struct MyAppExtension: AppExtension {
    @AppExtensionPoint.Bind
    var boundAppExtensionPoint: AppExtensionPoint {
        AppExtensionPoint.Identifier(name “MySecureFeature”)
    }
}
```

To make extension point and binding information available at runtime, use the compiler to add
the relevant information to your built products. In your Xcode project, add the
`EX_ENABLE_EXTENSION_POINT_GENERATION` flag to the build settings of your host app and app extension.
When the value of the flag is `true`, the compiler collects the target’s extension point
definitions or bindings and writes them to the target’s bundle. For example, it creates a
special file in the host app’s bundle and adds the extension point definitions to that file.
The system collects definition and binding information at installation time and uses it to
match the host app to relevant app extensions.

## Topics

### Creating an app-extension point

[`init(identifier:)`](/documentation/ExtensionFoundation/AppExtensionPoint/init(identifier:))

Initializes the type with a string you can use to find the extension point.

### Declaring an extension point

[`Definition`](/documentation/ExtensionFoundation/AppExtensionPoint/Definition)

A property wrapper that a host app uses to declare the extension points it supports.

[`Name`](/documentation/ExtensionFoundation/AppExtensionPoint/Name)

A type that defines the name of an extension point.

[`UserInterface`](/documentation/ExtensionFoundation/AppExtensionPoint/UserInterface)

A type with that indicates whether the extension point displays UI from an app extension.

[`EnhancedSecurity`](/documentation/ExtensionFoundation/AppExtensionPoint/EnhancedSecurity)

A type that indicates whether an extension point requires extra security.

[`Scope`](/documentation/ExtensionFoundation/AppExtensionPoint/Scope)

A type that regulates which app extensions may access an extension point.

[`Attribute`](/documentation/ExtensionFoundation/AppExtensionPoint/Attribute)

An interface that marks a type as an extension point attribute.

### Binding to an extension point

[`Bind`](/documentation/ExtensionFoundation/AppExtensionPoint/Bind)

A property wrapper that binds an app extension to an extension point of a host app.

[`Identifier`](/documentation/ExtensionFoundation/AppExtensionPoint/Identifier)

The details of an extension point that your app extension supports.

### Detecting app extensions

[`Monitor`](/documentation/ExtensionFoundation/AppExtensionPoint/Monitor)

A type you use to discover the app extensions available for your host app to use.

### Getting error codes

[`Error`](/documentation/ExtensionFoundation/AppExtensionPoint/Error)

Error codes for monitor-related requests.

## Relationships

### Conforms To

[`Identifiable`](/documentation/Swift/Identifiable)

[`Escapable`](/documentation/Swift/Escapable)

[`Sendable`](/documentation/Swift/Sendable)

[`Equatable`](/documentation/Swift/Equatable)

[`Copyable`](/documentation/Swift/Copyable)

[`SendableMetatype`](/documentation/Swift/SendableMetatype)

[`ExtensionPointDefining`](/documentation/ExtensionFoundation/ExtensionPointDefining)

[`Hashable`](/documentation/Swift/Hashable)

---

Copyright &copy; 2026 Apple Inc. All rights reserved. | [Terms of Use](https://www.apple.com/legal/internet-services/terms/site.html) | [Privacy Policy](https://www.apple.com/privacy/privacy-policy)