
In this blog post, I will share the code for a simple RCTBridgeModule that can write/read key-value from React Native.

The use case for this is to access the data in iOS Share Extension using value set from React Native.

So that the Share Extension can perform API call with sufficient data that was set in React Native, and thus giving user a much better experience similar to other natively built apps. This is a much more complicated implementation and there are much simpler ways to get it done without writing too many native code and that will be for another blog post.

Let's get back and focus on this topic, get and set value in `UserDefaults` that are accesible in Share Extension.
In order to achieve that, we need to use `UserDefaults` with `suiteName` that starts with `group.`.

Before you proceed, please make sure that you have already created Share Extension and updated `App Groups` in the `Signing & Capabilities`.
This is not covered in this post and there are alot of online resources for this topic.

<hr />

<br />

##### 1. First, create a header file in xcode.

I'll name it `SharedUserDefaults.h`

```
#ifndef SharedUserDefaults_h
#define SharedUserDefaults_h
#endif

#import <Foundation/Foundation.h>

#if __has_include(<React/RCTAssert.h>)
#import <React/RCTBridgeModule.h>
#else
#import "RCTBridgeModule.h"
#endif

@interface SharedUserDefaults : NSObject <RCTBridgeModule>
@end
```

<br />

##### 2. Then, create the implementation file.

`SharedUserDefaults.m`

```
#import <Foundation/Foundation.h>
#import "SharedUserDefaults.h"

@implementation SharedUserDefaults

RCT_EXPORT_MODULE()

+ (BOOL)requiresMainQueueSetup
{
  return YES;
}

RCT_EXPORT_METHOD(set:(NSString *)suiteName
                  key:(NSString *)keyName
                  value:(NSString *)value)
{
  NSUserDefaults *shareExtensionDefaults = [[NSUserDefaults alloc] initWithSuiteName: suiteName];
  [shareExtensionDefaults setObject:value forKey:keyName];
  NSLog(@"val written %@", value);
}

RCT_EXPORT_METHOD(get:(NSString *)suiteName
                  key:(NSString *)keyName
                  resolver: (RCTPromiseResolveBlock)resolve
                  rejecter:(RCTPromiseRejectBlock)reject)
{
  NSUserDefaults *shareExtensionDefaults = [[NSUserDefaults alloc] initWithSuiteName: suiteName];
  NSString *val = [shareExtensionDefaults stringForKey:keyName];
  if (val == nil) {
    NSError *error = [NSError errorWithDomain:@"org.reactjs.native.example.Bill" code:0 userInfo:@{ @"message": @"Empty" }];
    reject(@"error", @"error description", error);
  } else {
    resolve(val);
  }
}

@end
```

<br />

##### 3. Next, build and run your app.

And you can use the methods from the native module you've just written.

In your React Native project, you can now get and set key-value pair to UserDefaults via the native module.

```
import { NativeModules } from 'react-native';

const SharedUserDefaults = NativeModules.SharedUserDefaults;

// Usage

// Set
SharedUserDefaults.set("group.org.reactjs.native.example.YourProject", "yourKey", "some string to be stored");

// Get
let val = await SharedUserDefaults.get("group.org.reactjs.native.example.YourProject", "yourKey");
```

In iOS, the value can be retrieved in `ShareViewController.swift` or `AppDelegate.m`.

`Swift`

```
var userDefaults = UserDefaults(suiteName: "group.org.reactjs.native.example.YourProject")

// Get value stored earlier
let storedValue = userDefaults?.object(forKey: "yourKey") as? String

 // Set new value
userDefaults?.set("some string to be stored", forKey: "yourKey")
```

`Obj-C`

```
  NSUserDefaults *userDefaults = [[NSUserDefaults alloc] initWithSuiteName: @"group.org.reactjs.native.example.YourProject"];

  // Get value stored earlier
  NSString *val = [userDefaults stringForKey:@"yourKey"];

  // Set new value
  [userDefaults setObject:@"some string to be stored" forKey:@"yourKey"];
```

<br />

#### End

You are now all set!

Now you can set value from React Native and retrieve it in your `ShareViewController.swift`.

That's it! Hope it helps.

Cheers.

iOS Shared UserDefaults for App Extensions With RCTBridgeModule


In this post, I'll share the practical aspects of what I learned building iOS apps with Compose Multiplatform.

---

## Understanding the Internals

### Project Structure

A typical Compose Multiplatform project structure:

```
project/
├── iosApp/            # iOS-specific code (Swift/UIKit wrapper)
├── shared/            # Shared Kotlin code
│   ├── commonMain/    # Platform-agnostic code
│   ├── androidMain/   # Android-specific implementations
│   └── iosMain/       # iOS-specific implementations
└── composeApp/        # Shared Compose UI code
```

---


### From KMP project template

Here's a generated `ContentView.swift` from project template.

```swift
import SwiftUI
import Shared

struct ComposeView: UIViewControllerRepresentable {
    func makeUIViewController(context: Context) -> UIViewController {
        MainViewControllerKt.MainViewController()
    }

    func updateUIViewController(_ uiViewController: UIViewController, context: Context) {}
}

struct ContentView: View {
    var body: some View {
        ComposeView()
            .ignoresSafeArea(.all)
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

```

This exact code runs natively on iOS without any modifications.


Layer-by-layer view

```
iOS App
 └── SwiftUI
      └── UIViewControllerRepresentable
           └── UIKit UIViewController
                └── Compose Runtime
                     └── Skia / Metal rendering
```

In a Kotlin Multiplatform project using Compose Multiplatform on iOS, the UI is rendered through a layered architecture rather than directly by SwiftUI or UIKit.

SwiftUI acts only as the entry point of the app, embedding a UIViewController via UIViewControllerRepresentable.

That UIViewController is not responsible for laying out views or drawing UI elements; instead, it serves as a host required by iOS to participate in the app lifecycle.

This makes UIKit the structural container, ensuring compatibility with iOS windowing, lifecycle, and event delivery, while remaining largely unaware of how the UI itself is drawn.

Inside this UIKit container runs the Compose runtime, which owns layout, state, input handling, and rendering.
Compose does not use UIKit components like UILabel or UIButton;

Instead, it renders its UI using Skia, a cross-platform graphics engine, which in turn targets Metal for hardware-accelerated drawing on iOS.

Touch and system events flow from UIKit into the Compose runtime, but all visual output and UI logic remain entirely in Kotlin.

As a result, the app achieves a single shared UI codebase across Android and iOS, while still integrating cleanly into the native iOS application stack without relying on a JavaScript bridge or web-based rendering.

---

## The Future of Compose Multiplatform on iOS

Compose Multiplatform for iOS is rapidly maturing. Recent improvements include:
- Better performance optimizations
- Improved IDE support
- Growing ecosystem of libraries
- Better interop with Swift and SwiftUI

JetBrains is actively investing in the platform, with regular updates and improvements.

---

## Conclusion

Compose Multiplatform offers a compelling approach to iOS development, especially for teams already using Kotlin or building cross-platform apps. While it requires learning Kotlin and the Compose paradigm, the benefits of code sharing, type safety, and modern declarative UI make it a powerful tool in the mobile developer's toolkit.

The key is knowing when to use shared code and when to embrace platform-specific implementations. With the right balance, you can build high-quality iOS apps while maximizing code reuse across platforms.

Thanks for reading. Happy coding!


ios

iOS Shared UserDefaults for App Extensions With RCTBridgeModule

Building iOS Apps with Compose Multiplatform