diff --git a/.changeset/red-llamas-love.md b/.changeset/red-llamas-love.md
new file mode 100644
index 00000000..7e97b291
--- /dev/null
+++ b/.changeset/red-llamas-love.md
@@ -0,0 +1,8 @@
+---
+'@callstack/brownie': minor
+'@callstack/brownfield-cli': minor
+'brownfield': minor
+'@callstack/react-native-brownfield': minor
+---
+
+add brownie android
diff --git a/apps/AndroidApp/app/build.gradle.kts b/apps/AndroidApp/app/build.gradle.kts
index 2b6cd3a6..f724fdcd 100644
--- a/apps/AndroidApp/app/build.gradle.kts
+++ b/apps/AndroidApp/app/build.gradle.kts
@@ -49,11 +49,11 @@ android {
         }
     }
     compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_11
-        targetCompatibility = JavaVersion.VERSION_11
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
     }
     kotlinOptions {
-        jvmTarget = "11"
+        jvmTarget = "17"
     }
     buildFeatures {
         compose = true
@@ -61,6 +61,7 @@ android {
 }
 
 dependencies {
+    implementation("com.google.code.gson:gson:2.13.1")
     implementation(libs.androidx.core.ktx)
     implementation(libs.androidx.lifecycle.runtime.ktx)
     implementation(libs.androidx.activity.compose)
diff --git a/apps/AndroidApp/app/src/expo/java/com/callstack/brownfield/android/example/BrownfieldStore.kt b/apps/AndroidApp/app/src/expo/java/com/callstack/brownfield/android/example/BrownfieldStore.kt
new file mode 100644
index 00000000..c7499219
--- /dev/null
+++ b/apps/AndroidApp/app/src/expo/java/com/callstack/brownfield/android/example/BrownfieldStore.kt
@@ -0,0 +1,4 @@
+package com.callstack.brownfield.android.example
+
+typealias BrownfieldStore = com.callstack.rnbrownfield.demo.expoapp.BrownfieldStore
+typealias User = com.callstack.rnbrownfield.demo.expoapp.User
diff --git a/apps/AndroidApp/app/src/main/java/com/callstack/brownfield/android/example/MainActivity.kt b/apps/AndroidApp/app/src/main/java/com/callstack/brownfield/android/example/MainActivity.kt
index 1d265bc0..4765cbbb 100644
--- a/apps/AndroidApp/app/src/main/java/com/callstack/brownfield/android/example/MainActivity.kt
+++ b/apps/AndroidApp/app/src/main/java/com/callstack/brownfield/android/example/MainActivity.kt
@@ -26,6 +26,7 @@ import androidx.fragment.compose.AndroidFragment
 import com.callstack.brownfield.android.example.components.GreetingCard
 import com.callstack.brownfield.android.example.components.PostMessageCard
 import com.callstack.brownfield.android.example.ui.theme.AndroidBrownfieldAppTheme
+import com.callstack.brownie.registerStoreIfNeeded
 import com.callstack.reactnativebrownfield.ReactNativeFragment
 import com.callstack.reactnativebrownfield.constants.ReactNativeFragmentArgNames
 
@@ -48,6 +49,15 @@ class MainActivity : AppCompatActivity() {
                     Toast.LENGTH_LONG
                 ).show()
             }
+
+            registerStoreIfNeeded(
+                storeName = BrownfieldStore.STORE_NAME
+            ) {
+                BrownfieldStore(
+                    counter = 0.0,
+                    user = User(name = "Username")
+                )
+            }
         }
 
         setContent {
diff --git a/apps/AndroidApp/app/src/main/java/com/callstack/brownfield/android/example/components/GreetingCard.kt b/apps/AndroidApp/app/src/main/java/com/callstack/brownfield/android/example/components/GreetingCard.kt
index 06f4b81d..1f04e99f 100644
--- a/apps/AndroidApp/app/src/main/java/com/callstack/brownfield/android/example/components/GreetingCard.kt
+++ b/apps/AndroidApp/app/src/main/java/com/callstack/brownfield/android/example/components/GreetingCard.kt
@@ -8,20 +8,42 @@ import androidx.compose.material3.Button
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
+import com.callstack.brownfield.android.example.BrownfieldStore
+import com.callstack.brownie.Store
+import com.callstack.brownie.StoreManager
+import com.callstack.brownie.store
+import com.callstack.brownie.subscribe
+
+private fun brownieStore(): Store<BrownfieldStore>? {
+    return StoreManager.shared.store(BrownfieldStore.STORE_NAME)
+}
 
 @Composable
 fun GreetingCard(
     name: String,
 ) {
-    var counter by rememberSaveable { mutableIntStateOf(0) }
+    var counter by remember { mutableIntStateOf(0) }
+
+    DisposableEffect(Unit) {
+        val store = brownieStore()
+        val unsubscribe = store?.subscribe(
+            selector = { state -> state.counter.toInt() },
+            onChange = { updatedCounter -> counter = updatedCounter }
+        ) ?: {}
+
+        onDispose {
+            unsubscribe()
+        }
+    }
 
     MaterialCard {
         Column(
@@ -43,7 +65,11 @@ fun GreetingCard(
                 style = MaterialTheme.typography.bodyMedium
             )
 
-            Button(onClick = { counter++ }) {
+            Button(onClick = {
+                brownieStore()?.set { state ->
+                    state.copy(counter = state.counter + 1)
+                }
+            }) {
                 Text("Increment counter")
             }
         }
diff --git a/apps/AndroidApp/app/src/vanilla/java/com/callstack/brownfield/android/example/BrownfieldStore.kt b/apps/AndroidApp/app/src/vanilla/java/com/callstack/brownfield/android/example/BrownfieldStore.kt
new file mode 100644
index 00000000..299418d3
--- /dev/null
+++ b/apps/AndroidApp/app/src/vanilla/java/com/callstack/brownfield/android/example/BrownfieldStore.kt
@@ -0,0 +1,4 @@
+package com.callstack.brownfield.android.example
+
+typealias BrownfieldStore = com.rnapp.brownfieldlib.BrownfieldStore
+typealias User = com.rnapp.brownfieldlib.User
diff --git a/apps/ExpoApp/components/counter/index.ios.tsx b/apps/ExpoApp/components/counter/index.ios.tsx
deleted file mode 100644
index 52b3ccab..00000000
--- a/apps/ExpoApp/components/counter/index.ios.tsx
+++ /dev/null
@@ -1,33 +0,0 @@
-import { StyleSheet, Text, Button } from 'react-native';
-import { useStore } from '@callstack/brownie';
-
-const Counter = () => {
-  const [counter, setState] = useStore('BrownfieldStore', (s) => s.counter);
-
-  return (
-    <>
-      <Text style={styles.text}>Count: {counter}</Text>
-
-      <Button
-        onPress={() => setState((prev) => ({ counter: prev.counter + 1 }))}
-        title="Increment"
-      />
-    </>
-  );
-};
-
-export default Counter;
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    padding: 20,
-  },
-  text: {
-    fontSize: 30,
-    fontWeight: 'bold',
-    margin: 10,
-  },
-});
diff --git a/apps/ExpoApp/components/counter/index.tsx b/apps/ExpoApp/components/counter/index.tsx
index ccdee4a6..04eea002 100644
--- a/apps/ExpoApp/components/counter/index.tsx
+++ b/apps/ExpoApp/components/counter/index.tsx
@@ -1,9 +1,17 @@
-import { StyleSheet, Text } from 'react-native';
+import { StyleSheet, Text, Button } from 'react-native';
+import { useStore } from '@callstack/brownie';
 
 const Counter = () => {
+  const [counter, setState] = useStore('BrownfieldStore', (s) => s.counter);
+
   return (
     <>
-      <Text style={styles.text}>Brownie: To be implemented</Text>
+      <Text style={styles.text}>Count: {counter}</Text>
+
+      <Button
+        onPress={() => setState((prev) => ({ counter: prev.counter + 1 }))}
+        title="Increment"
+      />
     </>
   );
 };
@@ -12,7 +20,7 @@ export default Counter;
 
 const styles = StyleSheet.create({
   text: {
-    fontSize: 18,
+    fontSize: 30,
     fontWeight: 'bold',
     margin: 10,
   },
diff --git a/apps/ExpoApp/package.json b/apps/ExpoApp/package.json
index 9244f052..ddcc4dad 100644
--- a/apps/ExpoApp/package.json
+++ b/apps/ExpoApp/package.json
@@ -44,5 +44,9 @@
     "eslint": "^9.25.0",
     "eslint-config-expo": "~10.0.0",
     "typescript": "~5.9.2"
+  },
+  "brownie": {
+    "kotlin": "./android/brownfieldlib/src/main/java/com/callstack/rnbrownfield/demo/expoapp/Generated/",
+    "kotlinPackageName": "com.callstack.rnbrownfield.demo.expoapp"
   }
 }
diff --git a/apps/RNApp/package.json b/apps/RNApp/package.json
index 07ea82c4..3613959f 100644
--- a/apps/RNApp/package.json
+++ b/apps/RNApp/package.json
@@ -45,6 +45,10 @@
     "react-test-renderer": "19.1.1",
     "typescript": "^5.9.3"
   },
