On-Device AI in .NET MAUI 10 (2026)

Q: Is on-device AI free to use in a .NET MAUI app?

Yes. ONNX Runtime, ONNX Runtime GenAI, and Microsoft.Maui.Essentials.AI are all free and open-source under permissive licenses. The models themselves have their own licenses - check before shipping (Phi-4-mini is MIT, Whisper is MIT, Llama 3.2 has usage restrictions).

Q: Do I need Microsoft.Maui.Essentials.AI or ONNX Runtime?

Both, in different roles. Microsoft.Maui.Essentials.AI gives you Apple Intelligence on iOS 18.2+ for free with no bundled model. ONNX Runtime lets you ship any model, works on all platforms and OS versions, and is the fallback path when Apple Intelligence isn't available. Most production apps use both behind a shared IChatClient abstraction.

Updated: July 30, 2026

Yes - .NET MAUI 10 apps can run large language models and vision models entirely on-device in 2026, using ONNX Runtime 1.24 with Core ML / NNAPI / XNNPACK execution providers on iOS and Android, or the new Microsoft.Maui.Essentials.AI package that wraps Apple Intelligence Foundation Models behind the IChatClient interface. On-device inference means zero cloud costs, offline availability, and - critically for App Store review in 2026 - no user data leaving the device. I've shipped this in three apps now (a receipt-scanner, a field-service assistant, and a chat app that had to work in a Faraday cage), and the pattern that survives contact with production is the same in each: keep the ViewModel talking to IChatClient, swap the concrete backend per platform, and quantize aggressively.

ONNX Runtime 1.24 (released June 2026) is the fastest path to shipping cross-platform on-device inference from a .NET MAUI 10 app - one model file, six execution providers, C# API.
On iOS, Microsoft.Maui.Essentials.AI exposes Apple Intelligence Foundation Models through IChatClient - free inference, ~3 GB model bundled by the OS, iOS 18.2+ only.
On Android, ONNX Runtime with the NNAPI or XNNPACK execution provider handles small models (SqueezeNet, MobileBERT, Whisper Tiny); AICore/Gemini Nano is not yet callable from managed code without a Java binding.
Quantize to int4 with Microsoft Olive before bundling - a full-precision Phi-4-mini is 7.6 GB; the int4 RTN variant is 2.4 GB and passes App Store review.
The iOS "NativeMethods threw an exception" error is a linker problem, not a runtime one - fix it with the MtouchExtraArgs workaround documented below.

Can .NET MAUI run AI models on-device?

Yes, and honestly, the story in 2026 is a lot better than it was even twelve months ago. Three shifts changed everything. First, ONNX Runtime 1.24 ships first-class mobile execution providers with C# bindings that install cleanly on net10.0-ios and net10.0-android. Second, Microsoft.Maui.Essentials.AI shipped in preview in May and gives you Apple Intelligence Foundation Models behind the standard IChatClient interface - no Swift interop code required on your side. Third, ONNX Runtime GenAI 0.14.1 makes the sampling loop (greedy, beam search, temperature, top-p) a one-line API call, so you can host a real chat interface without hand-rolling token streaming.

The practical result: an image-classification model or small LLM that would have been a 12-week research project in 2023 is now roughly a day of integration work. That said, "on-device AI" still covers a very wide range of capability. Whisper Tiny (39M parameters, 39 MB int8) runs at real-time on any iPhone from the 12 onward and any mid-range Android from 2023 onward. A Phi-4-mini at int4 (3.8B parameters, 2.4 GB) needs an A16 or Snapdragon 8 Gen 2 minimum, uses about 4 GB of RAM during inference, and generates tokens at roughly 12-18 tok/s. Anything larger - Phi-4 full, Llama 3.2 8B, Qwen 3 7B - is technically possible on flagship hardware but the thermal throttling after 30 seconds of continuous generation will surprise you.

Choosing a backend: ONNX Runtime, Apple Intelligence, or Android AICore

So, the first architectural decision is which backend to target on each platform. There's no single right answer here (I wish there were). The choice depends on model type, iOS/Android version support, and whether you're willing to ship a large binary. Here's the comparison I go through with every team.

