Unlocking AI on Apple: AnyLanguageModel Simplifies Local and Cloud LLM Integration

Posted on November 20, 2025 by Arthur N

The AI Revolution on Apple: Bridging the Gap for Developers

Large Language Models (LLMs) have rapidly ascended from niche research tools to indispensable components for modern software development. Whether it’s powering sophisticated chatbots, analyzing vast datasets, or generating creative content, LLMs are at the forefront of innovation. However, for developers building applications specifically for Apple’s ecosystem – be it on macOS, iOS, iPadOS, or visionOS – integrating these powerful AI models has historically been a fragmented and often frustrating experience.

Currently, Apple developers typically navigate a multi-pronged approach to LLM integration. This often involves a hybrid strategy that balances different strengths:

  • Local Models: Leveraging frameworks like Core ML or Apple’s own MLX allows for on-device processing. This is crucial for maintaining user privacy, ensuring offline functionality, and often reducing latency and operational costs.
  • Cloud Providers: Accessing cutting-edge capabilities from major cloud players like OpenAI, Anthropic, or Google Gemini offers developers access to the most advanced and powerful models, often with larger context windows and superior performance on complex tasks.
  • Apple’s Foundation Models: For system-level integrations and fallback options, Apple’s native Foundation Models framework provides a convenient, albeit sometimes limited, option.

The challenge lies in the fact that each of these integration paths comes with its own distinct set of APIs, unique integration patterns, and differing operational requirements. This creates a significant overhead for developers, forcing them to manage multiple SDKs, learn different paradigms, and spend valuable time wrestling with compatibility issues rather than focusing on building innovative features.

This friction hasn’t gone unnoticed. Many developers have expressed their frustration. One poignant anecdote shared by a developer highlights the steep learning curve and unexpected time investment: "I thought I’d quickly use the demo for a test and maybe a quick and dirty build, but instead wasted so much time. Drove me nuts." This high cost of experimentation can be a significant deterrent, discouraging developers from exploring the potential of local, open-source models that might be perfectly suited for their specific use cases.

Introducing AnyLanguageModel: A Unified API for Every LLM

Today, we’re thrilled to announce a game-changer for Apple developers: AnyLanguageModel. This new Swift package is designed to be a drop-in replacement for Apple’s own Foundation Models framework, but with a crucial difference – it supports a wide array of both local and remote LLM providers under a single, cohesive API.

Our primary mission with AnyLanguageModel is to drastically reduce the friction associated with working with LLMs on Apple platforms. We aim to empower developers to seamlessly adopt and switch between different models, making it easier than ever to harness the power of open-source models that run directly on their users’ devices.

The Elegance of Simplicity: One API to Rule Them All

The core philosophy behind AnyLanguageModel is remarkably straightforward: Swap your import statement, keep the same API. Imagine a world where switching from Apple’s native model to a powerful local LLM requires only a minor code adjustment, preserving the rest of your application’s logic.

Let’s illustrate this with a practical example. Traditionally, interacting with Apple’s built-in language model would look something like this:

import FoundationModels

let model = SystemLanguageModel.default
let session = LanguageModelSession(model: model)

let response = try await session.respond(to: "Explain quantum computing in one sentence")
print(response.content)

Now, with AnyLanguageModel, transitioning to an open-source model running locally via MLX is as simple as this:

import AnyLanguageModel

let model = MLXLanguageModel(modelId: "mlx-community/Qwen3-4B-4bit")
let session = LanguageModelSession(model: model)

let response = try await session.respond(to: "Explain quantum computing in one sentence")
print(response.content)

This seamless transition is the magic of AnyLanguageModel. It abstracts away the complexities of different backends, allowing you to focus on the core AI logic of your application.

A Spectrum of Support: Powering Your AI on Apple

