Here are Libraries required:

• MLX Swift Core Library : Package providing the Swift bindings for MLX ( https://github.com/ml-explore/mlx-swift)
• mlx-community on Hugging Face: A collection of models already converted to the MLX format, ready to use (https://huggingface.co/mlx-community)
• Useful packages like MLXLLM and MLXVLM makes loading and running large language and vision language models easily.

Pre-trained Model contains several interconnected pieces that work together apart from the core neural network architecture.

• Model Architecture & Weights — This is the core neural network and the learned parameters (weights) which captures the model’s knowledge. The weights are usually stored in the .safetensors file - is a special file format designed to store these model weights securely and it is optimized for quick loading.
• Configuration file (config.json) — This contains the metadata of the model like `model_type`, `layer dimensions` , `vocabulary size`. This could be like a Info.plist file or any Key value files.
• Tokenizer — This component breaks down the text in to smaller pieces called “tokens” and converts them in to numerical ID’s or vectors and vice-versa. It’s like a special ‘JSONDecoder’ and ‘JSONEncoder’ rolled in to one. It has it’s own configuration ( tokenizer_config.json ) and vocabulary files. - Defines special tokens that convey structural information or control the signals to the model.
• EOS ( End of Sequence) , BOS (Beginning of Sequence) , UNK ( Unknown) , PAD(Padding) , Chat/Roles Tokens for eg: <iam_start|>system, <iam_start|>user , <iam_start|>assistant
• Processor ( for Multimodal Models) — Vision Language Models handling images or videos requires an additional component, a processor to prepare the visual input in to the format that model expects.

Anatomy of the Model

How They Work Together:

1. Loading Process: config.json tells the system what type of model to create.
2. Text Processing: Tokenizer files convert human text in to numbers or vectors the model understands.
3. Inference: Model weight process the tokenized input to generate predictions.
4. Output: Results are converted back to human readable text using the tokenizer.

Quantization: Making Models Device Friendly

Deploying multi gigabyte models directly onto mobile devices is often infeasible. Quantization is a key technique to address this, making models smaller and more efficient. It reduces the precision of the model weights instead of using standard 32 bit floating point(FP32), Weights are converted to lower precision formats like 16 bit floats (FP16), 8- bit integers (INT8) or 4 bit integers(INT4)

Using a Pre-defined Configurations like below which is provided by MLXLLM — LLM registry

Creating a Configuration Directly:

Loading a Model

• Model Source Detection: The ModelFactory starts with a ModelConfiguration shown above to determine whether the model is remote (Hugging Face Hub ID) or local (directory URL), then uses HubApi to handle downloads if needed.
• Intelligent Caching System: HubApi maintains a local cache (~/.cache/huggingface/hub) with metadata checking (ETags, commit hashes) to avoid unnecessary downloads, using a blob/snapshot structure to minimize disk usage across model versions.
• Model Instantiation: The factory reads config.json to identify the model type (e.g., “qwen3”), uses ModelTypeRegistry to call the appropriate Swift initializer, creating a model object without weights initially.
• Weight Loading and Processing: Load.loadWeights finds .safetensors files, loads parameters, applies model-specific preprocessing via sanitize(weights:), handles quantization if specified in the config.json MLXNN.quantize is used
• to apply quantization to the appropriate layers and populates the model with final weights using model.update(parameters:verify:)
• Complete Context Assembly: The factory loads the Tokenizer and UserInputProcessor (for VLMs) from their respective configuration files, then packages everything (ModelConfiguration, LanguageModel, Tokenizer, UserInputProcessor) into a final ModelContext.

Below is the snippet to load the model on to device. MLX caches it in Device support folders no need to load it again for subsequent launches.

How to create a Custom Model

Step 1: Set up your development environment

Open a new folder in VSCode, Cursor, PyCharm, or any Python environment tool of your choice.

python --version

Step 2: Create a Python virtual environment

Create a virtual environment to isolate your project dependencies:

python -m venv mlx-env
source mlx-env/bin/activate

Step 3: Install the required dependencies

Install the necessary packages for model conversion:

pip install mlx-lm
pip install -U "huggingface_hub[cli]"

Step 4: Login to Hugging Face

Authenticate with your Hugging Face account:

huggingface-cli login

Step 5: Execute the MLX convert command

Convert your model using the MLX conversion tool:

mlx_lm.convert --hf-path mobiuslabsgmbh/DeepSeek-R1-ReDistill-Qwen-1.5B-v1.0 -q --upload-repo XXXX/deepseek-r1-redistill-qwen-1.5b-mlx

Note: Replace XXXX with your actual Hugging Face username or organization name in the upload repository path.

Run Inference

Use the modelContainer’s perform method to access the modelContext and MLXLMCommon.generate to produce the text which can be streamed.

Experience will look like

Tool Calling Experience

Tool allows LLM to interact with external functions you define as part of its generation process. Instead of just relying on static training data, tool enabled LLM can do the following steps.

1. Analyze — Determine if external tools are needed
2. Select — Choose the appropriate tool
3. Request — Format parameters (JSON)
4. Execute — Pause generation, run tool
5. Respond — Use tool output in final answer

Define a tool protocol which has the name , description and display name and one for the arguments which needs to be passed to tool

Define another protocol for handling the Tool execution

See the implementation of WeatherTool Handler conforming to ToolHandlerProtocol

Inference Implementation for tool is available here. Below is how the experience of tool calling for weather with OnDevice Model.

I’ve open-sourced the complete implementation on GitHub, built with Clean Architecture principles to keep the code maintainable, reusable, scalable and extensible. Try it out, share your thoughts, and feel free to contribute — let’s build better on-device AI together!

#OnDeviceML #Swift #iOS #ML

MCP (Model Context Protocol) — is open protocol that standardizes how applications provide context to LLM’s. In simple it’s like a USB -C port for connecting to AU models to different data sources and tools.

It is intended for integrations across wide range of tools such as AI code editors (Cursor, VSCode, Claude Code etc..) and other applications. By leveraging natural language, MCP allows seamless interaction with multiple tools and data sources.

Thanks for reading Badarinath’s Substack! Subscribe for free to receive new posts and support my work.

In this article, we will create a server in Swift that can perform various swift Dev tools operations.

Creating a server

mkdir swift-dev-tools-mcp
cd swift-dev-tools-mcp
swift package init --type executable

Next add the official Swift SDK for Model Context Protocol servers and clients. Update the Package.swift file to include the SDK as dependency

Open main.swift and add the following code

Here we are creating a server with name and version. The capabilities parameters is used to define the capabilities of the server, In this case we are defining only the tools capability.

To start the server , we are using the StdioTransport class, which is a transport layer for the server. It allows the server to communicate with the client via standard input and output.

Next, we need to implement tools. The server will have multiple tools that return the following development environment information:

1. Swift Development Environment

• swift_version — Returns the current Swift compiler version, build information, and target architecture
• system_architecture — Returns the system architecture (arm64 for Apple Silicon, x86_64 for Intel)

2. Xcode Development Environment

• xcode_version — Returns the installed Xcode version and build number
• xcode_sdks — Returns all available Xcode SDKs for iOS, macOS, watchOS, tvOS, visionOS, and DriverKit

3. Device and Simulator Management

• list_simulator — Returns all available iOS and iPad simulators with their current status (Booted/Shutdown)
• connected_devices — Returns all connected physical devices (iPhone, iPad, Apple Watch, Mac) and their connection status

4. System Information

• macos_version — Returns the current macOS version, product name, and build version

Register all the tools with server.withMethodHandler(ListTools.self)

Note: Tool names should be in snake case and tools may have input schema for input parameters, it’s optional by specification.

To make server respond to tool, we need to implement the .withMethodHandler(CallTool.self) function. It will be called when the client requests the tool. The method should return a Result object with the result of the tool, as server can contain multiple tools, we can switch on tool name

In the end of the file, add a call to .waitUntilCompleted() to keep the server running.

Now , it’s time to build the package to generate the executable.

swift build

You will see the terminal output like below

Using MCP Servers in Cursor

Go to Cursor Settings → Tools & Integration, You will see a mcp.json

"mcpServers": {
    "swift-dev-tools-server": {
        "type": "stdio",
       "command": "<Path of the project>/swift-dev-tools-mcp/.build/arm64-apple-macosx/debug/swift-dev-tools-mcp"
    }
  }
}

Below are few natural language questions you can try with the tool.

“What Swift version am I running?”

“Show me all available iOS simulators”

“What Xcode version do I have installed?”

“List all my connected devices”

“What SDKs are available for development?”

“What macOS version am I on?”

“Am I running on Apple Silicon or Intel?”

“What’s my complete development environment setup?”

As next step we can extend this capability to accessible remotely via HomeBrew

Remote MCP Server via Home Brew

Execute the below command to configure the `swift-dev-tools-mcp` which could be used remotely.

brew tap badrinathvm/tap

brew install swift-dev-tools-mcp

Now we can use below json in the MCP clients

{
  "mcpServers": {
    "swift-version-server": {
      "type": "stdio",
      "command": "swift-dev-tools-mcp"
    }
  }
}

We welcome your contributions — just follow the guidelines when adding new tools. The code is available on 📦 Homebrew Tap and 🛠️ Main Project

Happy Coding!!

Thanks for reading Badarinath’s Substack! Subscribe for free to receive new posts and support my work.

How does share extension looks like ?

You can create Share extension target by clicking on “+” at the bottom and choose a template like below.

Select the share extension from the scheme section. On click of Run Choose an app to execute few examples include Photos, Safari, Calendar, Contacts etc..

Once the target is created, Since i do not work with storyboard, i remove MainInterface.storyboard from the share extension folder and replace the key NSExtensionMainStoryboard from the extension’s Info.plist with the key NSExtensionPrincipalClass inside the NSExtension dictionary having a value of $(PRODUCT_MODULE_NAME).ShareViewController .

Next i will use ShareViewController.swift as mentioned below.

How does action extension will look like ?

Below are few examples of action targets.

Print with Epson — Opens the Epson app, deeplinks the selected file for printing it.

Save to Dropbox — Opens the Dropbox app, deeplinks the selected file for saving to desired folder of your choice.

Save to Files — Opens the Files app, deeplinks the selected file for saving to desired folder of your choice.

You can create action extension target by clicking on “+” at the bottom and choose a template like below.

Just like Share extension target , make sure to update the info.plist for NSExtensionPrincipalClass inside the NSExtension dictionary having a value of $(PRODUCT_MODULE_NAME).ActionViewController

Below is the code with regards to ActionViewController

Types of UTI’s (Uniform Type Identifiers)

1. public.text — Represents the plain text data. This action extension handles text-based content, such as copying text from webpage or a document.
2. public.image — Represents the image data. This action extension handles images.
3. public.url — Represents URL’s. This action extension handles URLs such as sharing links from web browser or a messaging app.
4. public.audio — Represents the audio data. This is required if your action extension handles audio files or audio recordings.
5. public.movie — Represents the video data. You might need this if the action extension handles video files or video recordings.
6. public.data — Represents generic binary data. This is required if your action extension handles any other types of data that are not covered by the more specific UTI’s mentioned above.

based on the needs , corresponding UTI can be configured in the Info.plist for NSExtensionActivationRule key

Debugging

Debugging an app extension is not straightforward but possible, regardless. While you cannot debug the app and its share extension at the same time, you can determine the target to be debugged. In XCode, navigate to Debug, Attach to process, and select the app extension’s process. Now, breakpoints should be triggered as you are used to with the containing app.

Code Sharing

A share extension is a separate target, meaning that it does not share any source code with the corresponding app. If you still want to share source code between the app and the share extension, you have to change the target membership of the source code to be shared. In XCode, you can easily select the target membership by ticking the corresponding boxes under Target Membership from the inspector on the right-hand side after opening the desired source code file.

We can also make use of App Groups to share the data between the main app the target extensions.

PhaseScriptExecution [CP]\ Check\ Pods\ Manifest.lock /Users/xxx/Library/Developer/Xcode/DerivedData/xxx/Build/Intermediates.noindex/xxx.build/Debug\ (Staging)-iphonesimulator/OV.build/Script-05BB3CCD2FBD4842F78B0F4F.sh (in target 'xxx' from project 'xxx')
    cd /Users/xxx/Documents/Projects/<project-name>
    /bin/sh -c /Users/xxx/Library/Developer/Xcode/DerivedData/xxx/Build/Intermediates.noindex/xxx.build/Debug\\\ \\\(Staging\\\)-iphonesimulator/xxx.build/Script-05BB3CCD2FBD4842F78B0F4F.sh

error: unable to spawn process (Argument list too long) (in target 'xxx' from project 'xxx')

The direct solution to fix this problem is setiing the build system to Legacy Build Sysrtem via ‘File -> Workspace Settings’

Legacy Build System could work till Xcode 11.x versions. However, with Xcode 12.x the above approach won't work as the Legacy Build system will be deprecated in future versions of Xcode.

Bummer !!! What’s the solution? How can we fix it?

The solution is to inspect the below Build Setting properties.

Make sure these Custom compiler Flags contain only compiler related items

OTHER_CFLAGS=”-fprofile-arcs -ftest-coverage”

OTHER_CPLUSPLUSGLAGS=-g ‘-std=c++14’ -Wno-objc-designated-initializers -fobjc-arc -g

However, with pod install these fields will be appended with $(inherited) values of the pods listed in the podfile creating huge number of enytries which is causing “Arguments list too long (Unable to spwan the process /bin/sh)

Hope this helps, Feel free to comment for any more clarifications. Happy Coding !!

Writing tests for any piece of code is important for maintaining the quality of software which brings more confidence to product delivery. In today’s world most of the code are modularized and bundled to a library/pod making it easier to share, reuse across, managing deployment and release activities etc.. Writing unit tests for modularized code could be achieved comfortably along side with feature development by adopting techniques like TDD. However, the main challenge is how to share integration/ui tests to hosting apps for modularized code. Luckily, there’s a way to do it with “test-specs” in Podfile via Cocoapods.

Cocoapods can extend the capability of providing UI test specifications, a convenient way of shipping UI tests along with it’s sources to any of the hosting apps, so that app’s consuming this library no longer need to write any UI tests for the features delivered.

Follow below steps for setup

1. Add below code in the podspec file

Pod::Spec.new do |spec|
  spec.name         = 'SampleLibrary'
  spec.version      = '1.0'

  spec.test_spec 'Tests' do |test_spec|
     test_spec.requires_app_host = true
     test_spec.test_type = :ui
     test_spec.source_files = 'SampleApp/SampleApp-UITests/SampleTest.swift'
end

2. Bring the test specification to Podfile, tie it with :testspecs, the name should match with the one added in podspec file

target 'SampleApp' do
  use_frameworks!
  pod 'SampleLibrary', '~> 1.0', :testspecs => ['Tests'] 
end

3. Perform pod install , examine Pods.xcodeproj , a new target for UI test will be generated with name SampleLibrary-UI-Tests, if you notice test target name would be set to AppHost-SampleLibrary-UI-Tests in Build Settings like below.

4. Next, we need to set the update the TEST_TARGET_NAME to “SampleApp” to execute the UI tests shared as part of :testspec, in order to achieve this, add post_install step in podfile to update the build setting configuration and then perform “ pod install” which regenerates the Pods.xcodeproj with proper target setting.

post_install do |installer|
  installer.pods_project.targets.each do |target|
    target.build_configurations.each do |config|
       if target.name == "SampleLibrary-UI-Tests"
           config.build_settings['TEST_TARGET_NAME'] = "SampleApp"
       end
     end
   end
end

5. To execute tests, first enable the scheme by pressing “Command + 6” -> Right Click on “SampleLibrary-UI-Tests” -> Enable “SampleLibrary-UI-Tests”, once it is enabled click on play button.

Visual conception of the library

Here’s the library which does the work with just couple of lines which accepts below View Modifiers

.addSteps(_ steps: [View]) : array of views to be rendered closer to indicator

.alignments(_ alignments: [StepperAlignment]) : optional defaults to .center, available with custom options either .top, .center, .bottom sections

.indicatorTypes(_ indicators:[StepperIndicationType]): enum provides the options to use .circle(color, width) , .image(Image, width) , .custom(AnyView)

.lineOptions(_ options: StepperLineOptions): color, thickness line customization.

.spacing(_ value: CGFloat): spacing between each of the step views.

.stepIndicatorMode(_ mode: StepperMode): vertical, horizontal display modes.

var body: some View {
         StepperView()
            .addSteps([Text("Account"), Text("MemberShip"))
            .indicators([.center,.center])
            .stepIndicatorMode(StepperMode.horizontal)
            .spacing(50)
            .lineOptions(StepperLineOptions.custom(1, Colors.blue(.teal).rawValue))
}

This library handles top, center and bottom alignments. Above are some variation screenshots.

References:

More Details : https://badrinathvm.github.io/StepperView/

cocoapods:

StepperView

Github: https://github.com/badrinathvm/StepperView

Feel free to request any new features or create a pull request.

Happy Coding..!

Implement a struct with single Rectangle with index parameter for each view to start and stop the animation programmatically via publisher with PassthroughSubject is passed as a parameter — which sends stream of values from their origin to it’ subscribers. The PassthroughSubject's subscribers can use this information to update the state of the UI or to handle the occurred event. In .onReceive will have access to the value sent by the publisher to act on to update the UI state.

@State Variable animate is set to true or false based on the value received from the publisher to control the opacity of the RectangleView

Next, create ProgressView( see the references link below) with @state currentIndex,publisher variables. In it’s .onAppear pass the value via publisher to the it’s subscriber RectangleView in this case

PassthroughSubject takes AnimationStatus enum to start, stop at particular index and completely everything.

References : https://gist.github.com/badrinathvm/13b79f1d6dfd30ea54a106dc1d805953

Happy Coding !!

Let’s say if we have any UIViewController to be used on any SwiftUI based app we have to follow below steps

Extend the protocol UIViewControllerRepresentable

Implement makeUIViewController and updateUIViewController

However writing a wrapper provides easier way to use it inline for any of the viewControllers.

Here two closures one each for the requirement of UIViewControllerRepresentable.

@autoclsore which will enable us to keep the conventions of UIViewControllerRepresentable and create our views lazily without requiring any additional syntax during calling.

When accessing a ViewController there might be some cases where accessing Context might be required , so let’s added some convenience initializers with just ViewController and without Context

Here’s the usage of it, let’s say u have EntryViewController

References : https://gist.github.com/badrinathvm/aa88ec0b66b99d4acb85f7069ae40625

Happy Coding..!!

Follow below steps

1. Make SwiftUI View ready

2. Include it in UIKit Code like below.

3. If the project is supporting version ≤= iOS 12.0 , Update the Build Settings of Xcode like below.

Expand Link Binary With Libraries then Click on + and then Add SwiftUI.framework and make it Optional

4. In case, if you have added SwiftUI View as part of Development pod, make sure to update the podspec file with below config.

spec.xcconfig = { ‘OTHER_LDFLAGS’ => ‘-weak_framework “SwiftUI”’ }

Then perform pod install , make to validate the other Linker Flags should like below.

Idea is to have a stack view of button aligned horizontally or vertically as per specification.

Follow below steps:

1. Construct mainStackview for UIImageButton
2. rootStackView contains series of buttons. ( like $,$$, $$$, etc.. )
3. Pin both mainStackView & rootStackView inside the UIView to establish corner radius functionality.
4. Have key variables like widthConstraint, buttonsAreHidden ,updateButtonImage. These variables values will be altered during expanding /unexpanding the buttons via didSet

performAnimation is called when button is toggled, this method performs below functionalities

Hides the rootStackView

update the button image to dotted_filled

hiding the sub layers left borders while animation is happening

update the width Constraint

remove constraints if any

Complete source code available in Github

Any feedback is really appreciated. Happy Coding. !!