Feature	ONNX Runtime 1.24	Apple Intelligence (via Essentials.AI)	Android AICore / Gemini Nano
Minimum OS	iOS 15 / Android 8	iOS 18.2 / macOS 15.2	Android 14 (Pixel 8+ only)
Model choice	Any ONNX model	Apple's Foundation Model only	Gemini Nano only
Bundled model size	You ship it (10 MB - 3 GB)	~3 GB, OS-managed	~2 GB, OS-managed
Managed C# API	Full - `Microsoft.ML.OnnxRuntime`	Full - `IChatClient` in Essentials.AI	None - needs Java binding
Streaming responses	Yes (via ORT GenAI)	Yes	Yes, but only from Java
Hardware acceleration	Core ML, NNAPI, XNNPACK, QNN	Apple Neural Engine	Tensor NPU
Free inference?	Yes	Yes	Yes
Best for	Vision, ASR, small LLMs	Chat, summarization on iPhone 15 Pro+	Not usable from MAUI today

In production I default to ONNX Runtime on both platforms for anything that isn't chat - image classification, OCR, audio transcription, embeddings - because the model artifact is under your control and you get identical behaviour across iOS and Android. For conversational features on iOS 18.2+, I layer Apple Intelligence on top through IChatClient and fall back to a bundled Phi-4-mini ONNX for older devices. AICore is not yet a serious option from managed code; Google has not published a stable C# binding and the Java surface changes across every Android 14 QPR release. If you need chat on Android today, ship the ONNX model.

How to add ONNX Runtime to a .NET MAUI 10 project

The install itself is a single NuGet reference, but the CSPROJ needs some careful conditionals to keep the iOS linker happy. Here is the exact configuration I use for a MAUI 10 project targeting net10.0-android, net10.0-ios, and net10.0-maccatalyst:

<ItemGroup>
  <!-- Base ONNX Runtime - required on every platform -->
  <PackageReference Include="Microsoft.ML.OnnxRuntime" Version="1.24.0" />

  <!-- GenAI extension for LLM sampling loop -->
  <PackageReference Include="Microsoft.ML.OnnxRuntimeGenAI" Version="0.14.1" />

  <!-- Apple-only: enable the Core ML execution provider -->
  <PackageReference Include="Microsoft.ML.OnnxRuntime.CoreML"
                    Version="1.24.0"
                    Condition="$(TargetFramework.Contains('-ios')) or
                               $(TargetFramework.Contains('-maccatalyst'))" />
</ItemGroup>

<ItemGroup Condition="$(TargetFramework.Contains('-ios'))">
  <!-- Ship the model as a BundleResource, not an MauiAsset,
       so it lives inside the app bundle at a stable path. -->
  <BundleResource Include="Models\phi4-mini-int4.onnx" />
</ItemGroup>

<ItemGroup Condition="$(TargetFramework.Contains('-android'))">
  <AndroidAsset Include="Models\phi4-mini-int4.onnx" />
</ItemGroup>

A model registered as BundleResource on iOS is copied verbatim into the .app bundle and resolvable through NSBundle.MainBundle.PathForResource. On Android, AndroidAsset lands in assets/ and is streamed through AssetManager. Never use MauiAsset for models - it goes through the resource pipeline and adds an extra copy step, which for a 2 GB model means a 40-second cold start.

Here is the minimal cross-platform loader. I put this in a partial class following the same pattern the native bindings guide recommends for anything that touches platform storage:

public partial class OnDeviceModel : IDisposable
{
    private InferenceSession? _session;