AnyLanguageModel boasts an impressive range of supported providers, catering to diverse development needs:

  • Apple Foundation Models: Enjoy native integration with Apple’s system-level model, available on macOS 14+ and iOS 17+ (note: the article mentions macOS 26+/iOS 26+, which likely refers to future versions). This provides a familiar starting point and a reliable fallback.
  • Core ML: Efficiently run your own converted models, taking full advantage of the Neural Engine for accelerated performance on Apple hardware.
  • MLX: Optimize for Apple Silicon with MLX, enabling the efficient execution of quantized models directly on the chip.
  • llama.cpp: Load and utilize GGUF models through the widely adopted llama.cpp backend, opening up a vast ecosystem of open-source models.
  • Ollama: Connect to locally-served models running via Ollama’s robust HTTP API, offering flexibility in managing your local AI deployments.
  • Cloud Providers (OpenAI, Anthropic, Google Gemini): Integrate with leading cloud LLM providers for comparative analysis, fallback scenarios, or to access their most advanced capabilities.
  • Hugging Face Inference Providers: Access hundreds of models hosted on Hugging Face, powered by world-class inference services. The primary focus here is on models you can download and run locally from the Hugging Face Hub, but cloud providers are also included to ease initial adoption and provide a clear migration path from experimentation to polished production-ready applications.

Why Foundation Models? A Strategic Foundation

When embarking on the development of AnyLanguageModel, the team faced a critical architectural decision: should they create an entirely new, comprehensive abstraction layer, or build upon an existing framework? The chosen path was to leverage Apple’s Foundation Models framework as the foundational API template. This might initially seem counterintuitive – why tie your innovation to an existing, potentially limited API?

There are several compelling reasons for this strategic choice:

  1. Exceptional Design: Apple’s Foundation Models framework is, in many respects, genuinely well-designed. It effectively utilizes Swift’s modern features, such as macros, to create an ergonomic and intuitive developer experience. Its abstractions for concepts like ‘sessions,’ ‘tools,’ and ‘generation’ align closely with the actual workflows of interacting with LLMs.
  2. Intentional Limitations as a Strength: The Foundation Models framework represents a kind of ‘lowest common denominator’ for language model capabilities. Rather than viewing these limitations as a weakness, AnyLanguageModel embraces them. This creates a stable, predictable foundation. Because nearly every Swift developer targeting Apple platforms will encounter this API, building upon it directly minimizes the conceptual overhead for developers adopting AnyLanguageModel.
  3. Staying Grounded: Every additional layer of abstraction, while often powerful, can also take developers further away from the core problem they are trying to solve. When abstractions become too numerous or too complex, they can morph into problems themselves. By grounding AnyLanguageModel in an existing, well-understood API, the resulting code remains clean, predictable, and significantly easier to manage.

The outcome of this approach is a system where switching between different LLM providers requires minimal code modifications, and the core abstractions remain intuitive and consistent.

Package Traits: Efficiency Through Selective Dependency

A common pitfall in creating multi-backend libraries is the issue of ‘dependency bloat.’ Developers shouldn’t be forced to pull in the entire ecosystem of dependencies for a backend they don’t intend to use. For instance, if your application’s needs are exclusively met by MLX models, you shouldn’t have to include the complex dependencies associated with llama.cpp.

AnyLanguageModel elegantly solves this problem using Swift 6.1 Package Traits. This feature allows developers to explicitly opt into the specific backends they require. This means you only pull in the code and dependencies relevant to your chosen LLM providers, keeping your project lean and efficient.

Here’s how you might declare your dependencies with specific traits:

dependencies: [
    .package(
        url: "https://github.com/mattt/AnyLanguageModel.git",
        from: "0.4.0",
        traits: ["MLX"] // Only pulls in MLX dependencies
    )
]

Currently, available traits include CoreML, MLX, and Llama (for both llama.cpp and llama.swift). By default, no heavy, external dependencies are bundled. You receive the core API, along with cloud provider integrations that rely only on standard URLSession networking.

For developers using Xcode projects, which currently do not directly support trait declarations within the Package Dependencies window, a simple workaround exists. You can create a small, internal Swift package that depends on AnyLanguageModel with your desired traits. This internal package can then be added as a local dependency to your main Xcode project. The project’s README provides detailed instructions for this process.

Expanding Horizons: Image Support and API Design