+  "brownie": {
+    "kotlin": "./android/BrownfieldLib/src/main/java/com/rnapp/brownfieldlib/Generated/",
+    "kotlinPackageName": "com.rnapp.brownfieldlib"
+  },
   "engines": {
     "node": ">=20"
   }
diff --git a/apps/RNApp/src/components/counter/index.ios.tsx b/apps/RNApp/src/components/counter/index.ios.tsx
deleted file mode 100644
index 8693fa1d..00000000
--- a/apps/RNApp/src/components/counter/index.ios.tsx
+++ /dev/null
@@ -1,40 +0,0 @@
-import { StyleSheet, Text, Button } from 'react-native';
-import { useStore } from '@callstack/brownie';
-
-type CounterProps = {
-  colors: { primary: string; secondary: string };
-};
-
-const Counter = ({ colors }: CounterProps) => {
-  const [counter, setState] = useStore('BrownfieldStore', (s) => s.counter);
-
-  return (
-    <>
-      <Text style={[styles.text, { color: colors.secondary }]}>
-        Count: {counter}
-      </Text>
-
-      <Button
-        onPress={() => setState((prev) => ({ counter: prev.counter + 1 }))}
-        color={colors.secondary}
-        title="Increment"
-      />
-    </>
-  );
-};
-
-export default Counter;
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    padding: 20,
-  },
-  text: {
-    fontSize: 30,
-    fontWeight: 'bold',
-    margin: 10,
-  },
-});
diff --git a/apps/RNApp/src/components/counter/index.tsx b/apps/RNApp/src/components/counter/index.tsx
index fa9f280c..20ca26e4 100644
--- a/apps/RNApp/src/components/counter/index.tsx
+++ b/apps/RNApp/src/components/counter/index.tsx
@@ -1,15 +1,24 @@
-import { StyleSheet, Text } from 'react-native';
+import { Button, StyleSheet, Text } from 'react-native';
+import { useStore } from '@callstack/brownie';
 
 type CounterProps = {
   colors: { primary: string; secondary: string };
 };
 
 const Counter = ({ colors }: CounterProps) => {
+  const [counter, setState] = useStore('BrownfieldStore', (s) => s.counter);
+
   return (
     <>
       <Text style={[styles.text, { color: colors.secondary }]}>
-        Brownie: To be implemented
+        Count: {counter}
       </Text>
+
+      <Button
+        onPress={() => setState((prev) => ({ counter: prev.counter + 1 }))}
+        color={colors.secondary}
+        title="Increment"
+      />
     </>
   );
 };
diff --git a/docs/docs/docs/api-reference/brownie/_meta.json b/docs/docs/docs/api-reference/brownie/_meta.json
index 5128b934..96caecdb 100644
--- a/docs/docs/docs/api-reference/brownie/_meta.json
+++ b/docs/docs/docs/api-reference/brownie/_meta.json
@@ -24,6 +24,11 @@
     "name": "typescript-usage",
     "label": "TypeScript Usage"
   },
