Getting Began with Basis Fashions in iOS 26

With iOS 26, Apple introduces the Basis Fashions framework, a privacy-first, on-device AI toolkit that brings the identical language fashions behind Apple Intelligence proper into your apps. This framework is on the market throughout Apple platforms, together with iOS, macOS, iPadOS, and visionOS, and it offers builders with a streamlined Swift API for integrating superior AI options instantly into your apps.

In contrast to cloud-based LLMs akin to ChatGPT or Claude, which run on highly effective servers and require web entry, Apple’s LLM is designed to run totally on-device. This architectural distinction provides it a singular benefit: all knowledge stays on the consumer’s gadget, making certain privateness, decrease latency, and offline entry.

This framework opens the door to a complete vary of clever options you may construct proper out of the field. You may generate and summarize content material, classify data, and even construct in semantic search and customized studying experiences. Whether or not you wish to create a sensible in-app information, generate distinctive content material for every consumer, or add a conversational assistant, now you can do it with only a few strains of Swift code.

On this tutorial, we’ll discover the Basis Fashions framework. You’ll study what it’s, the way it works, and easy methods to use it to generate content material utilizing Apple’s on-device language fashions.

Able to get began? Let’s dive in.

The Demo App: Ask Me Something

It’s at all times nice to study new frameworks or APIs by constructing a demo app — and that’s precisely what we’ll do on this tutorial. We’ll create a easy but highly effective app referred to as Ask Me Something to discover how Apple’s new Basis Fashions framework works in iOS 26.

The app lets customers kind in any questions and offers an AI-generated response, all processed on-device utilizing Apple’s built-in LLM.

By constructing this demo app, you may learn to combine the Basis Fashions framework right into a SwiftUI app. You may additionally perceive easy methods to create prompts and seize each full and partial generated responses.

Utilizing the Default System Language Mannequin

Apple offers a built-in mannequin referred to as SystemLanguageModel, which supplies you entry to the on-device basis mannequin that powers Apple Intelligence. For general-purpose use, you may entry the base model of this mannequin through the default property. It’s optimized for textual content era duties and serves as an incredible start line for constructing options like content material era or query answering in your app.

To make use of it in your app, you may first must import the FoundationModels framework:

import FoundationModels

With the framework now imported, you will get a deal with on the default system language mannequin. Right here’s the pattern code to try this:

struct ContentView: View {
    
    personal var mannequin = SystemLanguageModel.default
    
    var physique: some View {
        change mannequin.availability {
        case .obtainable:
            mainView
        case .unavailable(let motive):
            Textual content(unavailableMessage(motive))
        }
    }
    
    personal var mainView: some View {
        ScrollView {
            .
            .
            .
        }
    }

    personal func unavailableMessage(_ motive: SystemLanguageModel.Availability.UnavailableReason) -> String {
        change motive {
        case .deviceNotEligible:
            return "The gadget is just not eligible for utilizing Apple Intelligence."
        case .appleIntelligenceNotEnabled:
            return "Apple Intelligence is just not enabled on this gadget."
        case .modelNotReady:
            return "The mannequin is not prepared as a result of it is downloading or due to different system causes."
        @unknown default:
            return "The mannequin is unavailable for an unknown motive."
        }
    }
}

Since Basis Fashions solely work on units with Apple Intelligence enabled, it is vital to confirm {that a} mannequin is on the market earlier than utilizing it. You may test its readiness by inspecting the availability property.

Implementing the UI

Let’s proceed to construct the UI of the mainView. We first add two state variables to retailer the consumer query and the generated reply:

@State personal var reply: String = ""
@State personal var query: String = ""

For the UI implementation, replace the mainView like this:

personal var mainView: some View {
    ScrollView {
        ScrollView {
            VStack {
                Textual content("Ask Me Something")
                    .font(.system(.largeTitle, design: .rounded, weight: .daring))
                
                TextField("", textual content: $query, immediate: Textual content("Kind your query right here"), axis: .vertical)
                    .lineLimit(3...5)
                    .padding()
                    .background {
                        Shade(.systemGray6)
                    }
                    .font(.system(.title2, design: .rounded))
                
                Button {

                } label: {
                    Textual content("Get reply")
                        .body(maxWidth: .infinity)
                        .font(.headline)
                }
                .buttonStyle(.borderedProminent)
                .controlSize(.extraLarge)
                .padding(.prime)
                
                Rectangle()
                    .body(peak: 1)
                    .foregroundColor(Shade(.systemGray5))
                    .padding(.vertical)
                
                Textual content(LocalizedStringKey(reply))
                    .font(.system(.physique, design: .rounded))
            }
            .padding()
        }

    }
}