Vision-language models represent a significant leap forward in AI capabilities, enabling applications to describe images, extract text from screenshots, analyze complex charts, and answer questions based on visual information. However, Apple’s Foundation Models framework currently lacks direct support for sending images as part of prompts.

Building on an existing API means acknowledging and sometimes working within its current constraints. While it’s highly anticipated that Apple will introduce image support in a future release (perhaps iOS 18 or later), the potential of vision-language models is too great to wait. This is where AnyLanguageModel extends beyond the current offerings of Foundation Models.

AnyLanguageModel proactively addresses this by providing an extended API that accommodates image inputs. Here’s a glimpse of how you might send an image to a model like Anthropic’s Claude:

let model = AnthropicLanguageModel(
    apiKey: ProcessInfo.processInfo.environment["ANTHROPIC_API_KEY"]!,
    model: "claude-sonnet-4-5-20250929"
)
let session = LanguageModelSession(model: model)

let response = try await session.respond(
    to: "What's in this image?",
    image: .init(url: URL(fileURLWithPath: "/path/to/image.png"))
)

This is a deliberate, calculated risk. By extending beyond the current Foundation Models API, there’s a possibility that the design might diverge from Apple’s eventual implementation. However, this is precisely what deprecation warnings are for. Sometimes, the best approach is to build the API for the framework that doesn’t quite exist yet, anticipating future needs and capabilities.

Putting It to the Test: chat-ui-swift

To truly grasp the power and flexibility of AnyLanguageModel, we encourage you to explore chat-ui-swift. This open-source SwiftUI chat application serves as a practical demonstration of the library’s capabilities. It showcases:

  • Apple Intelligence Integration: Seamlessly integrates with Apple’s native AI features through Foundation Models on macOS 14+.
  • Hugging Face OAuth: Implements OAuth authentication for accessing gated models on Hugging Face, providing secure access to a wider range of AI resources.
  • Streaming Responses: Delivers real-time, streaming responses, enhancing the user experience and providing immediate feedback.
  • Chat Persistence: Includes features for saving and recalling chat history, allowing for continuity in user conversations.

chat-ui-swift is designed as a starting point. Feel free to fork it, extend its functionality, experiment with swapping out different models, and adapt it to your specific project requirements. It’s an excellent way to see how the different components of AnyLanguageModel fit together in a real-world application.

What Lies Ahead: The Future of Agentic Workflows

AnyLanguageModel is currently in its pre-1.0 phase, meaning its core API is stable, but there’s ongoing work to bring the full feature set of Apple’s Foundation Models to all supported adapters. Key areas of development include:

  • Tool Calling Across All Providers: Enabling LLMs to interact with external tools and services, a crucial step for building intelligent agents.
  • MCP Integration for Tools and Elicitations: Incorporating the Model Conversation Protocol (MCP) for enhanced tool usage and user interaction.
  • Guided Generation for Structured Outputs: Providing better control over the format and structure of AI-generated content.
  • Performance Optimizations: Continuously refining the performance of local inference to ensure maximum efficiency.

This library is envisioned as the foundational element for something larger: a unified inference API that provides the essential scaffolding for building seamless agentic workflows on Apple platforms. These are sophisticated applications where AI models can intelligently leverage tools, access system resources, and autonomously accomplish complex tasks. More details on this exciting vision will be shared soon. 🤫

Join the Movement: Get Involved!

We are immensely excited about the potential of AnyLanguageModel and invite the developer community to be a part of its evolution. Your feedback and contributions are invaluable in making this project the best it can be:

  • Try it Out: Download the package, build something, and put it through its paces.
  • Share Your Experiences: Tell us what works well and what presents challenges. We want to hear about the real-world hurdles you face integrating AI into your applications.
  • Open Issues: Report bugs, suggest new features, or ask questions on the project’s GitHub repository.
  • Contribute: Pull requests are warmly welcomed! If you have improvements or new features to offer, don’t hesitate to submit them.

Resources:

We can’t wait to see the incredible applications you’ll build with AnyLanguageModel! 🦾

Posted in Uncategorized