+  {
+    "type": "file",
+    "name": "android-usage",
+    "label": "Android Usage"
+  },
   {
     "type": "file",
     "name": "swift-usage",
diff --git a/docs/docs/docs/api-reference/brownie/android-usage.mdx b/docs/docs/docs/api-reference/brownie/android-usage.mdx
new file mode 100644
index 00000000..bbeb398b
--- /dev/null
+++ b/docs/docs/docs/api-reference/brownie/android-usage.mdx
@@ -0,0 +1,134 @@
+# Android Usage
+
+Use stores in Android apps with Kotlin.
+
+This page shows the recommended path first, then advanced customization APIs.
+
+## Easy Path (Recommended)
+
+Use generated Kotlin types with the built-in Gson serializer.
+
+### 1. Register Store Once
+
+Register your store during app startup (for example in `Activity.onCreate` when `savedInstanceState == null`):
+
+```kotlin
+import com.callstack.brownie.registerStoreIfNeeded
+import com.callstack.rnapp.brownfieldlib.BrownfieldStore
+import com.callstack.rnapp.brownfieldlib.User
+
+registerStoreIfNeeded(
+  storeName = BrownfieldStore.STORE_NAME
+) {
+  BrownfieldStore(
+    counter = 0.0,
+    user = User(name = "Username")
+  )
+}
+```
+
+`registerStoreIfNeeded` returns `null` when the same key is already registered, which keeps registration idempotent across lifecycle re-entries.
+
+### 2. Retrieve the Typed Store
+
+```kotlin
+import com.callstack.brownie.Store
+import com.callstack.brownie.StoreManager
+import com.callstack.brownie.store
+import com.callstack.rnapp.brownfieldlib.BrownfieldStore
+
+val store: Store<BrownfieldStore>? = StoreManager.shared.store(BrownfieldStore.STORE_NAME)
+```
+
+### 3. Read, Update, and Subscribe
+
+```kotlin
+// Read current state
+val current = store?.state
+
+// Update whole state with copy()
+store?.set { state ->
+  state.copy(counter = state.counter + 1)
+}
+
+// Subscribe to full state changes
+val unsubscribe = store?.subscribe { newState ->
+  println("Counter: ${newState.counter}")
+}
+
+// Subscribe to a selected slice only
+val unsubscribeCounter = store?.subscribe(
+  selector = { state -> state.counter.toInt() },
+  onChange = { counter -> println("Counter: $counter") }
+)
+
+// Cleanup subscription
+unsubscribe?.invoke()
+unsubscribeCounter?.invoke()
+```
+
+## Advanced Path (Custom Serialization)
+
+Use this when default Gson serialization is not enough (custom formats, compatibility rules, encrypted payloads, etc.).
+
+### Option A: Custom Serializer Interface
+
+```kotlin
+import com.callstack.brownie.BrownieStoreSerializer
+import com.callstack.brownie.brownieStoreDefinition
+import com.callstack.brownie.register
+
+data class SessionState(val token: String, val expiresAt: Long)
+
+object SessionSerializer : BrownieStoreSerializer<SessionState> {
+  override fun encode(state: SessionState): String {
+    // Replace with your own format
+    return """{"token":"${state.token}","expiresAt":${state.expiresAt}}"""
+  }
+
+  override fun decode(snapshotJson: String): SessionState {
+    // Replace with your own parser
+    TODO("Decode snapshotJson into SessionState")
+  }
+}
+
+val sessionStore = brownieStoreDefinition(
+  storeName = "SessionStore",
+  serializer = SessionSerializer
+).register(
+  initialState = SessionState(token = "", expiresAt = 0L)
+)
+```
+
+### Option B: Encode/Decode Lambdas
+
+```kotlin
+import com.callstack.brownie.brownieStoreDefinition
+import com.callstack.brownie.register
+
+data class SessionState(val token: String, val expiresAt: Long)
+
+val sessionStore = brownieStoreDefinition(
+  storeName = "SessionStore",
+  encode = { state ->
+    """{"token":"${state.token}","expiresAt":${state.expiresAt}}"""
+  },
+  decode = { snapshotJson ->
+    // Replace with your own parser
+    TODO("Decode snapshotJson into SessionState")
+  }
+).register(
+  initialState = SessionState(token = "", expiresAt = 0L)
+)
+```
+
+Both advanced options produce the same `Store<State>` API as the easy path.
+
+## API Summary
+
+- `registerStoreIfNeeded(storeName, initialState)` - Easy one-time registration.
+- `registerStore(storeName, initialState)` - Always creates/registers store.
+- `brownieStoreDefinition(...)` - Store definition API (default or custom serializer).
+- `StoreManager.shared.store<T>(key)` - Retrieve typed store by key.
+- `Store.set { ... }` - Update full typed state.
+- `Store.subscribe { ... }` and selector `subscribe(...)` - Observe state changes.
diff --git a/docs/docs/docs/api-reference/brownie/getting-started.mdx b/docs/docs/docs/api-reference/brownie/getting-started.mdx
index 6a792772..0390d0e3 100644
--- a/docs/docs/docs/api-reference/brownie/getting-started.mdx
+++ b/docs/docs/docs/api-reference/brownie/getting-started.mdx
@@ -1,25 +1,30 @@
 # Getting Started
 
-This guide walks you through setting up Brownie from scratch - defining stores, generating native types, building XCFrameworks, and using shared state in both React Native and Swift.
+This guide walks you through setting up Brownie from scratch and then integrating it per platform.
 
 ## Prerequisites
 
 Before starting, ensure you have:
 
 - Completed the [React Native Brownfield Quick Start](/docs/getting-started/quick-start) guide
+- Completed the [iOS Integration](/docs/getting-started/ios) guide
+- Completed the [Android Integration](/docs/getting-started/android) guide
 - React Native project with `@callstack/react-native-brownfield` installed
-- Native iOS app (SwiftUI or UIKit)
-- Xcode 15+
+- Native host app (iOS and/or Android)
+- Xcode 15+ (for iOS)
+- Android Studio (for Android)
 
-## Step 1: Install Brownie
+## Shared Setup
 
-In your React Native project:
+### Step 1: Install Brownie
+
+In your React Native app:
 
 ```bash
 npm install @callstack/brownie
 ```
 
-## Step 2: Define Your Store
+### Step 2: Define Your Store
 
 Create a store definition file with the `.brownie.ts` extension:
 
@@ -45,7 +50,7 @@ Import the store in your app entry point:
 import './stores/AppStore.brownie';
 ```
 
-## Step 3: Use the Store in React Native
+### Step 3: Use the Store in React Native
 
 ```tsx
 import { useStore } from '@callstack/brownie';
@@ -65,15 +70,17 @@ function Counter() {
 }
 ```
 
-## Step 4: Build XCFrameworks
+## iOS
+
+### Step 4: Build XCFrameworks
 
-The CLI generates native types and builds everything into XCFrameworks:
+The CLI generates Swift types and builds iOS artifacts:
 
 ```bash
 npx brownfield package:ios --scheme YourScheme --configuration Release
 ```
 
-This produces the following in `ios/.brownfield/package/`:
+This produces files in `ios/.brownfield/package/`:
 
 - `YourScheme.xcframework` - Your React Native module
 - `Brownie.xcframework` - Shared state library
@@ -84,13 +91,13 @@ This produces the following in `ios/.brownfield/package/`:
 The `package:ios` command automatically runs `brownfield codegen` to generate Swift types from your `.brownie.ts` files.
 :::
 
-## Step 5: Add Frameworks to Native App
+### Step 5: Add Frameworks to Native App
 
 1. Open your native Xcode project
 2. Drag all XCFrameworks from `ios/.brownfield/package/` into your project
 3. In target settings → **General** → **Frameworks, Libraries, and Embedded Content**, set all to **Embed & Sign**
 
-## Step 6: Register Store in Swift
+### Step 6: Register Store in Swift
 
 In your app's entry point, register the store with initial state:
 
@@ -119,7 +126,7 @@ struct MyApp: App {
 }
 ```
 
-## Step 7: Use the Store in SwiftUI
+### Step 7: Use the Store in SwiftUI
 
 ```swift
 import Brownie
@@ -139,13 +146,98 @@ struct CounterView: View {
 }
 ```
 
+## Android
+
+### Step 4: Add brownie configuration
+
+Add the following block to your package.json:
+
+```json
+"brownie": {
+  "kotlin": "./android/BrownfieldLib/src/main/java/com/rnapp/brownfieldlib/Generated/",
+  "kotlinPackageName": "com.rnapp.brownfieldlib"
+},
+```
+
+### Step 5: Add gson dependency
+
+Add the gson dependency to your android module for brownfield:
+
+```kts
+api("com.google.code.gson:gson:2.13.1")
+```
+
+Otherwise, you can also add it to your native App:
+
+```kts
+implementation("com.google.code.gson:gson:2.13.1")
+```
+
+### Step 6: Add AAR
+
+The CLI generates Kotlin types and builds AAR:
+
+```bash
+npx brownfield package:android --module-name :YourModuleName --variant release
+```
+
+Once it succeeds, publish the AAR to local maven:
+
+```bash
+npx brownfield publish:android --module-name :YourModuleName
+```
+
+:::info
+The `package:android` command automatically runs `brownfield codegen` to generate Kotlin types from your `.brownie.ts` files.
+:::
+
+### Step 7: Register Store in Android
+
+Register once during app startup:
+
+```kotlin
+import com.callstack.brownie.registerStoreIfNeeded
+import com.rnapp.brownfieldlib.AppStore
+
+registerStoreIfNeeded(
+  storeName = AppStore.STORE_NAME
+) {
+  AppStore(counter = 0.0)
+}
+```
+
+### Step 8: Read and Update Store from Native UI
+
+```kotlin
+import com.callstack.brownie.StoreManager
+import com.callstack.brownie.store
+import com.rnapp.brownfieldlib.AppStore
+
+val store = StoreManager.shared.store<AppStore>(AppStore.STORE_NAME)
+
+// Read
+val counter = store?.state?.counter ?: 0.0
+
+// Update
+store?.set { state ->
+  state.copy(counter = state.counter + 1)
+}
+
+// Observe
+val unsubscribe = store?.subscribe(
+  selector = { state -> state.counter.toInt() },
+  onChange = { updated -> println("Counter: $updated") }
+)
+```
+
 ## Done!
 
-State changes now sync automatically between React Native and Swift. Increment from either side and both update immediately.
+State changes now sync automatically between React Native and native host code on both platforms.
 
 ## Next Steps
 
 - [Defining Stores](/docs/api-reference/brownie/store-definition) - Nested objects and multiple stores
 - [TypeScript Usage](/docs/api-reference/brownie/typescript-usage) - Advanced React Native patterns
 - [Swift Usage](/docs/api-reference/brownie/swift-usage) - UIKit integration and API reference
+- [Android Usage](/docs/api-reference/brownie/android-usage) - Kotlin setup, easy path, and advanced serializers
 - [XCFramework Packaging](/docs/api-reference/brownie/xcframework-packaging) - SPM distribution and advanced options
diff --git a/docs/docs/docs/api-reference/brownie/overview.mdx b/docs/docs/docs/api-reference/brownie/overview.mdx
index 40d997f1..7e9f2567 100644
--- a/docs/docs/docs/api-reference/brownie/overview.mdx
+++ b/docs/docs/docs/api-reference/brownie/overview.mdx
@@ -16,10 +16,10 @@ Brownie is a shared state management library for React Native brownfield apps. I
 
 ## Platform Support
 
-| Platform | Status      |
-| -------- | ----------- |
-| iOS      | Supported   |
-| Android  | Coming soon |
+| Platform | Status    |
+| -------- | --------- |
+| iOS      | Supported |
+| Android  | Supported |
 
 ## How It Works
 
@@ -42,3 +42,4 @@ Brownie is a shared state management library for React Native brownfield apps. I
 - [Code Generation](/docs/api-reference/brownie/codegen) - Configure and run the codegen CLI
 - [TypeScript Usage](/docs/api-reference/brownie/typescript-usage) - Use stores in React Native
 - [Swift Usage](/docs/api-reference/brownie/swift-usage) - Use stores in iOS apps
+- [Android Usage](/docs/api-reference/brownie/android-usage) - Use stores in Kotlin apps
diff --git a/docs/docs/docs/api-reference/brownie/swift-usage.mdx b/docs/docs/docs/api-reference/brownie/swift-usage.mdx
index 8778da5a..86d42292 100644
--- a/docs/docs/docs/api-reference/brownie/swift-usage.mdx
+++ b/docs/docs/docs/api-reference/brownie/swift-usage.mdx
@@ -3,7 +3,7 @@
 Use stores in iOS apps with SwiftUI or UIKit.
 
 :::info Android
-Android support is coming soon.
+Android APIs are documented separately in [Android Usage](/docs/api-reference/brownie/android-usage).
 :::
 
 ## Setup
diff --git a/packages/brownie/.gitignore b/packages/brownie/.gitignore
index ed24048c..10f0045b 100644
--- a/packages/brownie/.gitignore
+++ b/packages/brownie/.gitignore
@@ -1,2 +1,3 @@
 # Generated store types (created by brownie codegen)
 ios/Generated/
+android/build/
diff --git a/packages/brownie/android/build.gradle b/packages/brownie/android/build.gradle
new file mode 100644
index 00000000..e8355f0e
--- /dev/null
+++ b/packages/brownie/android/build.gradle
@@ -0,0 +1,91 @@
+buildscript {
+  ext.brownie = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    targetSdkVersion: 36,
+    cmakeVersion: "3.22.1"
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return brownie[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.callstack.brownie"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
+    consumerProguardFiles "consumer-rules.pro"
+
+    externalNativeBuild {
+      cmake {
+        arguments "-DANDROID_STL=c++_shared"
+        cppFlags "-std=c++20 -fexceptions -frtti"
+      }
+    }
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  packaging {
+    jniLibs {
+      excludes += ["**/libc++_shared.so"]
+    }
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lint {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "src/main/cpp/CMakeLists.txt"
+      version getExtOrDefault("cmakeVersion")
+    }
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "com.google.code.gson:gson:2.13.1"
+}
diff --git a/packages/brownie/android/consumer-rules.pro b/packages/brownie/android/consumer-rules.pro
new file mode 100644
index 00000000..c231fd9c
--- /dev/null
+++ b/packages/brownie/android/consumer-rules.pro
@@ -0,0 +1,4 @@
+-keep class com.callstack.brownie.BrownieStoreBridge {
+    void onStoreDidChange(java.lang.String);
+    native <methods>;
+}
diff --git a/packages/brownie/android/src/main/AndroidManifest.xml b/packages/brownie/android/src/main/AndroidManifest.xml
new file mode 100644
index 00000000..2d331664
--- /dev/null
+++ b/packages/brownie/android/src/main/AndroidManifest.xml
@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.callstack.brownie" />
diff --git a/packages/brownie/android/src/main/cpp/CMakeLists.txt b/packages/brownie/android/src/main/cpp/CMakeLists.txt
new file mode 100644
index 00000000..9772ae22
--- /dev/null
+++ b/packages/brownie/android/src/main/cpp/CMakeLists.txt
@@ -0,0 +1,68 @@
+cmake_minimum_required(VERSION 3.13)
+
+project(brownie)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(PACKAGE_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../../../..")
+
+SET(folly_FLAGS
+        -DFOLLY_NO_CONFIG=1
+        -DFOLLY_HAVE_CLOCK_GETTIME=1
+        -DFOLLY_USE_LIBCPP=1
+        -DFOLLY_CFG_NO_COROUTINES=1
+        -DFOLLY_MOBILE=1
+        -DFOLLY_HAVE_RECVMMSG=1
+        -DFOLLY_HAVE_PTHREAD=1
+        # Once we target android-23 above, we can comment
+        # the following line. NDK uses GNU style stderror_r() after API 23.
+        -DFOLLY_HAVE_XSI_STRERROR_R=1
+        )
+
+add_compile_options(${folly_FLAGS})
+
+add_library(
+  brownie
+  SHARED
+  JNIBrownieStoreBridge.cpp
+  "${PACKAGE_ROOT}/cpp/BrownieHostObject.cpp"
+  "${PACKAGE_ROOT}/cpp/BrownieInstaller.cpp"
+  "${PACKAGE_ROOT}/cpp/BrownieStore.cpp"
+  "${PACKAGE_ROOT}/cpp/BrownieStoreManager.cpp"
+)
+
+target_include_directories(
+  brownie
+  PRIVATE
+  "${PACKAGE_ROOT}/cpp"
+)
+
+find_library(log-lib log)
+find_package(fbjni REQUIRED CONFIG)
+find_package(ReactAndroid REQUIRED CONFIG)
+
+target_link_libraries(
+  brownie
+  PRIVATE
+  ${log-lib}
+  fbjni::fbjni
+)
+
+
+if(TARGET ReactAndroid::jsi)
+  target_link_libraries(brownie PRIVATE ReactAndroid::jsi)
+elseif(TARGET jsi)
+  target_link_libraries(brownie PRIVATE jsi)
+endif()
+
+if(TARGET ReactAndroid::reactnative)
+  target_link_libraries(brownie PRIVATE ReactAndroid::reactnative)
+endif()
+
+if(TARGET ReactAndroid::folly_runtime)
+  target_link_libraries(brownie PRIVATE ReactAndroid::folly_runtime)
+elseif(TARGET folly_runtime)
+  target_link_libraries(brownie PRIVATE folly_runtime)
+endif()
+
diff --git a/packages/brownie/android/src/main/cpp/JNIBrownieStoreBridge.cpp b/packages/brownie/android/src/main/cpp/JNIBrownieStoreBridge.cpp
new file mode 100644
index 00000000..fb4155db
--- /dev/null
+++ b/packages/brownie/android/src/main/cpp/JNIBrownieStoreBridge.cpp
@@ -0,0 +1,233 @@
+#include <jni.h>
+#include <folly/dynamic.h>
+#include <folly/json.h>
+#include <jsi/jsi.h>
+#include <memory>
+#include <mutex>
+#include <string>
+#include "BrownieInstaller.h"
+#include "BrownieStore.h"
+#include "BrownieStoreManager.h"
+
+namespace {
+
+constexpr auto kBridgeClassName = "com/callstack/brownie/BrownieStoreBridge";
+constexpr auto kOnStoreDidChangeMethod = "onStoreDidChange";
+constexpr auto kOnStoreDidChangeSignature = "(Ljava/lang/String;)V";
+
+JavaVM *g_vm = nullptr;
+jclass g_bridgeClass = nullptr;
+jmethodID g_onStoreDidChangeMethod = nullptr;
+std::once_flag g_initMethodOnce;
+
+std::string fromJString(JNIEnv *env, jstring value) {
+  if (value == nullptr) {
+    return "";
+  }
+
+  const char *chars = env->GetStringUTFChars(value, nullptr);
+  if (chars == nullptr) {
+    return "";
+  }
+
+  std::string result(chars);
+  env->ReleaseStringUTFChars(value, chars);
+  return result;
+}
+
+jstring toJString(JNIEnv *env, const std::string &value) {
+  return env->NewStringUTF(value.c_str());
+}
+
+bool initOnStoreDidChangeMethod(JNIEnv *env) {
+  bool success = true;
+  std::call_once(g_initMethodOnce, [env, &success]() {
+    auto localBridgeClass = env->FindClass(kBridgeClassName);
+    if (localBridgeClass == nullptr) {
+      success = false;
+      return;
+    }
+
+    g_bridgeClass = reinterpret_cast<jclass>(env->NewGlobalRef(localBridgeClass));
+    env->DeleteLocalRef(localBridgeClass);
+    if (g_bridgeClass == nullptr) {
+      success = false;
+      return;
+    }
+
+    g_onStoreDidChangeMethod = env->GetStaticMethodID(
+        g_bridgeClass, kOnStoreDidChangeMethod, kOnStoreDidChangeSignature);
+    if (g_onStoreDidChangeMethod == nullptr) {
+      success = false;
+    }
+  });
+
+  return success && g_bridgeClass != nullptr && g_onStoreDidChangeMethod != nullptr;
+}
+
+void emitStoreDidChange(const std::string &storeKey) {
+  if (g_vm == nullptr) {
+    return;
+  }
+
+  JNIEnv *env = nullptr;
+  bool didAttachCurrentThread = false;
+
+  if (g_vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6) != JNI_OK) {
+    if (g_vm->AttachCurrentThread(&env, nullptr) != JNI_OK) {
+      return;
+    }
+    didAttachCurrentThread = true;
+  }
+
+  if (!initOnStoreDidChangeMethod(env)) {
+    if (didAttachCurrentThread) {
+      g_vm->DetachCurrentThread();
+    }
+    return;
+  }
+
+  auto jStoreKey = toJString(env, storeKey);
+  env->CallStaticVoidMethod(g_bridgeClass, g_onStoreDidChangeMethod, jStoreKey);
+  env->DeleteLocalRef(jStoreKey);
+
+  if (didAttachCurrentThread) {
+    g_vm->DetachCurrentThread();
+  }
+}
+
+std::shared_ptr<brownie::BrownieStore> getStoreOrNull(const std::string &storeKey) {
+  return brownie::BrownieStoreManager::shared().getStore(storeKey);
+}
+
+template <typename TCallback>
+void withStore(JNIEnv *env, jstring storeKey, TCallback &&callback) {
+  auto store = getStoreOrNull(fromJString(env, storeKey));
+  if (!store) {
+    return;
+  }
+
+  callback(std::move(store));
+}
+
+template <typename TCallback>
+jstring withStoreResult(JNIEnv *env, jstring storeKey, TCallback &&callback) {
+  auto store = getStoreOrNull(fromJString(env, storeKey));
+  if (!store) {
+    return nullptr;
+  }
+
+  return callback(std::move(store));
+}
+
+template <typename TCallback>
+void withParsedJson(const std::string &json, TCallback &&callback) {
+  try {
+    callback(folly::parseJson(json));
+  } catch (const std::exception &) {
+    // Keep native bridge resilient to malformed payloads from Kotlin callers.
+  }
+}
+
+jstring toJsonJStringOrNull(JNIEnv *env, const folly::dynamic &value) {
+  try {
+    return toJString(env, folly::toJson(value));
+  } catch (const std::exception &) {
+    return nullptr;
+  }
+}
+
+} // namespace
+
+extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
+  g_vm = vm;
+  return JNI_VERSION_1_6;
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_callstack_brownie_BrownieStoreBridge_nativeInstallJSIBindings(JNIEnv *,
+                                                                        jclass,
+                                                                        jlong runtimePointer) {
+  auto *runtime = reinterpret_cast<facebook::jsi::Runtime *>(runtimePointer);
+  if (runtime == nullptr) {
+    return;
+  }
+
+  brownie::BrownieInstaller::install(*runtime);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_callstack_brownie_BrownieStoreBridge_nativeRegisterStore(JNIEnv *env,
+                                                                   jclass,
+                                                                   jstring storeKey) {
+  auto store = std::make_shared<brownie::BrownieStore>();
+  auto key = fromJString(env, storeKey);
+  store->setChangeCallback([key]() { emitStoreDidChange(key); });
+  brownie::BrownieStoreManager::shared().registerStore(key, store);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_callstack_brownie_BrownieStoreBridge_nativeRemoveStore(JNIEnv *env,
+                                                                 jclass,
+                                                                 jstring storeKey) {
+  brownie::BrownieStoreManager::shared().removeStore(fromJString(env, storeKey));
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_callstack_brownie_BrownieStoreBridge_nativeSetValue(JNIEnv *env,
+                                                              jclass,
+                                                              jstring valueJson,
+                                                              jstring propKey,
+                                                              jstring storeKey) {
+  withStore(env, storeKey, [env, propKey, valueJson](std::shared_ptr<brownie::BrownieStore> store) {
+    auto key = fromJString(env, propKey);
+    auto json = fromJString(env, valueJson);
+    withParsedJson(json, [&store, &key](folly::dynamic value) { store->set(key, std::move(value)); });
+  });
+}
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_com_callstack_brownie_BrownieStoreBridge_nativeGetValue(JNIEnv *env,
+                                                              jclass,
+                                                              jstring propKey,
+                                                              jstring storeKey) {
+  return withStoreResult(env, storeKey, [env, propKey](std::shared_ptr<brownie::BrownieStore> store) {
+    auto key = fromJString(env, propKey);
+    return toJsonJStringOrNull(env, store->get(key));
+  });
+}
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_com_callstack_brownie_BrownieStoreBridge_nativeGetSnapshot(JNIEnv *env,
+                                                                 jclass,
+                                                                 jstring storeKey) {
+  return withStoreResult(env, storeKey, [env](std::shared_ptr<brownie::BrownieStore> store) {
+    return toJsonJStringOrNull(env, store->getSnapshot());
+  });
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_callstack_brownie_BrownieStoreBridge_nativeSetState(JNIEnv *env,
+                                                              jclass,
+                                                              jstring stateJson,
+                                                              jstring storeKey) {
+  withStore(env, storeKey, [env, stateJson](std::shared_ptr<brownie::BrownieStore> store) {
+    auto json = fromJString(env, stateJson);
+    withParsedJson(json, [&store](folly::dynamic state) { store->setState(std::move(state)); });
+  });
+}
+
+extern "C" JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *, void *) {
+  if (g_vm == nullptr || g_bridgeClass == nullptr) {
+    return;
+  }
+
+  JNIEnv *env = nullptr;
+  if (g_vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6) != JNI_OK) {
+    return;
+  }
+
+  env->DeleteGlobalRef(g_bridgeClass);
+  g_bridgeClass = nullptr;
+  g_onStoreDidChangeMethod = nullptr;
+}
diff --git a/packages/brownie/android/src/main/java/com/callstack/brownie/BrownieModule.kt b/packages/brownie/android/src/main/java/com/callstack/brownie/BrownieModule.kt
new file mode 100644
index 00000000..3181049c
--- /dev/null
+++ b/packages/brownie/android/src/main/java/com/callstack/brownie/BrownieModule.kt
@@ -0,0 +1,84 @@
+package com.callstack.brownie
+
+import android.os.Handler
+import android.os.Looper
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * TurboModule entrypoint for Brownie on Android.
+ *
+ * It installs JSI bindings and forwards native store change events to JavaScript.
+ */
+class BrownieModule(reactContext: ReactApplicationContext) :
+  NativeBrownieModuleSpec(reactContext) {
+  private val mainHandler = Handler(Looper.getMainLooper())
+  private val didInstallJSI = AtomicBoolean(false)
+  private var storeDidChangeListenerId: String? = null
+
+  private val storeDidChangeListener: (String) -> Unit = { storeKey ->
+    val eventPayload =
+      Arguments.createMap().apply {
+        putString("storeKey", storeKey)
+        putString("key", "storeKey")
+        putString("value", storeKey)
+      }
+
+    if (Looper.myLooper() == Looper.getMainLooper()) {
+      emitNativeStoreDidChange(eventPayload)
+    } else {
+      mainHandler.post { emitNativeStoreDidChange(eventPayload) }
+    }
+  }
+
+  init {
+    storeDidChangeListenerId = BrownieStoreBridge.addStoreDidChangeListener(storeDidChangeListener)
+  }
+
+  /**
+   * Called by React Native when the module is initialized.
+   */
+  override fun initialize() {
+    super.initialize()
+    installJSIBindingsIfNeeded()
+  }
+
+  /**
+   * Called when the module is being torn down.
+   */
+  override fun invalidate() {
+    storeDidChangeListenerId?.let(BrownieStoreBridge::removeStoreDidChangeListener)
+    storeDidChangeListenerId = null
+    StoreManager.shared.clear()
+    super.invalidate()
+  }
+
+  /**
+   * Installs C++ JSI globals once a valid JS runtime pointer is available.
+   */
+  private fun installJSIBindingsIfNeeded() {
+    if (didInstallJSI.get()) {
+      return
+    }
+
+    val runtimePointer = reactApplicationContext.javaScriptContextHolder?.get() ?: 0L
+    if (runtimePointer == 0L) {
+      return
+    }
+
+    BrownieStoreBridge.installJSIBindings(runtimePointer)
+    didInstallJSI.set(true)
+  }
+
+  companion object {
+    const val NAME = "Brownie"
+  }
+
+  /**
+   * Exposes this module name to React Native.
+   */
+  override fun getName(): String {
+    return NAME
+  }
+}
diff --git a/packages/brownie/android/src/main/java/com/callstack/brownie/BrowniePackage.kt b/packages/brownie/android/src/main/java/com/callstack/brownie/BrowniePackage.kt
new file mode 100644
index 00000000..99326f94
--- /dev/null
+++ b/packages/brownie/android/src/main/java/com/callstack/brownie/BrowniePackage.kt
@@ -0,0 +1,33 @@
+package com.callstack.brownie
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+/**
+ * React Native package that registers the Brownie TurboModule.
+ */
+class BrowniePackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == BrownieModule.NAME) {
+      BrownieModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+    mapOf(
+      BrownieModule.NAME to ReactModuleInfo(
+        name = BrownieModule.NAME,
+        className = BrownieModule.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = true
+      )
+    )
+  }
+}
\ No newline at end of file
diff --git a/packages/brownie/android/src/main/java/com/callstack/brownie/BrownieStoreBridge.kt b/packages/brownie/android/src/main/java/com/callstack/brownie/BrownieStoreBridge.kt
new file mode 100644
index 00000000..690a1bce
--- /dev/null
+++ b/packages/brownie/android/src/main/java/com/callstack/brownie/BrownieStoreBridge.kt
@@ -0,0 +1,116 @@
+package com.callstack.brownie
+
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * Kotlin/JNI bridge for interacting with the shared C++ Brownie store runtime.
+ */
+object BrownieStoreBridge {
+  private val storeDidChangeListeners = ConcurrentHashMap<String, (String) -> Unit>()
+
+  init {
+    System.loadLibrary("brownie")
+  }
+
+  /**
+   * Registers a listener for store change notifications emitted from native.
+   *
+   * @return a listener id used to remove this listener.
+   */
+  fun addStoreDidChangeListener(listener: (String) -> Unit): String {
+    val listenerId = UUID.randomUUID().toString()
+    storeDidChangeListeners[listenerId] = listener
+    return listenerId
+  }
+
+  /**
+   * Removes a previously registered store change listener.
+   */
+  fun removeStoreDidChangeListener(listenerId: String) {
+    storeDidChangeListeners.remove(listenerId)
+  }
+
+  /**
+   * Creates and registers a C++ store for [storeKey].
+   */
+  fun registerStore(storeKey: String) {
+    nativeRegisterStore(storeKey)
+  }
+
+  /**
+   * Removes a C++ store for [storeKey].
+   */
+  fun removeStore(storeKey: String) {
+    nativeRemoveStore(storeKey)
+  }
+
+  /**
+   * Sets a single property on a store using JSON payload.
+   */
+  fun setValue(valueJson: String, propKey: String, storeKey: String) {
+    nativeSetValue(valueJson, propKey, storeKey)
+  }
+
+  /**
+   * Gets a single property from a store as JSON.
+   */
+  fun getValue(propKey: String, storeKey: String): String? {
+    return nativeGetValue(propKey, storeKey)
+  }
+
+  /**
+   * Gets the full store snapshot as JSON.
+   */
+  fun getSnapshot(storeKey: String): String? {
+    return nativeGetSnapshot(storeKey)
+  }
+
+  /**
+   * Replaces full store state with the provided JSON payload.
+   */
+  fun setState(stateJson: String, storeKey: String) {
+    nativeSetState(stateJson, storeKey)
+  }
+
+  /**
+   * Installs Brownie JSI bindings into the provided JS runtime.
+   */
+  fun installJSIBindings(runtimePointer: Long) {
+    nativeInstallJSIBindings(runtimePointer)
+  }
+
+  /**
+   * Entry point called from JNI when a store changes in the C++ layer.
+   */
+  @JvmStatic
+  private fun onStoreDidChange(storeKey: String) {
+    storeDidChangeListeners.values.forEach { listener ->
+      listener.invoke(storeKey)
+    }
+  }
+
+  /**
+   * Native bindings implemented in `JNIBrownieStoreBridge.cpp`.
+   */
+  @JvmStatic
+  private external fun nativeInstallJSIBindings(runtimePointer: Long)
+
+  @JvmStatic
+  private external fun nativeRegisterStore(storeKey: String)
+
+  @JvmStatic
+  private external fun nativeRemoveStore(storeKey: String)
+
+  @JvmStatic
+  private external fun nativeSetValue(valueJson: String, propKey: String, storeKey: String)
+
+  @JvmStatic
+  private external fun nativeGetValue(propKey: String, storeKey: String): String?
+
+  @JvmStatic
+  private external fun nativeGetSnapshot(storeKey: String): String?
+
+  @JvmStatic
+  private external fun nativeSetState(stateJson: String, storeKey: String)
+}
diff --git a/packages/brownie/android/src/main/java/com/callstack/brownie/BrownieStoreDefinition.kt b/packages/brownie/android/src/main/java/com/callstack/brownie/BrownieStoreDefinition.kt
new file mode 100644
index 00000000..901379da
--- /dev/null
+++ b/packages/brownie/android/src/main/java/com/callstack/brownie/BrownieStoreDefinition.kt
@@ -0,0 +1,83 @@
+package com.callstack.brownie
+
+import com.google.gson.Gson
+
+/**
+ * Serializer used by [Store] to sync typed Kotlin state with the C++ store as JSON.
+ */
+interface BrownieStoreSerializer<State> {
+  /**
+   * Encodes a typed state object into a JSON string.
+   */
+  fun encode(state: State): String
+
+  /**
+   * Decodes a JSON snapshot from native into a typed state object.
+   */
+  fun decode(snapshotJson: String): State
+}
+
+/**
+ * Immutable description of a store key and its serialization strategy.
+ */
+interface BrownieStoreDefinition<State> {
+  val storeName: String
+  val serializer: BrownieStoreSerializer<State>
+}
+
+private val brownieJson = Gson()
+
+private class BrownieStoreDefinitionImpl<State>(
+  override val storeName: String,
+  override val serializer: BrownieStoreSerializer<State>,
+) : BrownieStoreDefinition<State>
+
+private class JsonBrownieStoreSerializer<State>(
+  private val clazz: Class<State>,
+) : BrownieStoreSerializer<State> {
+  override fun encode(state: State): String = brownieJson.toJson(state)
+
+  override fun decode(snapshotJson: String): State = brownieJson.fromJson(snapshotJson, clazz)
+}
+
+/**
+ * Creates a store definition backed by Gson using a runtime [Class].
+ */
+fun <State : Any> brownieStoreDefinition(
+  storeName: String,
+  clazz: Class<State>,
+): BrownieStoreDefinition<State> = brownieStoreDefinition(storeName, JsonBrownieStoreSerializer(clazz))
+
+/**
+ * Creates a store definition backed by Gson using a reified state type.
+ */
+inline fun <reified State : Any> brownieStoreDefinition(
+  storeName: String,
+): BrownieStoreDefinition<State> = brownieStoreDefinition(storeName, State::class.java)
+
+/**
+ * Creates a store definition with a custom serializer implementation.
+ */
+fun <State> brownieStoreDefinition(
+  storeName: String,
+  serializer: BrownieStoreSerializer<State>,
+): BrownieStoreDefinition<State> = BrownieStoreDefinitionImpl(storeName, serializer)
+
+/**
+ * Creates a store definition from encode/decode lambdas.
+ */
+fun <State> brownieStoreDefinition(
+  storeName: String,
+  encode: (State) -> String,
+  decode: (String) -> State,
+): BrownieStoreDefinition<State> {
+  return brownieStoreDefinition(
+    storeName = storeName,
+    serializer =
+      object : BrownieStoreSerializer<State> {
+        override fun encode(state: State): String = encode(state)
+
+        override fun decode(snapshotJson: String): State = decode(snapshotJson)
+      },
+  )
+}
diff --git a/packages/brownie/android/src/main/java/com/callstack/brownie/BrownieStoreRegistration.kt b/packages/brownie/android/src/main/java/com/callstack/brownie/BrownieStoreRegistration.kt
new file mode 100644
index 00000000..ff61e536
--- /dev/null
+++ b/packages/brownie/android/src/main/java/com/callstack/brownie/BrownieStoreRegistration.kt
@@ -0,0 +1,55 @@
+package com.callstack.brownie
+
+/**
+ * Registers a new [Store] instance from this definition and the provided initial state.
+ */
+fun <State> BrownieStoreDefinition<State>.register(initialState: State): Store<State> {
+  return Store(initialState, storeName, serializer)
+}
+
+/**
+ * Convenience API that creates a definition with Gson and registers it.
+ */
+fun <State : Any> registerStore(
+  storeName: String,
+  initialState: State,
+  clazz: Class<State>,
+): Store<State> = brownieStoreDefinition(storeName, clazz).register(initialState)
+
+/**
+ * Reified overload of [registerStore].
+ */
+inline fun <reified State : Any> registerStore(
+  storeName: String,
+  initialState: State,
+): Store<State> = registerStore(storeName, initialState, State::class.java)
+
+/**
+ * Registers once per store name and returns null when the store was already registered.
+ *
+ * Idempotency is based on whether a store with this [storeName] currently exists
+ * in [StoreManager], so clearing or removing a store allows registration again
+ * within the same process.
+ */
+fun <State> BrownieStoreDefinition<State>.registerIfNeeded(initialState: () -> State): Store<State>? {
+  return StoreManager.shared.registerIfAbsent(storeName) {
+    register(initialState())
+  }
+}
+
+/**
+ * Convenience API that registers only once for the provided key.
+ */
+fun <State : Any> registerStoreIfNeeded(
+  storeName: String,
+  initialState: () -> State,
+  clazz: Class<State>,
+): Store<State>? = brownieStoreDefinition(storeName, clazz).registerIfNeeded(initialState)
+
+/**
+ * Reified overload of [registerStoreIfNeeded].
+ */
+inline fun <reified State : Any> registerStoreIfNeeded(
+  storeName: String,
+  noinline initialState: () -> State,
+): Store<State>? = registerStoreIfNeeded(storeName, initialState, State::class.java)
diff --git a/packages/brownie/android/src/main/java/com/callstack/brownie/Store.kt b/packages/brownie/android/src/main/java/com/callstack/brownie/Store.kt
new file mode 100644
index 00000000..72dd1079
--- /dev/null
+++ b/packages/brownie/android/src/main/java/com/callstack/brownie/Store.kt
@@ -0,0 +1,173 @@
+package com.callstack.brownie
+
+import java.util.concurrent.CopyOnWriteArraySet
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+
+/**
+ * Typed Kotlin facade over a shared C++ Brownie store.
+ *
+ * It keeps local typed state in sync with native snapshots and notifies subscribers on changes.
+ */
+class Store<State>(
+  initialState: State,
+  private val storeKey: String,
+  private val serializer: BrownieStoreSerializer<State>,
+) : AutoCloseable {
+  private val stateLock = ReentrantLock()
+  private val listeners = CopyOnWriteArraySet<(State) -> Unit>()
+  private val disposed = AtomicBoolean(false)
+
+  @Volatile
+  private var _state: State = initialState
+
+  /**
+   * Latest typed state snapshot known on the Kotlin side.
+   */
+  val state: State
+    get() = stateLock.withLock { _state }
+
+  private val bridgeListenerId: String
+
+  init {
+    BrownieStoreBridge.registerStore(storeKey)
+    pushStateToCxx()
+
+    bridgeListenerId =
+      BrownieStoreBridge.addStoreDidChangeListener { updatedStoreKey ->
+        if (updatedStoreKey == storeKey) {
+          rebuildState()
+        }
+      }
+
+    StoreManager.shared.register(this, storeKey)
+  }
+
+  /**
+   * Updates state with [updater] and pushes it to C++.
+   *
+   * Listener notification is triggered via the native storeDidChange callback and [rebuildState]
+   * to keep Kotlin updates consistent with cross-runtime updates.
+   */
+  fun set(updater: (State) -> State) {
+    val newState =
+      stateLock.withLock {
+        _state = updater(_state)
+        _state
+      }
+
+    pushStateToCxx(newState)
+  }
+
+  /**
+   * Replaces state with a concrete value.
+   */
+  fun set(value: State) {
+    set { value }
+  }
+
+  /**
+   * Sets a single property in the underlying C++ store using JSON payload.
+   */
+  fun setValue(property: String, valueJson: String) {
+    BrownieStoreBridge.setValue(valueJson, property, storeKey)
+  }
+
+  /**
+   * Reads a single property from the underlying C++ store as JSON.
+   */
+  fun getValue(property: String): String? = BrownieStoreBridge.getValue(property, storeKey)
+
+  /**
+   * Subscribes to full state updates.
+   *
+   * The listener is called immediately with current state and then on every update.
+   */
+  fun subscribe(onChange: (State) -> Unit): () -> Unit {
+    listeners.add(onChange)
+    onChange(state)
+    return { listeners.remove(onChange) }
+  }
+
+  /**
+   * Releases local listeners and bridge callbacks; called by [StoreManager].
+   */
+  internal fun dispose() {
+    if (!disposed.compareAndSet(false, true)) {
+      return
+    }
+
+    BrownieStoreBridge.removeStoreDidChangeListener(bridgeListenerId)
+    listeners.clear()
+  }
+
+  /**
+   * Closes this store and removes it from [StoreManager].
+   */
+  override fun close() {
+    StoreManager.shared.removeStore(storeKey)
+  }
+
+  /**
+   * Serializes typed state and pushes it to the C++ store.
+   */
+  private fun pushStateToCxx(state: State = this.state) {
+    BrownieStoreBridge.setState(serializer.encode(state), storeKey)
+  }
+
+  /**
+   * Pulls latest snapshot from C++, decodes it, and updates local state.
+   */
+  private fun rebuildState() {
+    val snapshot = BrownieStoreBridge.getSnapshot(storeKey) ?: return
+    val rebuiltState = runCatching { serializer.decode(snapshot) }.getOrNull() ?: return
+
+    stateLock.withLock {
+      _state = rebuiltState
+    }
+
+    notifyListeners(rebuiltState)
+  }
+
+  /**
+   * Notifies all active local subscribers with [state].
+   */
+  private fun notifyListeners(state: State) {
+    listeners.forEach { listener ->
+      listener(state)
+    }
+  }
+}
+
+/**
+ * Subscribes to a selected slice of store state.
+ *
+ * The listener is invoked only when the selected value changes by `!=`.
+ */
+fun <State, Selected> Store<State>.subscribe(
+  selector: (State) -> Selected,
+  onChange: (Selected) -> Unit,
+): () -> Unit {
+  val selectorLock = ReentrantLock()
+  var hasSelection = false
+  var previousSelection: Selected? = null
+
+  return subscribe { state ->
+    val newSelection = selector(state)
+    val shouldNotify =
+      selectorLock.withLock {
+        if (!hasSelection || previousSelection != newSelection) {
+          hasSelection = true
+          previousSelection = newSelection
+          true
+        } else {
+          false
+        }
+      }
+
+    if (shouldNotify) {
+      onChange(newSelection)
+    }
+  }
+}
diff --git a/packages/brownie/android/src/main/java/com/callstack/brownie/StoreManager.kt b/packages/brownie/android/src/main/java/com/callstack/brownie/StoreManager.kt
new file mode 100644
index 00000000..b80868b2
--- /dev/null
+++ b/packages/brownie/android/src/main/java/com/callstack/brownie/StoreManager.kt
@@ -0,0 +1,93 @@
+package com.callstack.brownie
+
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+
+/**
+ * Process-wide registry of Kotlin [Store] instances keyed by store name.
+ */
+class StoreManager private constructor() {
+  companion object {
+    /**
+     * Shared singleton used by Brownie runtime and app integrations.
+     */
+    val shared: StoreManager = StoreManager()
+  }
+
+  private val lock = ReentrantLock()
+  private val stores: MutableMap<String, Any> = mutableMapOf()
+
+  /**
+   * Registers a store instance under a key.
+   */
+  fun <State> register(store: Store<State>, key: String) {
+    lock.withLock {
+      check(!stores.containsKey(key)) {
+        "Store with key '$key' is already registered. Remove the previous store first using Store.close() or StoreManager.removeStore(key)"
+      }
+      stores[key] = store
+    }
+  }
+
+  /**
+   * Registers a new store only when [key] is currently absent.
+   *
+   * Returns the created store when registration succeeds, otherwise `null`.
+   * The check and registration are atomic under [lock].
+   */
+  fun <State> registerIfAbsent(key: String, createStore: () -> Store<State>): Store<State>? {
+    return lock.withLock {
+      if (stores.containsKey(key)) {
+        return@withLock null
+      }
+
+      val store = createStore()
+      stores[key] = store
+      store
+    }
+  }
+
+  /**
+   * Retrieves a typed store by key when the runtime state type matches [clazz].
+   */
+  fun <State> store(key: String, clazz: Class<State>): Store<State>? {
+    return lock.withLock {
+      val store = stores[key] as? Store<*> ?: return@withLock null
+      runCatching { clazz.cast(store.state) }.getOrNull() ?: return@withLock null
+      @Suppress("UNCHECKED_CAST")
+      store as Store<State>
+    }
+  }
+
+  /**
+   * Removes a store from the registry and from the native bridge.
+   */
+  fun removeStore(key: String) {
+    val store = lock.withLock {
+      stores.remove(key) as? Store<*>
+    }
+
+    store?.dispose()
+    BrownieStoreBridge.removeStore(key)
+  }
+
+  /**
+   * Removes all registered stores.
+   */
+  fun clear() {
+    val keys = lock.withLock {
+      stores.keys.toList()
+    }
+
+    keys.forEach { key ->
+      removeStore(key)
+    }
+  }
+}
+
+/**
+ * Reified convenience overload for [StoreManager.store].
+ */
+inline fun <reified State : Any> StoreManager.store(key: String): Store<State>? {
+  return store(key, State::class.java)
+}
diff --git a/packages/brownie/cpp/BrownieStore.cpp b/packages/brownie/cpp/BrownieStore.cpp
index 31a8c387..7ccf586a 100644
--- a/packages/brownie/cpp/BrownieStore.cpp
+++ b/packages/brownie/cpp/BrownieStore.cpp
@@ -16,16 +16,18 @@ folly::dynamic BrownieStore::get(const std::string &key) const {
 }
 
 void BrownieStore::set(const std::string &key, folly::dynamic value) {
+  ChangeCallback callback;
   {
     std::lock_guard<std::mutex> lock(mutex_);
     if (!state_.isObject()) {
       state_ = folly::dynamic::object();
     }
     state_[key] = std::move(value);
+    callback = changeCallback_;
   }
 
-  if (changeCallback_) {
-    changeCallback_();
+  if (callback) {
+    callback();
   }
 }
 
@@ -35,13 +37,15 @@ folly::dynamic BrownieStore::getSnapshot() const {
 }
 
 void BrownieStore::setState(folly::dynamic state) {
+  ChangeCallback callback;
   {
     std::lock_guard<std::mutex> lock(mutex_);
     state_ = std::move(state);
+    callback = changeCallback_;
   }
 
-  if (changeCallback_) {
-    changeCallback_();
+  if (callback) {
+    callback();
   }
 }
 
diff --git a/packages/brownie/package.json b/packages/brownie/package.json
index dbf5c793..01bd41ab 100644
--- a/packages/brownie/package.json
+++ b/packages/brownie/package.json
@@ -50,10 +50,16 @@
   "files": [
     "src",
     "lib",
+    "android",
     "ios",
     "cpp",
     "*.podspec",
     "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
     "!**/__tests__",
     "!**/__fixtures__",
     "!**/__mocks__",
diff --git a/packages/brownie/react-native.config.js b/packages/brownie/react-native.config.js
deleted file mode 100644
index 22b2e13d..00000000
--- a/packages/brownie/react-native.config.js
+++ /dev/null
@@ -1,7 +0,0 @@
-module.exports = {
-  dependency: {
-    platforms: {
-      android: null,
-    },
-  },
-};
diff --git a/packages/cli/src/brownie/__tests__/commands/codegen.test.ts b/packages/cli/src/brownie/__tests__/commands/codegen.test.ts
index 6793ff19..deb5473d 100644
--- a/packages/cli/src/brownie/__tests__/commands/codegen.test.ts
+++ b/packages/cli/src/brownie/__tests__/commands/codegen.test.ts
@@ -113,7 +113,7 @@ describe('runCodegen', () => {
     expect(mockGenerateSwift).not.toHaveBeenCalled();
   });
 
-  it('generates only swift by default even when kotlin is configured', async () => {
+  it('generates swift and kotlin by default when kotlin is configured', async () => {
     tempDir = createTempPackageJson({
       brownie: {
         kotlin: './Generated',
@@ -124,7 +124,13 @@ describe('runCodegen', () => {
     await runCodegen({});
 
     expect(mockGenerateSwift).toHaveBeenCalled();
-    expect(mockGenerateKotlin).not.toHaveBeenCalled();
+    expect(mockGenerateKotlin).toHaveBeenCalledWith({
+      name: 'TestStore',
+      schemaPath: '/path/to/TestStore.brownie.ts',
+      typeName: 'TestStore',
+      outputPath: 'Generated/TestStore.kt',
+      packageName: undefined,
+    });
   });
 
   it('generates only specified platform', async () => {
diff --git a/packages/cli/src/brownie/commands/codegen.ts b/packages/cli/src/brownie/commands/codegen.ts
index 3c9020bf..78359b65 100644
--- a/packages/cli/src/brownie/commands/codegen.ts
+++ b/packages/cli/src/brownie/commands/codegen.ts
@@ -118,8 +118,8 @@ export async function runCodegen({ platform }: RunCodegenOptions) {
       if (platform) {
         platforms = [platform];
       } else {
-        // Only generate Swift by default (Kotlin not yet released)
-        platforms = ['swift'];
+        // Generate both Swift and Kotlin by default
+        platforms = ['swift', 'kotlin'];
       }
 
       await generateForStore(store, config, platforms, isMultipleStores);
@@ -142,8 +142,8 @@ export const codegenCommand = new Command('codegen')
   .addOption(
     new Option(
       '-p, --platform <platform>',
-      'Generate for specific platform (swift)'
-    ).choices(['swift'])
+      'Generate for specific platform (swift|kotlin)'
+    ).choices(['swift', 'kotlin'])
   )
   .action(
     actionRunner(async (options: RunCodegenOptions) => {