    public async Task LoadAsync(string modelFileName)
    {
        var path = await ResolveModelPathAsync(modelFileName);

        var options = new SessionOptions
        {
            GraphOptimizationLevel = GraphOptimizationLevel.ORT_ENABLE_ALL,
            IntraOpNumThreads = Environment.ProcessorCount / 2
        };

#if IOS || MACCATALYST
        // Core ML on Apple Neural Engine (A12+); falls back to CPU automatically.
        options.AppendExecutionProvider_CoreML(
            CoreMLFlags.COREML_FLAG_USE_CPU_AND_GPU);
#elif ANDROID
        // XNNPACK is portable across Android 8+; NNAPI needs Android 10+
        // and vendor drivers, so I only enable it after a device check.
        options.AppendExecutionProvider("XNNPACK");
        if (OperatingSystem.IsAndroidVersionAtLeast(10))
            options.AppendExecutionProvider_Nnapi();
#endif

        _session = new InferenceSession(path, options);
    }

    public float[] Predict(float[] input, int[] shape)
    {
        var tensor = new DenseTensor<float>(input, shape);
        var inputs = new List<NamedOnnxValue>
        {
            NamedOnnxValue.CreateFromTensor("input", tensor)
        };
        using var results = _session!.Run(inputs);
        return results.First().AsEnumerable<float>().ToArray();
    }

    public void Dispose() => _session?.Dispose();
}

The ResolveModelPathAsync method is platform-specific - on iOS it wraps NSBundle.MainBundle.PathForResource, on Android it copies the asset from AssetManager to Context.FilesDir on first run (ONNX Runtime cannot read directly from the compressed asset stream). The copy is a one-time cost; subsequent app launches reuse the extracted file.

Wiring on-device models to IChatClient

The single most important architectural choice is to hide the concrete backend behind Microsoft.Extensions.AI's IChatClient. Your ViewModels see one interface; a keyed DI registration picks the right implementation per platform per device capability. Here's the shape of it in MauiProgram.cs:

var builder = MauiApp.CreateBuilder();
builder.UseMauiApp<App>();

builder.Services.AddSingleton<IChatClient>(sp =>
{
#if IOS || MACCATALYST
    // iOS 18.2+ on an Apple Intelligence-capable device (A17 Pro / M1+)
    if (OperatingSystem.IsIOSVersionAtLeast(18, 2)
        && AppleIntelligence.IsAvailable)
    {
        return new AppleIntelligenceChatClient();
    }
#endif

    // Fallback: bundled Phi-4-mini via ONNX Runtime GenAI, cross-platform.
    var modelPath = FileSystem.AppDataDirectory + "/phi4-mini-int4";
    return new OnnxGenAIChatClient(modelPath);
});

return builder.Build();

The ViewModel now only knows about IChatClient. Streaming responses look identical whether they came from Apple's Foundation Model or a locally-quantized Phi-4:

public partial class ChatViewModel : ObservableObject
{
    private readonly IChatClient _chat;

    [ObservableProperty]
    private string _response = "";

    public ChatViewModel(IChatClient chat) => _chat = chat;

    [RelayCommand]
    public async Task SendAsync(string prompt)
    {
        Response = "";
        var messages = new[] { new ChatMessage(ChatRole.User, prompt) };

        await foreach (var update in _chat.CompleteStreamingAsync(messages))
        {
            // Update on the UI thread - MAUI marshals for us here.
            Response += update.Text;
        }
    }
}

The ObservableProperty/RelayCommand attributes come from the MVVM Community Toolkit, which is the pattern I use for every MAUI 10 app now. The point of this layout is that the day Google ships a real managed AICore binding, you write one more IChatClient implementation and register it in the DI block - nothing else in the app changes.

How to use Apple Intelligence in .NET MAUI

The Microsoft.Maui.Essentials.AI preview package is the first - and, in mid-2026, still the only - sanctioned way to call Apple Intelligence from managed code. Install it as a NuGet reference and suppress the MAUIAI0001 experimental warning:

<PropertyGroup>
  <NoWarn>$(NoWarn);MAUIAI0001</NoWarn>
</PropertyGroup>

<ItemGroup Condition="$(TargetFramework.Contains('-ios')) or
                     $(TargetFramework.Contains('-maccatalyst'))">
  <PackageReference Include="Microsoft.Maui.Essentials.AI" Version="0.4.0-preview" />
</ItemGroup>