The implementation is fairly easy – I simply added a contact of primary styling to the textual content area and button.

Producing Responses with the Language Mannequin

Now we’ve come to the core a part of app: sending the query to the mannequin and producing the response. To deal with this, we create a brand new operate referred to as generateAnswer():

personal func generateAnswer() async {
    let session = LanguageModelSession()
    do {
        let response = attempt await session.reply(to: query)
        reply = response.content material
    } catch {
        reply = "Didn't reply the query: (error.localizedDescription)"
    }
}

As you may see, it solely takes just a few strains of code to ship a query to the mannequin and obtain a generated response. First, we create a session utilizing the default system language mannequin. Then, we move the consumer’s query, which is called a immediate, to the mannequin utilizing the reply technique.

The decision is asynchronous because it often takes just a few second (and even longer) for the mannequin to generate the response. As soon as the response is prepared, we are able to entry the generated textual content by the content material property and assign it to reply for show.

To invoke this new operate, we additionally must replace the closure of the “Get Reply” button like this:

Button {
    Job {
        await generateAnswer()
    }
} label: {
    Textual content("Present me the reply")
        .body(maxWidth: .infinity)
        .font(.headline)
}

You may check the app instantly within the preview pane, or run it within the simulator. Simply kind in a query, wait just a few seconds, and the app will generate a response for you.

Reusing the Session

The code above creates a brand new session for every query, which works properly when the questions are unrelated.

However what if you need customers to ask follow-up questions and maintain the context? In that case, you may merely reuse the identical session every time you name the mannequin.

For our demo app, we are able to transfer the session variable out of the generateAnswer() operate and switch it right into a state variable:

@State personal var session = LanguageModelSession()

After making the change, attempt testing the app by first asking: “What are the must-try meals when visiting Japan?” Then comply with up with: “Recommend me some eating places.”

For the reason that session is retained, the mannequin understands the context and is aware of you are searching for restaurant suggestions in Japan.

In case you don’t reuse the identical session, the mannequin received’t acknowledge the context of your follow-up query. As a substitute, it’s going to reply with one thing like this, asking for extra particulars:

“Certain! To offer you one of the best strategies, may you please let me know your location or the kind of delicacies you are interested by?”

Disabling the Button Throughout Response Technology

For the reason that mannequin takes time to generate a response, it’s a good suggestion to disable the “Get Reply” button whereas ready for the reply. The session object features a property referred to as isResponding that allows you to test if the mannequin is presently working.

To disable the button throughout that point, merely use the .disabled modifier and move within the session’s standing like this:

Button {
    Job {
        await generateAnswer()
    }
} label: {
    .
    .
    .
}
.disabled(session.isResponding)

Working with Stream Responses

The present consumer expertise is not superb — because the on-device mannequin takes time to generate a response, the app solely reveals the consequence after the whole response is prepared.

In case you’ve used ChatGPT or comparable LLMs, you’ve in all probability seen that they begin displaying partial outcomes nearly instantly. This creates a smoother, extra responsive expertise.

The Basis Fashions framework additionally helps streaming output, which lets you show responses as they’re being generated, moderately than ready for the entire reply. To implement this, use the streamResponse technique moderately than the reply technique. This is the up to date generateAnswer() operate that works with streaming responses:

personal func generateAnswer() async {
    
    do {
        reply = ""
        let stream = session.streamResponse(to: query)
        for attempt await streamData in stream {             
		        reply = streamData.asPartiallyGenerated()
        }
    } catch {
        reply = "Didn't reply the query: (error.localizedDescription)"
    }
}

Similar to with the reply technique, you move the consumer’s query to the mannequin when calling streamResponse. The important thing distinction is that as an alternative of ready for the total response, you may loop by the streamed knowledge and replace the reply variable with every partial consequence — displaying it on display because it’s generated.

Now if you check the app once more and ask any questions, you may see responses seem incrementally as they’re generated, creating a way more responsive consumer expertise.

Abstract

On this tutorial, we lined the fundamentals of the Basis Fashions framework and confirmed easy methods to use Apple’s on-device language mannequin for duties like query answering and content material era.

That is just the start — the framework gives rather more. In future tutorials, we’ll dive deeper into different new options akin to the brand new @Generable and @Information macros, and discover further capabilities like content material tagging and gear calling.

In case you’re seeking to construct smarter, AI-powered apps, now’s the right time to discover the Basis Fashions framework and begin integrating on-device intelligence into your tasks.