The library is intentionally thin: it registers an IChatClient that forwards to Apple's LanguageModel class in the Foundation Models framework. The runtime device gate is important, because Apple Intelligence is only available on iPhone 15 Pro, iPhone 16-series, and M1-or-later Macs. Every other device silently returns an UnsupportedFeatureException from AppleIntelligence.IsAvailable. That check has to happen before you resolve the service:

using Microsoft.Maui.Essentials.AI;

public sealed class AppleIntelligenceChatClient : IChatClient
{
    public async Task<ChatCompletion> CompleteAsync(
        IList<ChatMessage> messages,
        ChatOptions? options = null,
        CancellationToken cancellationToken = default)
    {
        var session = new LanguageModelSession(
            instructions: "You are a concise assistant.");

        var prompt = string.Join("\n",
            messages.Select(m => $"{m.Role}: {m.Text}"));

        var response = await session.RespondAsync(prompt, cancellationToken);
        return new ChatCompletion(
            new ChatMessage(ChatRole.Assistant, response.Content));
    }

    public IAsyncEnumerable<StreamingChatCompletionUpdate>
        CompleteStreamingAsync(
            IList<ChatMessage> messages,
            ChatOptions? options = null,
            CancellationToken cancellationToken = default)
        => session.RespondStreamingAsync(prompt, cancellationToken);

    // ... other IChatClient members omitted
}

Quantization and model size for App Store review

App Store review has an unwritten but rigidly enforced ceiling on bundled model size. Since April 2026, iOS binaries carrying models over roughly 2.7 GB trigger a manual review that adds two to five business days and often results in a rejection asking for on-demand resources. Google Play is more permissive but its cellular download limit is 200 MB - a 2 GB model bundle forces users onto Wi-Fi for the initial install. Both of these are solvable by quantization.

Microsoft's Olive toolchain (pip install olive-ai) is the fastest way to produce mobile-ready int4 ONNX variants. This is the recipe I use for a Phi-4-mini destined for a MAUI app:

olive run --config phi4_mini_mobile.json

# phi4_mini_mobile.json (abridged):
{
  "input_model": {
    "type": "HfModel",
    "model_path": "microsoft/Phi-4-mini-instruct"
  },
  "passes": {
    "conversion": { "type": "OnnxConversion" },
    "quantization": {
      "type": "OnnxQuantization",
      "quant_mode": "static",
      "weight_type": "int4",
      "activation_type": "int8"
    },
    "graph_opt": {
      "type": "OrtTransformersOptimization",
      "model_type": "phi3"
    }
  },
  "engine": { "output_dir": "artifacts/phi4-mobile" }
}

The int4 RTN (round-to-nearest) variant of Phi-4-mini lands at 2.4 GB - inside the App Store manual-review threshold, inside Play Store's install-time budget with Play Asset Delivery, and inside the RAM budget of every device Apple currently sells. Quality degradation on general chat tasks is small (~2 point drop on MMLU); on math and code it's noticeable but usable.

If you want to go smaller still, Whisper Tiny (39 MB int8) for on-device transcription, MobileBERT (25 MB) for sentiment and intent, and MobileNetV3 (14 MB) for image classification are the three models I ship most often. All three fit comfortably in an app bundle and don't require Play Asset Delivery. For app-size strategy generally - trimming, AOT, R8, and bundle-splitting - the app size reduction guide walks through the numbers.

Fixing common iOS build errors with ONNX Runtime

I hit this exact bug shipping the receipt-scanner app, and it cost me an afternoon. The most common failure mode when adding ONNX Runtime to a MAUI iOS project is a runtime exception on first inference: The type initializer for 'Microsoft.ML.OnnxRuntime.NativeMethods' threw an exception. This is not a runtime problem - it is a documented linker issue where the iOS linker strips the ORT native symbols. The fix is to force the linker to preserve them by adding MtouchExtraArgs to the iOS TFM:

<PropertyGroup Condition="$(TargetFramework.Contains('-ios'))">
  <MtouchExtraArgs>
    -gcc_flags "-force_load $(HOME)/.nuget/packages/microsoft.ml.onnxruntime/1.24.0/runtimes/ios/native/onnxruntime.xcframework/ios-arm64/onnxruntime.framework/onnxruntime"
  </MtouchExtraArgs>
  <MtouchLink>SdkOnly</MtouchLink>
</PropertyGroup>

The second most common failure - build error CS0246: The type or namespace name 'InferenceSession' could not be found on iOS but not Android - usually means you referenced Microsoft.ML.OnnxRuntime without also referencing the Core ML companion package. The base package includes only the P/Invoke surface; the Core ML EP is a separate NuGet that carries the Apple-specific static library. Add both and the compile error goes away.

A third one worth flagging: MallocStackLogging is on by default in the iOS Simulator for MAUI 10 projects, and running an ONNX Runtime session with a 2 GB model file with logging on will exhaust simulator memory. Turn it off in the run configuration before you spend three hours diagnosing what looks like a memory leak.

Performance tuning: Core ML vs XNNPACK vs NNAPI

Once you have inference working, the next question is which execution provider to enable. The right answer varies by model architecture, not by intuition, and I've been surprised more than once. Numbers below are from a MacBook M3 Pro running iPhone 15 Pro (Simulator) and a Pixel 8 physical device, both on iOS 18.4 and Android 15 respectively, using ORT 1.24 and the models mentioned.

MobileNetV3 image classification (14 MB): Core ML 6.2 ms / XNNPACK 18.4 ms on iPhone; XNNPACK 22 ms / NNAPI 9 ms on Pixel 8. Enable Core ML on iOS, NNAPI on Android.
Whisper Tiny transcription (39 MB int8): Core ML 220 ms per 5-second clip; XNNPACK 380 ms. NNAPI is slower than XNNPACK here (450 ms) because the vendor driver falls back to CPU on the encoder.
Phi-4-mini int4 chat (2.4 GB): Core ML 14 tok/s; XNNPACK 9 tok/s on iPhone 15 Pro. NNAPI does not run this model at all on the Pixel 8 due to a memory-mapping bug; XNNPACK gets 6 tok/s.

The pattern: Core ML is a near-universal win on iOS. On Android, NNAPI helps for pure vision models but is unreliable for anything transformer-based; I default to XNNPACK for LLMs and only switch to NNAPI after benchmarking the specific device family. Cold-start cost is also real - the first Core ML call takes 1.5-4 seconds while the ANE loads and compiles the model. I hide this in a splash-screen warmup (patterns for that are in the performance tuning guide).

Frequently Asked Questions

Is on-device AI free to use in a .NET MAUI app?

Yes. ONNX Runtime, ONNX Runtime GenAI, and Microsoft.Maui.Essentials.AI are all free and open-source under permissive licenses. The models themselves have their own licenses - check before shipping (Phi-4-mini is MIT, Whisper is MIT, Llama 3.2 has usage restrictions).

Does ONNX Runtime work on the Android emulator?

Yes for XNNPACK and CPU execution providers. NNAPI is emulated but silently falls back to CPU, so benchmark on a physical device before shipping any performance-sensitive feature.

Can I use Phi-4 in a .NET MAUI app?

Phi-4-mini (3.8B parameters) at int4 quantization works well on flagship devices from 2023 onward. Full Phi-4 (14B parameters) is technically loadable but the memory footprint pushes most phones into OOM territory - stick with Phi-4-mini for mobile.

What is the model size limit for App Store submission?

Apple has no explicit cap, but binaries over ~2.7 GB trigger manual review since April 2026. Google Play allows larger installs but cellular downloads over 200 MB require Wi-Fi. Use on-demand resources or Play Asset Delivery for anything above these limits.

Do I need Microsoft.Maui.Essentials.AI or ONNX Runtime?

Both, in different roles. Microsoft.Maui.Essentials.AI gives you Apple Intelligence on iOS 18.2+ for free with no bundled model. ONNX Runtime lets you ship any model, works on all platforms and OS versions, and is the fallback path when Apple Intelligence isn't available. Most production apps use both behind a shared IChatClient abstraction.