diff --git a/.changeset/client-rendered-widgets-android-experimental.md b/.changeset/client-rendered-widgets-android-experimental.md
new file mode 100644
index 00000000..8486dc9d
--- /dev/null
+++ b/.changeset/client-rendered-widgets-android-experimental.md
@@ -0,0 +1,20 @@
+---
+'@use-voltra/android-client': minor
+---
+
+**Experimental: client-rendered widgets (Android).** A widget component marked with the
+`'use voltra'` directive now renders on-device in a standalone Hermes runtime, called as
+`(props, env) => JSX` on every render, so it reacts to live environment values (widget size, color
+scheme, locale, and configuration). Material You dynamic colors are consumed via
+`AndroidDynamicColors` tokens that the native renderer resolves to the system color scheme (and that
+follow light/dark automatically). In development the bundle is served by Metro and editing the JSX
+hot-reloads the pinned widget; in release builds the bundle is baked into the app's assets at build
+time.
+
+Configuration parameters declared in `app.json` (`appIntent.parameters`, with code-defined
+defaults) surface as `env.configuration`; runtime values set via `setWidgetConfiguration` override
+the defaults (Android has no system widget-configuration UI, so this is an in-app stand-in).
+
+This feature is **experimental** — usable in production at your own risk; the API and generated
+build output may change. Release rendering has been verified on the Android emulator (the baked
+bundle renders on-device with Metro stopped); confirming on a physical device is still recommended.
diff --git a/example/app.json b/example/app.json
index e5b8050e..4dfab480 100644
--- a/example/app.json
+++ b/example/app.json
@@ -226,6 +226,31 @@
                 "intervalMinutes": 15,
                 "refresh": true
               }
+            },
+            {
+              "id": "AndroidClientDemoWidget",
+              "displayName": {
+                "en": "Client Demo"
+              },
+              "description": {
+                "en": "Client-rendered Voltra widget (on-device Hermes)"
+              },
+              "minCellWidth": 2,
+              "minCellHeight": 2,
+              "targetCellWidth": 2,
+              "targetCellHeight": 2,
+              "resizeMode": "horizontal|vertical",
+              "widgetCategory": "home_screen",
+              "initialStatePath": "./widgets/android/AndroidClientDemoWidget.tsx",
+              "appIntent": {
+                "parameters": [
+                  {
+                    "name": "label",
+                    "title": "Label",
+                    "default": "Hello"
+                  }
+                ]
+              }
             }
           ],
           "fonts": [
diff --git a/example/app/_layout.tsx b/example/app/_layout.tsx
index 9970620d..20b3dee1 100644
--- a/example/app/_layout.tsx
+++ b/example/app/_layout.tsx
@@ -1,13 +1,19 @@
 import { Stack } from 'expo-router'
+import { Platform } from 'react-native'
 import { SafeAreaProvider } from 'react-native-safe-area-context'
-import { enableWidgetHotReload } from '@use-voltra/ios-client'
+import { enableWidgetHotReload as enableIosWidgetHotReload } from '@use-voltra/ios-client'
+import { enableWidgetHotReload as enableAndroidWidgetHotReload } from '@use-voltra/android-client'
 import '@use-voltra/widget-hot-reload'
 
 import { useVoltraEvents } from '~/hooks/useVoltraEvents'
 import { useServerDrivenWidgetToken } from '~/hooks/useServerDrivenWidgetToken'
 import { updateAndroidVoltraWidget } from '~/widgets/android/updateAndroidVoltraWidget'
 
-enableWidgetHotReload()
+if (Platform.OS === 'android') {
+  enableAndroidWidgetHotReload()
+} else {
+  enableIosWidgetHotReload()
+}
 updateAndroidVoltraWidget({ width: 300, height: 200 })
 
 const STACK_SCREEN_OPTIONS = {
diff --git a/example/screens/android/AndroidWidgetPinScreen.tsx b/example/screens/android/AndroidWidgetPinScreen.tsx
index f2771085..6cc24f74 100644
--- a/example/screens/android/AndroidWidgetPinScreen.tsx
+++ b/example/screens/android/AndroidWidgetPinScreen.tsx
@@ -1,7 +1,7 @@
 import { useRouter } from 'expo-router'
 import React, { useState } from 'react'
 import { Alert, Platform, StyleSheet, Text, TextInput, View } from 'react-native'
-import { requestPinAndroidWidget } from '@use-voltra/android-client'
+import { requestPinAndroidWidget, setWidgetConfiguration } from '@use-voltra/android-client'
 
 import { Button } from '~/components/Button'
 import { ScreenLayout } from '~/components/ScreenLayout'
@@ -28,6 +28,13 @@ const AVAILABLE_WIDGETS = [
     defaultPreviewWidth: 250,
     defaultPreviewHeight: 150,
   },
+  {
+    id: 'AndroidClientDemoWidget',
+    name: 'Client-Rendered Demo',
+    description: 'On-device JSX render (Hermes) with live env',
+    defaultPreviewWidth: 250,
+    defaultPreviewHeight: 150,
+  },
 ]
 
 export default function AndroidWidgetPinScreen() {
@@ -36,6 +43,19 @@ export default function AndroidWidgetPinScreen() {
   const [previewWidth, setPreviewWidth] = useState<string>('250')
   const [previewHeight, setPreviewHeight] = useState<string>('150')
   const [isPinning, setIsPinning] = useState(false)
+  const [configLabel, setConfigLabel] = useState<string>('')
+
+  const handleSetConfig = async () => {
+    if (Platform.OS !== 'android') {
+      return
+    }
+    try {
+      await setWidgetConfiguration(selectedWidgetId, 'label', configLabel)
+      Alert.alert('Saved', `Set config "label" = "${configLabel}" for ${selectedWidgetId}. The widget re-renders.`)
+    } catch (error: any) {
+      Alert.alert('Error', error?.message || String(error))
+    }
+  }
 
   const selectedWidget = AVAILABLE_WIDGETS.find((w) => w.id === selectedWidgetId) || AVAILABLE_WIDGETS[0]
 
@@ -110,6 +130,22 @@ export default function AndroidWidgetPinScreen() {
         ))}
       </View>
 
+      <View style={styles.section}>
+        <Text style={styles.sectionTitle}>Configuration (client-rendered)</Text>
+        <View style={styles.inputGroup}>
+          <Text style={styles.inputLabel}>env.configuration.label</Text>
+          <TextInput
+            style={styles.input}
+            value={configLabel}
+            onChangeText={setConfigLabel}
+            placeholder="label value"
+            placeholderTextColor="#64748B"
+            autoCapitalize="none"
+          />
+        </View>
+        <Button title="Set configuration" onPress={handleSetConfig} style={styles.resetButton} />
+      </View>
+
       <View style={styles.section}>
         <Text style={styles.sectionTitle}>Preview Dimensions (optional)</Text>
         <View style={styles.previewInputs}>
diff --git a/example/widgets/android/AndroidClientDemoWidget.tsx b/example/widgets/android/AndroidClientDemoWidget.tsx
new file mode 100644
index 00000000..0a1342ed
--- /dev/null
+++ b/example/widgets/android/AndroidClientDemoWidget.tsx
@@ -0,0 +1,71 @@
+import { AndroidDynamicColors, VoltraAndroid, type WidgetEnvironment } from '@use-voltra/android'
+
+// Client-rendered Android widget: its JSX runs on-device in Hermes on every render, receiving
+// the live `env`. Edit the marker literal below and save — the home-screen widget updates via
+// Fast Refresh (dev). Mirrors the iOS ClientRenderedDemoWidget. Themes itself from Material You
+// via AndroidDynamicColors tokens, which the native renderer resolves to the system dynamic
+// color scheme (and which follow light/dark automatically).
+
+export const AndroidClientDemoWidget = (_props: object, env: WidgetEnvironment = {} as WidgetEnvironment) => {
+  'use voltra'
+
+  // ▼ EDIT THIS LITERAL TO TEST HOT RELOAD ▼
+  const hotReloadMarker = 'edit me'
+
+  const date = env.date ? new Date(env.date) : new Date()
+  const renderedAt = date.toLocaleTimeString('en-US', {
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    hour12: false,
+  })
+
+  const config = env.configuration as Record<string, unknown> | undefined
+  const configLabel = typeof config?.label === 'string' ? config.label : '(unset)'
+
+  // Material You tokens — resolved natively from the system dynamic color scheme.
+  const bg = AndroidDynamicColors.surface
+  const fg = AndroidDynamicColors.onSurface
+  const muted = AndroidDynamicColors.onSurfaceVariant
+  const accent = AndroidDynamicColors.primary
+
+  const label = { fontSize: 10, color: muted } as const
+  const value = { fontSize: 10, color: fg } as const
+
+  const row = (k: string, v: string) => (
+    <VoltraAndroid.Row>
+      <VoltraAndroid.Text style={label}>{k} </VoltraAndroid.Text>
+      <VoltraAndroid.Text style={value}>{v}</VoltraAndroid.Text>
+    </VoltraAndroid.Row>
+  )
+
+  const swatch = (color: string) => (
+    <VoltraAndroid.Box style={{ width: 16, height: 16, backgroundColor: color, cornerRadius: 4 }} />
+  )
+
+  return (
+    <VoltraAndroid.Column
+      style={{ backgroundColor: bg, width: '100%', height: '100%', padding: 12 }}
+      verticalAlignment="center-vertically"
+    >
+      <VoltraAndroid.Text style={{ fontSize: 12, color: fg }}>Client-rendered demo</VoltraAndroid.Text>
+      <VoltraAndroid.Text style={{ fontSize: 14, color: accent }}>{hotReloadMarker}</VoltraAndroid.Text>
+      <VoltraAndroid.Spacer style={{ height: 6 }} />
+      {row('size:', env.widgetFamily ?? '?')}
+      {row('scheme:', env.colorScheme ?? '?')}
+      {row('locale:', env.locale ?? '?')}
+      {row('config:', configLabel)}
+      {row('time:', renderedAt)}
+      <VoltraAndroid.Spacer style={{ height: 8 }} />
+      <VoltraAndroid.Row>
+        {swatch(AndroidDynamicColors.primary)}
+        <VoltraAndroid.Spacer style={{ width: 6 }} />
+        {swatch(AndroidDynamicColors.secondary)}
+        <VoltraAndroid.Spacer style={{ width: 6 }} />
+        {swatch(AndroidDynamicColors.tertiary)}
+        <VoltraAndroid.Spacer style={{ width: 6 }} />
+        {swatch(AndroidDynamicColors.error)}
+      </VoltraAndroid.Row>
+    </VoltraAndroid.Column>
+  )
+}
diff --git a/packages/android-client/README.md b/packages/android-client/README.md
index f275ff1a..c60a9e83 100644
--- a/packages/android-client/README.md
+++ b/packages/android-client/README.md
@@ -10,6 +10,8 @@
 
 - **Home Screen widgets**: Update, reload, pin, and query widgets with `updateAndroidWidget`, `reloadAndroidWidgets`, `getActiveWidgets`, and more.
 
+- **Client-rendered widgets** _(experimental)_: Write a widget as a `'use voltra'` JSX component and have it render on-device (standalone Hermes) from its own JS bundle, with live env (size, color scheme, Material You colors, locale, configuration). See the note below.
+
 - **Ongoing notifications**: Start and update promoted ongoing notifications with `useAndroidOngoingNotification` and related APIs.
 
 - **Fast Refresh**: Previews integrate with your React Native dev workflow via `VoltraWidgetPreview` and `VoltraView`.
@@ -20,6 +22,28 @@
 
 - **Expo config plugin**: Add `"@use-voltra/android-client"` to `app.json` to register widgets, optional notifications, and build-time initial states.
 
+## Client-rendered widgets (experimental)
+
+> [!WARNING]
+> Client-rendered widgets are **experimental** — usable in production at your own risk. The API
+> and generated build output may change between releases.
+
+A widget whose component carries the `'use voltra'` directive is rendered **on-device**: its JS
+bundle is evaluated in a standalone Hermes runtime on each render and called as `(props, env) => JSX`,
+so the widget reacts to live environment values (size, color scheme, Material You `materialColors`,
+locale, and `configuration`). In development the bundle is served by Metro (editing the JSX
+hot-reloads the pinned widget); in release builds it is baked into the app's assets at build time.
+
+Configuration parameters declared in `app.json` (`appIntent.parameters`, with code-defined
+defaults) surface as `env.configuration`. Android has no system-managed widget configuration UI
+(unlike iOS's Edit Widget), so runtime values are set in-app via `setWidgetConfiguration` and
+override the declared defaults.
+
+Notes:
+
+- The dev loop and release baking rely on Metro scaffolding in your project (see `example/metro`).
+- Verify release rendering on a **real device** — emulators are unreliable for widget rendering.
+
 ## Documentation
 
 The documentation is available at [use-voltra.dev](https://use-voltra.dev). Relevant topics for this package:
diff --git a/packages/android-client/android/CMakeLists.txt b/packages/android-client/android/CMakeLists.txt
new file mode 100644
index 00000000..ce0f06c1
--- /dev/null
+++ b/packages/android-client/android/CMakeLists.txt
@@ -0,0 +1,33 @@
+cmake_minimum_required(VERSION 3.13)
+project(voltra)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# React Native publishes JSI + Hermes via Prefab modules in their AARs.
+# We consume them through find_package below.
+#
+# NOTE: find_package does NOT error on a wrong target *name* — the failure only
+# surfaces at target_link_libraries. The correct Hermes prefab target on Android
+# (RN 0.83, com.facebook.react:hermes-android) is `hermes-engine::hermesvm`.
+find_package(ReactAndroid REQUIRED CONFIG)
+find_package(hermes-engine REQUIRED CONFIG)
+find_package(fbjni REQUIRED CONFIG)
+
+# ---------------------------------------------------------------------------
+# Voltra JS Renderer (client-rendered widgets on Android)
+# ---------------------------------------------------------------------------
+# Standalone Hermes runtime owned by Voltra, independent of the React Native
+# bridge. Evaluates a per-widget Metro bundle that exposes `render(props, env)`
+# and invokes it on every Glance render. JNI surface in voltra_js_renderer.cpp.
+add_library(voltra_js_renderer SHARED
+  src/main/cpp/voltra_js_renderer.cpp
+)
+
+target_link_libraries(voltra_js_renderer
+  android
+  log
+  ReactAndroid::jsi
+  hermes-engine::hermesvm
+  fbjni::fbjni
+)
\ No newline at end of file
diff --git a/packages/android-client/android/build.gradle b/packages/android-client/android/build.gradle
index b020d862..a7038005 100644
--- a/packages/android-client/android/build.gradle
+++ b/packages/android-client/android/build.gradle
@@ -39,11 +39,39 @@ android {
     versionCode 1
     versionName "0.1.0"
     buildConfigField "String", "VOLTRA_VERSION", "\"${voltraVersion}\""
+
+    // Standalone Hermes runtime for client-rendered widgets, via custom JNI.
+    // See CMakeLists.txt / src/main/cpp/voltra_js_renderer.cpp.
+    externalNativeBuild {
+      cmake {
+        cppFlags "-std=c++17", "-fexceptions", "-frtti"
+        arguments "-DANDROID_STL=c++_shared"
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
   }
 
   buildFeatures {
     buildConfig true
     compose true
+    // Required to consume React Native's published prefab modules (jsi, hermesvm, fbjni).
+    prefab true
+  }
+
+  packagingOptions {
+    // These .so files are already provided by the host app's React Native runtime;
+    // bundling Voltra's copies would cause duplicate-library conflicts at install time.
+    excludes += [
+      "**/libreact_nativemodule_core.so",
+      "**/libfbjni.so",
+      "**/libjsi.so",
+      "**/libhermes.so",
+    ]
   }
 
   lintOptions {
@@ -67,6 +95,11 @@ android {
 dependencies {
   // React Native
   implementation "com.facebook.react:react-android"
+  // Provides the `hermes-engine` prefab (libhermesvm) that CMakeLists.txt's
+  // find_package(hermes-engine) consumes for the standalone Hermes JS runtime. Without it the
+  // native build fails to configure in release variants (react-android alone does not publish the
+  // Hermes prefab). Version is substituted by the React Native Gradle Plugin (applied above).
+  implementation "com.facebook.react:hermes-android"
 
   // Jetpack Glance
   api "androidx.glance:glance:1.2.0-rc01"
@@ -75,6 +108,10 @@ dependencies {
   // Compose runtime (required for Glance)
   api "androidx.compose.runtime:runtime:1.6.8"
 
+  // Material3 — used to read Material You dynamic color tokens for client widgets'
+  // env.materialColors (dynamicLightColorScheme / dynamicDarkColorScheme).
+  implementation "androidx.compose.material3:material3:1.3.2"
+
   // WorkManager (for periodic server-driven widget updates)
   api "androidx.work:work-runtime-ktx:2.9.1"
 
diff --git a/packages/android-client/android/src/main/cpp/voltra_js_renderer.cpp b/packages/android-client/android/src/main/cpp/voltra_js_renderer.cpp
new file mode 100644
index 00000000..6cf5358b
--- /dev/null
+++ b/packages/android-client/android/src/main/cpp/voltra_js_renderer.cpp
@@ -0,0 +1,186 @@
+// Voltra JS Renderer — Hermes-on-Android JNI wrapper for client-rendered widgets.
+//
+// Owns a single standalone Hermes runtime per process, independent of the React
+// Native bridge. Each per-widget Metro bundle is evaluated once; the evaluation
+// captures the bundle's `render(props, env)` export under
+// `globalThis.__voltraWidgets[<widgetId>]` (the capture bootstrap is appended on
+// the Kotlin side, mirroring iOS `VoltraJSRenderer.swift`). `nativeRender` then
+// invokes that function on every Glance render.
+//
+// Architectural mirror of iOS's VoltraJSRenderer.swift (JSC), one layer lower at
+// the JNI boundary because Android has no Kotlin/Java Hermes API.
+
+#include <jni.h>
+#include <android/log.h>
+
+#include <hermes/hermes.h>
+#include <jsi/jsi.h>
+
+#include <chrono>
+#include <memory>
+#include <mutex>
+#include <string>
+
+#define LOG_TAG "VoltraJSRenderer"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+// Perf timing logs — debug builds only (release CMake defines NDEBUG).
+#ifndef NDEBUG
+#define LOGPERF(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#else
+#define LOGPERF(...) ((void)0)
+#endif
+
+namespace jsi = facebook::jsi;
+
+namespace {
+
+using Clock = std::chrono::steady_clock;
+
+double millisSince(Clock::time_point start) {
+  return std::chrono::duration<double, std::milli>(Clock::now() - start).count();
+}
+
+std::mutex g_mutex;
+std::unique_ptr<jsi::Runtime> g_runtime;
+
+jsi::Runtime &runtime() {
+  if (!g_runtime) {
+    g_runtime = facebook::hermes::makeHermesRuntime();
+    LOGI("standalone Hermes runtime created");
+  }
+  return *g_runtime;
+}
+
+std::string jstringToStd(JNIEnv *env, jstring jstr) {
+  if (jstr == nullptr) {
+    return {};
+  }
+  const char *chars = env->GetStringUTFChars(jstr, nullptr);
+  std::string out(chars);
+  env->ReleaseStringUTFChars(jstr, chars);
+  return out;
+}
+
+} // namespace
+
+// Evaluate a (Kotlin-wrapped) widget bundle and verify the capture bootstrap
+// registered `globalThis.__voltraWidgets[<widgetId>].render`. Returns false on
+// any JS error or if the render function was not captured.
+extern "C" JNIEXPORT jboolean JNICALL
+Java_voltra_runtime_VoltraJSRenderer_nativeEvaluateBundle(
+    JNIEnv *env, jobject /* this */, jstring jWrappedSource, jstring jSourceURL,
+    jstring jWidgetId) {
+  std::lock_guard<std::mutex> lock(g_mutex);
+  try {
+    const std::string source = jstringToStd(env, jWrappedSource);
+    const std::string sourceURL = jstringToStd(env, jSourceURL);
+    const std::string widgetId = jstringToStd(env, jWidgetId);
+
+    const bool firstRuntime = (g_runtime == nullptr);
+    auto tRuntime = Clock::now();
+    auto &rt = runtime();
+    if (firstRuntime) {
+      LOGPERF("[perf] runtime init: %.2f ms", millisSince(tRuntime));
+    }
+
+    auto tEval = Clock::now();
+    rt.evaluateJavaScript(
+        std::make_unique<jsi::StringBuffer>(source), sourceURL);
+    LOGPERF("[perf] bundle eval: %.2f ms (%zu chars)", millisSince(tEval), source.size());
+
+    auto registry = rt.global().getProperty(rt, "__voltraWidgets");
+    if (!registry.isObject()) {
+      LOGE("evaluateBundle: globalThis.__voltraWidgets missing after eval");
+      return JNI_FALSE;
+    }
+    auto widget = registry.asObject(rt).getProperty(rt, widgetId.c_str());
+    if (!widget.isObject()) {
+      LOGE("evaluateBundle: no entry for widgetId=%s", widgetId.c_str());
+      return JNI_FALSE;
+    }
+    auto renderFn = widget.asObject(rt).getProperty(rt, "render");
+    if (!renderFn.isObject() ||
+        !renderFn.asObject(rt).isFunction(rt)) {
+      LOGE("evaluateBundle: __voltraWidgets[%s].render is not a function",
+           widgetId.c_str());
+      return JNI_FALSE;
+    }
+
+    LOGI("evaluateBundle: render() captured for widgetId=%s (%zu chars)",
+         widgetId.c_str(), source.size());
+    return JNI_TRUE;
+  } catch (const jsi::JSError &e) {
+    LOGE("evaluateBundle JSError: %s", e.getMessage().c_str());
+    return JNI_FALSE;
+  } catch (const std::exception &e) {
+    LOGE("evaluateBundle threw: %s", e.what());
+    return JNI_FALSE;
+  } catch (...) {
+    LOGE("evaluateBundle threw: unknown");
+    return JNI_FALSE;
+  }
+}
+
+// Invoke the previously-captured `render(propsJSON, envJSON)` for a widget.
+// Props/env cross the boundary as JSON strings (the JS entry parses them); the
+// entry returns a JSON string (the resolved Voltra node tree), so no JSON
+// marshaling is needed here. Returns null on any error.
+extern "C" JNIEXPORT jstring JNICALL
+Java_voltra_runtime_VoltraJSRenderer_nativeRender(
+    JNIEnv *env, jobject /* this */, jstring jWidgetId, jstring jPropsJSON,
+    jstring jEnvJSON) {
+  std::lock_guard<std::mutex> lock(g_mutex);
+  if (!g_runtime) {
+    LOGE("render called before evaluateBundle");
+    return nullptr;
+  }
+  try {
+    auto &rt = *g_runtime;
+    const std::string widgetId = jstringToStd(env, jWidgetId);
+    const std::string propsJSON = jstringToStd(env, jPropsJSON);
+    const std::string envJSON = jstringToStd(env, jEnvJSON);
+
+    auto registry = rt.global().getProperty(rt, "__voltraWidgets");
+    if (!registry.isObject()) {
+      LOGE("render: __voltraWidgets missing (bundle not evaluated?)");
+      return nullptr;
+    }
+    auto widget = registry.asObject(rt).getProperty(rt, widgetId.c_str());
+    if (!widget.isObject()) {
+      LOGE("render: no captured widget for widgetId=%s", widgetId.c_str());
+      return nullptr;
+    }
+    auto renderProp = widget.asObject(rt).getProperty(rt, "render");
+    if (!renderProp.isObject() ||
+        !renderProp.asObject(rt).isFunction(rt)) {
+      LOGE("render: render is not a function for widgetId=%s",
+           widgetId.c_str());
+      return nullptr;
+    }
+    auto renderFn = renderProp.asObject(rt).asFunction(rt);
+
+    auto tRender = Clock::now();
+    jsi::Value result = renderFn.call(
+        rt, jsi::String::createFromUtf8(rt, propsJSON),
+        jsi::String::createFromUtf8(rt, envJSON));
+    LOGPERF("[perf] render: %.2f ms (widgetId=%s)", millisSince(tRender), widgetId.c_str());
+
+    if (!result.isString()) {
+      LOGE("render: did not return a string for widgetId=%s", widgetId.c_str());
+      return nullptr;
+    }
+    std::string resultStr = result.asString(rt).utf8(rt);
+    return env->NewStringUTF(resultStr.c_str());
+  } catch (const jsi::JSError &e) {
+    LOGE("render JSError: %s", e.getMessage().c_str());
+    return nullptr;
+  } catch (const std::exception &e) {
+    LOGE("render threw: %s", e.what());
+    return nullptr;
+  } catch (...) {
+    LOGE("render threw: unknown");
+    return nullptr;
+  }
+}
\ No newline at end of file
diff --git a/packages/android-client/android/src/main/java/voltra/VoltraModule.kt b/packages/android-client/android/src/main/java/voltra/VoltraModule.kt
index 825fd1d9..3565d52b 100644
--- a/packages/android-client/android/src/main/java/voltra/VoltraModule.kt
+++ b/packages/android-client/android/src/main/java/voltra/VoltraModule.kt
@@ -1,6 +1,8 @@
 package voltra
 
 import android.appwidget.AppWidgetManager
+import android.content.ComponentCallbacks
+import android.content.res.Configuration
 import android.util.Log
 import androidx.compose.ui.unit.DpSize
 import androidx.compose.ui.unit.dp
@@ -11,12 +13,17 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableNativeMap
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import voltra.images.VoltraImageManager
+import voltra.runtime.VoltraConfigurationStore
 import voltra.widget.VoltraGlanceWidget
 import voltra.widget.VoltraWidgetManager
+import voltra.widget.VoltraWidgetReceiver
 
 class VoltraModule(
     reactContext: ReactApplicationContext,
@@ -37,6 +44,48 @@ class VoltraModule(
         VoltraImageManager(reactApplicationContext)
     }
 
+    // Last-seen night-mode bit. ACTION_CONFIGURATION_CHANGED also fires for rotation, font scale,
+    // locale, etc., so we re-render only when the light/dark bit actually changes.
+    private var lastNightMode: Int =
+        reactContext.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK
+
+    // Re-renders client widgets when the system color scheme (light/dark) flips. Client widgets read
+    // env.colorScheme on-device, so a flip must re-run their render. Uses ComponentCallbacks rather
+    // than an ACTION_CONFIGURATION_CHANGED BroadcastReceiver: onConfigurationChanged delivers the
+    // authoritative new Configuration (a receiver's context.resources lags the change), and it isn't
+    // subject to the cached-process broadcast restrictions. Active while the host process is alive.
+    private val configurationCallbacks =
+        object : ComponentCallbacks {
+            override fun onConfigurationChanged(newConfig: Configuration) {
+                val nightMode = newConfig.uiMode and Configuration.UI_MODE_NIGHT_MASK
+                if (nightMode == lastNightMode) return
+                lastNightMode = nightMode
+                CoroutineScope(Dispatchers.IO).launch {
+                    try {
+                        widgetManager.reloadClientWidgets()
+                    } catch (e: Exception) {
+                        Log.e(TAG, "Color-scheme reload failed: ${e.message}")
+                    }
+                }
+            }
+
+            override fun onLowMemory() = Unit
+        }
+
+    override fun initialize() {
+        super.initialize()
+        reactApplicationContext.registerComponentCallbacks(configurationCallbacks)
+    }
+
+    override fun invalidate() {
+        try {
+            reactApplicationContext.unregisterComponentCallbacks(configurationCallbacks)
+        } catch (e: Exception) {
+            Log.w(TAG, "Failed to unregister configuration callbacks: ${e.message}")
+        }
+        super.invalidate()
+    }
+
     override fun startAndroidOngoingNotification(
         payload: String,
         options: ReadableMap,
@@ -153,6 +202,26 @@ class VoltraModule(
         promise.resolve(null)
     }
 
+    override fun setWidgetConfiguration(
+        widgetId: String,
+        key: String,
+        value: String,
+        promise: Promise,
+    ) {
+        // Stand-in for a Glance configuration activity: persist a config value and re-render the
+        // widget so its client render picks it up via env.configuration.
+        runBlocking {
+            try {
+                VoltraConfigurationStore(reactApplicationContext).set(widgetId, key, value)
+                VoltraWidgetReceiver.triggerGlanceUpdate(reactApplicationContext, widgetId)
+                promise.resolve(null)
+            } catch (e: Exception) {
+                Log.e(TAG, "setWidgetConfiguration failed", e)
+                promise.reject("VOLTRA_WIDGET_CONFIG_ERROR", e.message, e)
+            }
+        }
+    }
+
     override fun clearAndroidWidget(
         widgetId: String,
         promise: Promise,
diff --git a/packages/android-client/android/src/main/java/voltra/parsing/VoltraDecompressor.kt b/packages/android-client/android/src/main/java/voltra/parsing/VoltraDecompressor.kt
index 761ac53b..e55c714a 100644
--- a/packages/android-client/android/src/main/java/voltra/parsing/VoltraDecompressor.kt
+++ b/packages/android-client/android/src/main/java/voltra/parsing/VoltraDecompressor.kt
@@ -25,7 +25,12 @@ object VoltraDecompressor {
             e = payload.e?.map { decompressNode(it) },
         )
 
-    private fun decompressNode(node: VoltraNode): VoltraNode =
+    /**
+     * Expand short keys in a standalone node tree (no surrounding payload). Used by the
+     * client-rendered path, where the on-device renderer emits a single node with the same
+     * short-key format as server payloads but without the `{v, variants, s, e}` envelope.
+     */
+    fun decompressNode(node: VoltraNode): VoltraNode =
         when (node) {
             is VoltraNode.Element -> VoltraNode.Element(decompressElement(node.element))
             is VoltraNode.Array -> VoltraNode.Array(node.elements.map { decompressNode(it) })
diff --git a/packages/android-client/android/src/main/java/voltra/runtime/VoltraConfigurationStore.kt b/packages/android-client/android/src/main/java/voltra/runtime/VoltraConfigurationStore.kt
new file mode 100644
index 00000000..b2cf1d5a
--- /dev/null
+++ b/packages/android-client/android/src/main/java/voltra/runtime/VoltraConfigurationStore.kt
@@ -0,0 +1,94 @@
+package voltra.runtime
+
+import android.content.Context
+import android.util.Log
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.datastore.preferences.preferencesDataStore
+import kotlinx.coroutines.flow.first
+import org.json.JSONObject
+import java.io.IOException
+
+/**
+ * DataStore-backed per-widget configuration for client-rendered widgets — the values surfaced as
+ * `env.configuration` in the widget's `(props, env) => JSX` render.
+ *
+ * Two layers, merged at read time:
+ *  - **Defaults** declared in code (`app.json` widget `appIntent.parameters[].default`), emitted by
+ *    the config plugin to `assets/voltra/widget_config_defaults.json`. These are the values the
+ *    widget shows before the user configures anything — the Android equivalent of iOS's
+ *    `@Parameter(default:)`.
+ *  - **Stored** values written at runtime (see setWidgetConfiguration), which override the defaults.
+ *
+ * Stands in for a real Glance configuration activity: Android has no system-managed widget
+ * configuration equivalent of iOS's WidgetConfigurationIntent, so runtime values are written by an
+ * in-app screen and read here at render time. Keys are namespaced `voltra.config.<widgetId>.<key>`.
+ */
+internal class VoltraConfigurationStore(
+    private val context: Context,
+) {
+    /** Code-declared defaults merged with stored runtime values (stored wins). */
+    suspend fun get(widgetId: String): Map<String, String> = loadDefaults(widgetId) + getStored(widgetId)
+
+    suspend fun set(
+        widgetId: String,
+        key: String,
+        value: String,
+    ) {
+        val prefKey = stringPreferencesKey(keyPrefix(widgetId) + key)
+        context.voltraConfigurationDataStore.edit { it[prefKey] = value }
+    }
+
+    private suspend fun getStored(widgetId: String): Map<String, String> {
+        val prefix = keyPrefix(widgetId)
+        val snapshot = context.voltraConfigurationDataStore.data.first()
+        val out = mutableMapOf<String, String>()
+        snapshot.asMap().forEach { (key, value) ->
+            if (key.name.startsWith(prefix) && value is String) {
+                out[key.name.substring(prefix.length)] = value
+            }
+        }
+        return out
+    }
+
+    // Reads the plugin-emitted defaults once and caches them: { "<widgetId>": { "<key>": "<value>" } }.
+    private fun loadDefaults(widgetId: String): Map<String, String> {
+        val cached = defaultsCache
+        if (cached != null) return cached[widgetId] ?: emptyMap()
+
+        val parsed =
+            try {
+                context.assets
+                    .open(DEFAULTS_ASSET_PATH)
+                    .bufferedReader()
+                    .use { it.readText() }
+            } catch (e: IOException) {
+                Log.d(TAG, "No $DEFAULTS_ASSET_PATH — client widget configuration starts empty")
+                defaultsCache = emptyMap()
+                return emptyMap()
+            }
+
+        val root = JSONObject(parsed)
+        val all = mutableMapOf<String, Map<String, String>>()
+        root.keys().forEach { id ->
+            val obj = root.getJSONObject(id)
+            val widgetMap = mutableMapOf<String, String>()
+            obj.keys().forEach { key -> widgetMap[key] = obj.getString(key) }
+            all[id] = widgetMap
+        }
+        defaultsCache = all
+        return all[widgetId] ?: emptyMap()
+    }
+
+    private fun keyPrefix(widgetId: String): String = "voltra.config.$widgetId."
+
+    companion object {
+        private const val TAG = "VoltraConfigurationStore"
+        private const val DEFAULTS_ASSET_PATH = "voltra/widget_config_defaults.json"
+
+        @Volatile
+        private var defaultsCache: Map<String, Map<String, String>>? = null
+    }
+}
+
+private val Context.voltraConfigurationDataStore by preferencesDataStore(name = "voltra_widget_configuration")
diff --git a/packages/android-client/android/src/main/java/voltra/runtime/VoltraJSRenderer.kt b/packages/android-client/android/src/main/java/voltra/runtime/VoltraJSRenderer.kt
new file mode 100644
index 00000000..9ff215d3
--- /dev/null
+++ b/packages/android-client/android/src/main/java/voltra/runtime/VoltraJSRenderer.kt
@@ -0,0 +1,147 @@
+package voltra.runtime
+
+import android.util.Log
+
+/**
+ * Standalone Hermes runtime for Voltra **client-rendered widgets**.
+ *
+ * Architectural mirror of iOS `VoltraJSRenderer.swift` (JSC). Each per-widget Metro bundle
+ * exposes `render(props, env)`; [evaluateBundle] evaluates it once in a single process-wide
+ * Hermes runtime, capturing the bundle's exports under `globalThis.__voltraWidgets[<id>]`,
+ * and [render] invokes that function on every Glance render.
+ *
+ * Lifecycle: one Hermes runtime per process (created lazily in native code on first
+ * evaluate). Re-evaluating the same widget overwrites its captured exports — used by
+ * dev-mode hot reload (always-refetch).
+ *
+ * Thread safety: a single lock guards both evaluate and render, matching iOS's NSLock.
+ */
+object VoltraJSRenderer {
+    private const val TAG = "VoltraJSRenderer"
+
+    init {
+        System.loadLibrary("voltra_js_renderer")
+    }
+
+    private val lock = Any()
+
+    private external fun nativeEvaluateBundle(
+        wrappedSource: String,
+        sourceURL: String,
+        widgetId: String,
+    ): Boolean
+
+    private external fun nativeRender(
+        widgetId: String,
+        propsJSON: String,
+        envJSON: String,
+    ): String?
+
+    /**
+     * Minimal global shims. The widget Metro bundle runs in a *bare* Hermes runtime (no RN
+     * preamble — the widget Metro config strips polyfills), but React's dev build and a few
+     * helpers reference `console` / timers that Hermes does not define out of the box. JSC
+     * (iOS) happened to tolerate their absence; Hermes does not, so we inject no-op stand-ins
+     * before the bundle. Voltra's renderer is fully synchronous, so timers are never actually
+     * needed during a render — the no-ops exist only so references don't throw.
+     */
+    private val GLOBAL_SHIMS =
+        """
+        (function (g) {
+          if (typeof g.console === 'undefined') {
+            var noop = function () {};
+            g.console = {
+              log: noop, info: noop, warn: noop, error: noop, debug: noop, trace: noop,
+              group: noop, groupCollapsed: noop, groupEnd: noop, table: noop, assert: noop,
+              dir: noop, count: noop, time: noop, timeEnd: noop
+            };
+          }
+          if (typeof g.setTimeout === 'undefined') { g.setTimeout = function () { return 0; }; }
+          if (typeof g.clearTimeout === 'undefined') { g.clearTimeout = function () {}; }
+          if (typeof g.setInterval === 'undefined') { g.setInterval = function () { return 0; }; }
+          if (typeof g.clearInterval === 'undefined') { g.clearInterval = function () {}; }
+          if (typeof g.setImmediate === 'undefined') { g.setImmediate = function () { return 0; }; }
+        })(typeof globalThis !== 'undefined' ? globalThis : this);
+        """.trimIndent()
+
+    /**
+     * Evaluate a widget bundle (raw Metro `/voltra/widgets/<id>.bundle` output) and capture
+     * its `render(props, env)` export. Idempotent: re-evaluating overwrites the capture.
+     *
+     * The raw bundle ends with Metro's entry invocation `__r(<entryId>);`. We re-invoke that
+     * entry and stash its exports in `globalThis.__voltraWidgets[<id>]` (Metro's `__r` caches
+     * module exports, so the second invocation returns the already-evaluated module).
+     */
+    fun evaluateBundle(
+        source: String,
+        widgetId: String,
+    ): Boolean =
+        synchronized(lock) {
+            val entryModuleId = extractEntryModuleId(source) ?: 0
+            val wrapped =
+                buildString {
+                    append(GLOBAL_SHIMS)
+                    append('\n')
+                    append(source)
+                    append('\n')
+                    append(";(function () {\n")
+                    append("  if (!globalThis.__voltraWidgets) { globalThis.__voltraWidgets = {}; }\n")
+                    append("  globalThis.__voltraWidgets[")
+                    append(jsStringLiteral(widgetId))
+                    append("] = __r(")
+                    append(entryModuleId)
+                    append(");\n")
+                    append("})();\n")
+                }
+            val ok =
+                try {
+                    nativeEvaluateBundle(wrapped, "voltra/$widgetId.bundle", widgetId)
+                } catch (t: Throwable) {
+                    Log.e(TAG, "nativeEvaluateBundle threw for widgetId=$widgetId", t)
+                    false
+                }
+            ok
+        }
+
+    /**
+     * Invoke the previously-evaluated widget's `render(propsJSON, envJSON)` and return its
+     * resolved JSON string. Returns null if the widget was not evaluated, the function throws,
+     * or it did not return a string.
+     */
+    fun render(
+        widgetId: String,
+        propsJSON: String,
+        envJSON: String,
+    ): String? =
+        synchronized(lock) {
+            try {
+                nativeRender(widgetId, propsJSON, envJSON)
+            } catch (t: Throwable) {
+                Log.e(TAG, "nativeRender threw for widgetId=$widgetId", t)
+                null
+            }
+        }
+
+    /**
+     * Find the entry module id Metro emitted in the bundle's trailing `__r(<id>);`. Every
+     * `__d(...)` module body also contains internal `__r(...)` calls, so we take the LAST
+     * match — the entry invocation Metro appends at the end of the bundle. Mirrors iOS's
+     * `extractEntryModuleId`.
+     */
+    private fun extractEntryModuleId(source: String): Int? =
+        Regex("""__r\((\d+)\);""")
+            .findAll(source)
+            .lastOrNull()
+            ?.groupValues
+            ?.get(1)
+            ?.toIntOrNull()
+
+    private fun jsStringLiteral(value: String): String =
+        "\"" +
+            value
+                .replace("\\", "\\\\")
+                .replace("\"", "\\\"")
+                .replace("\n", "\\n")
+                .replace("\r", "\\r") +
+            "\""
+}
diff --git a/packages/android-client/android/src/main/java/voltra/widget/VoltraClientGlanceWidget.kt b/packages/android-client/android/src/main/java/voltra/widget/VoltraClientGlanceWidget.kt
new file mode 100644
index 00000000..9bdd4d20
--- /dev/null
+++ b/packages/android-client/android/src/main/java/voltra/widget/VoltraClientGlanceWidget.kt
@@ -0,0 +1,261 @@
+package voltra.widget
+
+import android.content.Context
+import android.content.pm.ApplicationInfo
+import android.content.res.Configuration
+import android.util.Log
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.DpSize
+import androidx.compose.ui.unit.dp
+import androidx.glance.GlanceId
+import androidx.glance.GlanceModifier
+import androidx.glance.LocalContext
+import androidx.glance.LocalSize
+import androidx.glance.appwidget.GlanceAppWidget
+import androidx.glance.appwidget.SizeMode
+import androidx.glance.appwidget.provideContent
+import androidx.glance.layout.Alignment
+import androidx.glance.layout.Box
+import androidx.glance.layout.fillMaxSize
+import androidx.glance.layout.padding
+import androidx.glance.text.Text
+import androidx.glance.unit.ColorProvider
+import com.facebook.react.modules.systeminfo.AndroidInfoHelpers
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.json.Json
+import org.json.JSONObject
+import voltra.BuildConfig
+import voltra.glance.GlanceFactory
+import voltra.models.VoltraNode
+import voltra.parsing.VoltraDecompressor
+import voltra.runtime.VoltraConfigurationStore
+import voltra.runtime.VoltraJSRenderer
+import java.net.HttpURLConnection
+import java.net.URL
+
+/**
+ * Client-rendered Voltra widget: downloads a per-widget JS bundle (Metro in dev), evaluates it
+ * in the standalone Hermes runtime, and invokes its `render(props, env)` on every Glance render
+ * — the Android counterpart of iOS's VoltraClientWidgetProvider.
+ *
+ * Pipeline:
+ *  1. provideGlance (suspend, off the composition): fetch the bundle from Metro and evaluate it
+ *     via [VoltraJSRenderer.evaluateBundle].
+ *  2. Content (composable): read LocalSize/locale/scheme, build the WidgetEnvironment JSON, call
+ *     [VoltraJSRenderer.render], decompress the resulting node, and hand it to [GlanceFactory] —
+ *     the same renderer server-rendered widgets use, so the two look identical.
+ *
+ * On fetch/eval/render failure the widget shows a minimal fallback; the config plugin supplies
+ * a prerendered placeholder for the first paint and the offline case.
+ */
+class VoltraClientGlanceWidget(
+    private val widgetId: String = "default",
+) : GlanceAppWidget() {
+    companion object {
+        private const val TAG = "VoltraClientGlanceWidget"
+
+        private val json =
+            Json {
+                ignoreUnknownKeys = true
+                explicitNulls = false
+            }
+
+        /** Fetch the raw widget bundle from Metro (dev). Returns null on any network error. */
+        private suspend fun fetchDevBundle(
+            context: Context,
+            widgetId: String,
+        ): String? =
+            withContext(Dispatchers.IO) {
+                // AndroidInfoHelpers resolves the dev server host for emulator (10.0.2.2),
+                // physical device, or adb-reverse — the RN-native equivalent of iOS's
+                // RCTBundleURLProvider.
+                val host = AndroidInfoHelpers.getServerHost(context)
+                val urlString = "http://$host/voltra/widgets/$widgetId.bundle?platform=android&dev=true"
+                val t0 = System.nanoTime()
+                try {
+                    val connection = URL(urlString).openConnection() as HttpURLConnection
+                    connection.connectTimeout = 5_000
+                    connection.readTimeout = 5_000
+                    connection.requestMethod = "GET"
+                    try {
+                        val code = connection.responseCode
+                        if (code !in 200..299) {
+                            Log.e(TAG, "Metro HTTP $code for $urlString")
+                            return@withContext null
+                        }
+                        val body = connection.inputStream.bufferedReader().use { it.readText() }
+                        if (BuildConfig.DEBUG) {
+                            Log.i(
+                                TAG,
+                                "[perf] metro fetch: ${"%.2f".format(
+                                    (System.nanoTime() - t0) / 1_000_000.0,
+                                )} ms (${body.length} chars)",
+                            )
+                        }
+                        body
+                    } finally {
+                        connection.disconnect()
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Metro fetch failed ($urlString): ${e.message}")
+                    null
+                }
+            }
+
+        /**
+         * Read the release bundle baked into the app's assets by the Gradle bundling task
+         * (assets/voltra/voltra-widget-<id>.bundle). The release counterpart of [fetchDevBundle];
+         * returns null (→ prerendered fallback) when the asset is missing.
+         */
+        private fun loadBakedBundle(
+            context: Context,
+            widgetId: String,
+        ): String? =
+            try {
+                context.assets
+                    .open("voltra/voltra-widget-$widgetId.bundle")
+                    .bufferedReader()
+                    .use { it.readText() }
+            } catch (e: java.io.IOException) {
+                Log.w(TAG, "No baked bundle for widgetId=$widgetId (assets/voltra/voltra-widget-$widgetId.bundle)")
+                null
+            }
+
+        private fun isDev(context: Context): Boolean =
+            (context.applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE) != 0
+
+        /**
+         * Build the WidgetEnvironment JSON (see packages/core/src/widget-environment.ts) for the
+         * current render.
+         */
+        private fun buildEnvJson(
+            context: Context,
+            size: DpSize,
+            configuration: Map<String, String>,
+        ): String {
+            val family = "${size.width.value.toInt()}x${size.height.value.toInt()}"
+            val nightMode =
+                context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK
+            val colorScheme = if (nightMode == Configuration.UI_MODE_NIGHT_YES) "dark" else "light"
+            val locale =
+                context.resources.configuration.locales[0]
+                    .toLanguageTag()
+            val dev = isDev(context)
+            val appVersion =
+                try {
+                    context.packageManager.getPackageInfo(context.packageName, 0).versionName ?: "unknown"
+                } catch (e: Exception) {
+                    "unknown"
+                }
+
+            val build =
+                JSONObject()
+                    .put("isDev", dev)
+                    .put(
+                        "metroUrl",
+                        if (dev) "http://${AndroidInfoHelpers.getServerHost(context)}" else JSONObject.NULL,
+                    ).put("appVersion", appVersion)
+                    .put("voltraVersion", BuildConfig.VOLTRA_VERSION)
+
+            val configObject = JSONObject()
+            configuration.forEach { (key, value) -> configObject.put(key, value) }
+
+            return JSONObject()
+                .put("date", System.currentTimeMillis())
+                .put("widgetFamily", family)
+                .put("colorScheme", colorScheme)
+                .put("locale", locale)
+                .put("configuration", configObject)
+                .put("build", build)
+                .toString()
+        }
+    }
+
+    // One node is rendered for the actual on-screen size (env carries the size); no multi-variant
+    // selection on the client path. SizeMode.Exact re-composes provideGlance with the real
+    // LocalSize on every resize, so env.widgetFamily and the node track the new size.
+    override val sizeMode = SizeMode.Exact
+
+    override suspend fun provideGlance(
+        context: Context,
+        id: GlanceId,
+    ) {
+        val source = if (isDev(context)) fetchDevBundle(context, widgetId) else loadBakedBundle(context, widgetId)
+        val bundleReady = source != null && VoltraJSRenderer.evaluateBundle(source, widgetId)
+        if (!bundleReady) {
+            Log.w(TAG, "Bundle not ready for widgetId=$widgetId (dev=${isDev(context)})")
+        }
+
+        // Read user-configured params (DataStore) off the composition so env.configuration is
+        // available synchronously during render.
+        val configuration = VoltraConfigurationStore(context).get(widgetId)
+
+        provideContent {
+            Content(bundleReady, configuration)
+        }
+    }
+
+    @Composable
+    private fun Content(
+        bundleReady: Boolean,
+        configuration: Map<String, String>,
+    ) {
+        val context = LocalContext.current
+        val size = LocalSize.current
+
+        // Live render when the bundle is ready; otherwise fall back to the plugin-prerendered
+        // placeholder node (first paint / offline / Metro down).
+        val node = (if (bundleReady) renderNode(context, size, configuration) else null) ?: placeholderNode(context)
+        if (node != null) {
+            GlanceFactory(widgetId, null, null, size).Render(node)
+        } else {
+            Fallback()
+        }
+    }
+
+    private fun renderNode(
+        context: Context,
+        size: DpSize,
+        configuration: Map<String, String>,
+    ): VoltraNode? {
+        val envJson = buildEnvJson(context, size, configuration)
+        val resolved = VoltraJSRenderer.render(widgetId, "{}", envJson) ?: return null
+        return parseNode(resolved)
+    }
+
+    /** Decode the plugin-prerendered single-node placeholder from the initial-states asset. */
+    private fun placeholderNode(context: Context): VoltraNode? {
+        val raw = VoltraWidgetManager(context).readWidgetJson(widgetId) ?: return null
+        return parseNode(raw)
+    }
+
+    private fun parseNode(jsonString: String): VoltraNode? =
+        try {
+            val t0 = System.nanoTime()
+            val node = VoltraDecompressor.decompressNode(json.decodeFromString<VoltraNode>(jsonString))
+            if (BuildConfig.DEBUG) {
+                Log.i(
+                    TAG,
+                    "[perf] decode+decompress: ${"%.2f".format(
+                        (System.nanoTime() - t0) / 1_000_000.0,
+                    )} ms (${jsonString.length} chars)",
+                )
+            }
+            node
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to parse node for widgetId=$widgetId: ${e.message}")
+            null
+        }
+
+    @Composable
+    private fun Fallback() {
+        Box(
+            modifier = GlanceModifier.fillMaxSize().padding(16.dp),
+            contentAlignment = Alignment.Center,
+        ) {
+            Text(text = "Loading…", style = androidx.glance.text.TextStyle(color = ColorProvider(Color.Gray)))
+        }
+    }
+}
diff --git a/packages/android-client/android/src/main/java/voltra/widget/VoltraClientWidgetReceiver.kt b/packages/android-client/android/src/main/java/voltra/widget/VoltraClientWidgetReceiver.kt
new file mode 100644
index 00000000..cd718ca2
--- /dev/null
+++ b/packages/android-client/android/src/main/java/voltra/widget/VoltraClientWidgetReceiver.kt
@@ -0,0 +1,19 @@
+package voltra.widget
+
+import android.content.Context
+import androidx.glance.appwidget.GlanceAppWidget
+
+/**
+ * Base receiver for client-rendered Voltra widgets. Identical lifecycle to
+ * [VoltraWidgetReceiver] but hosts a [VoltraClientGlanceWidget] (on-device JS render) instead
+ * of the server-rendered [VoltraGlanceWidget].
+ *
+ * Generated client receivers extend this and provide their `widgetId`.
+ */
+abstract class VoltraClientWidgetReceiver : VoltraWidgetReceiver() {
+    override fun createGlanceAppWidget(): GlanceAppWidget = VoltraClientGlanceWidget(widgetId)
+
+    // Client widgets use SizeMode.Exact, so Glance re-composes provideGlance for the new size on
+    // resize. The server-cache re-render path doesn't apply (there is no cached payload).
+    override fun onWidgetResized(context: Context) = Unit
+}
diff --git a/packages/android-client/android/src/main/java/voltra/widget/VoltraWidgetManager.kt b/packages/android-client/android/src/main/java/voltra/widget/VoltraWidgetManager.kt
index a5a2543e..55381a08 100644
--- a/packages/android-client/android/src/main/java/voltra/widget/VoltraWidgetManager.kt
+++ b/packages/android-client/android/src/main/java/voltra/widget/VoltraWidgetManager.kt
@@ -399,19 +399,83 @@ class VoltraWidgetManager(
 
             // Also include server-driven widgets that may not have cached data yet
             val serverDrivenIds = VoltraWidgetUpdateScheduler.getAllServerDrivenWidgetIds(context)
-            val allWidgetIds = widgetIds + serverDrivenIds
+            val cachedAndServerIds = widgetIds + serverDrivenIds
+
+            // Pinned widgets that have neither cached data nor a server URL are client-rendered
+            // (they render from Metro). reloadSingleWidget's cache path can't refresh them, so
+            // trigger their Glance update directly to re-run provideGlance.
+            val pinnedIds = pinnedVoltraWidgetIds()
+            val clientIds = pinnedIds - cachedAndServerIds
 
             Log.d(
                 TAG,
-                "Found ${allWidgetIds.size} widgets to reload (${widgetIds.size} cached, ${serverDrivenIds.size} server-driven)",
+                "Found ${cachedAndServerIds.size + clientIds.size} widgets to reload " +
+                    "(${widgetIds.size} cached, ${serverDrivenIds.size} server-driven, ${clientIds.size} client-rendered)",
             )
 
-            for (widgetId in allWidgetIds) {
+            for (widgetId in cachedAndServerIds) {
                 try {
                     reloadSingleWidget(widgetId)
                 } catch (e: Exception) {
                     Log.e(TAG, "Failed to update widget $widgetId: ${e.message}")
                 }
             }
+            for (widgetId in clientIds) {
+                try {
+                    VoltraWidgetReceiver.triggerGlanceUpdate(context, widgetId)
+                } catch (e: Exception) {
+                    Log.e(TAG, "Failed to update client widget $widgetId: ${e.message}")
+                }
+            }
+        }
+
+    /**
+     * Re-render only client-rendered widgets (pinned widgets with neither cached data nor a server
+     * URL — they render on-device from `provideGlance`). Used to react to environment changes that
+     * affect `env` but not server payloads, e.g. a light/dark (color scheme) toggle.
+     */
+    suspend fun reloadClientWidgets() =
+        withContext(Dispatchers.Main) {
+            val cachedIds =
+                prefs.all.keys
+                    .filter { it.startsWith(KEY_JSON_PREFIX) }
+                    .map { it.removePrefix(KEY_JSON_PREFIX) }
+                    .toSet()
+            val serverDrivenIds = VoltraWidgetUpdateScheduler.getAllServerDrivenWidgetIds(context)
+            val clientIds = pinnedVoltraWidgetIds() - cachedIds - serverDrivenIds
+
+            Log.d(TAG, "reloadClientWidgets: ${clientIds.size} client widget(s)")
+            for (widgetId in clientIds) {
+                try {
+                    VoltraWidgetReceiver.triggerGlanceUpdate(context, widgetId)
+                } catch (e: Exception) {
+                    Log.e(TAG, "Failed to reload client widget $widgetId: ${e.message}")
+                }
+            }
+        }
+
+    /**
+     * Widget ids of all currently-pinned Voltra widgets, derived from bound AppWidget providers
+     * named `<pkg>.widget.VoltraWidget_<id>Receiver`. Covers client-rendered widgets, which keep no
+     * cached prefs data, so reloadAllWidgets reaches them too.
+     */
+    private fun pinnedVoltraWidgetIds(): Set<String> {
+        val appWidgetManager = AppWidgetManager.getInstance(context)
+        val prefix = "VoltraWidget_"
+        val suffix = "Receiver"
+        val ids = mutableSetOf<String>()
+        try {
+            for (provider in appWidgetManager.installedProviders) {
+                val componentName = provider.provider
+                if (componentName.packageName != context.packageName) continue
+                val simpleName = componentName.className.substringAfterLast('.')
+                if (!simpleName.startsWith(prefix) || !simpleName.endsWith(suffix)) continue
+                if (appWidgetManager.getAppWidgetIds(componentName).isEmpty()) continue // not pinned
+                ids.add(simpleName.removePrefix(prefix).removeSuffix(suffix))
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "pinnedVoltraWidgetIds failed: ${e.message}")
         }
+        return ids
+    }
 }
diff --git a/packages/android-client/android/src/main/java/voltra/widget/VoltraWidgetReceiver.kt b/packages/android-client/android/src/main/java/voltra/widget/VoltraWidgetReceiver.kt
index 3b2a3b02..3a0173ad 100644
--- a/packages/android-client/android/src/main/java/voltra/widget/VoltraWidgetReceiver.kt
+++ b/packages/android-client/android/src/main/java/voltra/widget/VoltraWidgetReceiver.kt
@@ -102,18 +102,23 @@ abstract class VoltraWidgetReceiver : GlanceAppWidgetReceiver() {
      */
     abstract val widgetId: String
 
+    /**
+     * The GlanceAppWidget this receiver hosts. Defaults to the server-rendered
+     * [VoltraGlanceWidget]; client-rendered receivers override this to return a
+     * [voltra.widget.VoltraClientGlanceWidget]. Kept as a factory (not a direct property) so
+     * the shared registry registration in [glanceAppWidget] stays in one place.
+     */
+    protected open fun createGlanceAppWidget(): GlanceAppWidget = VoltraGlanceWidget(widgetId)
+
     override val glanceAppWidget: GlanceAppWidget by lazy {
-        Log.d(TAG, "Creating VoltraGlanceWidget for widgetId=$widgetId")
-        val widget = VoltraGlanceWidget(widgetId)
+        Log.d(TAG, "Creating GlanceAppWidget for widgetId=$widgetId")
+        val widget = createGlanceAppWidget()
         widgetRegistry[widgetId] = widget
         widget
     }
 
     /**
      * Called when the user resizes a widget on the home screen.
-     * The server returns all size variants in every response, so we just
-     * re-render from cached data — RemoteViews(sizeMapping) picks the closest match.
-     * No network request needed.
      */
     override fun onAppWidgetOptionsChanged(
         context: Context,
@@ -125,8 +130,19 @@ abstract class VoltraWidgetReceiver : GlanceAppWidgetReceiver() {
 
         val w = newOptions.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_WIDTH, 0)
         val h = newOptions.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT, 0)
-        Log.d(TAG, "Widget '$widgetId' resized to ${w}x$h, re-rendering from cache")
+        Log.d(TAG, "Widget '$widgetId' resized to ${w}x$h")
 
+        onWidgetResized(context)
+    }
+
+    /**
+     * Re-render after a resize. Server-rendered widgets re-render from cached data — the payload
+     * carries all size variants, so RemoteViews(sizeMapping) picks the closest match; no network
+     * request needed. Client-rendered widgets override this to no-op: they use
+     * `SizeMode.Exact`, so Glance already re-composes `provideGlance` for the new size (and there
+     * is no cached payload to re-render from).
+     */
+    protected open fun onWidgetResized(context: Context) {
         CoroutineScope(Dispatchers.IO).launch {
             val widgetManager = VoltraWidgetManager(context.applicationContext)
             widgetManager.updateWidgetDirect(widgetId)
diff --git a/packages/android-client/android/src/test/java/voltra/parsing/VoltraDecompressorNodeTest.kt b/packages/android-client/android/src/test/java/voltra/parsing/VoltraDecompressorNodeTest.kt
new file mode 100644
index 00000000..c4555144
--- /dev/null
+++ b/packages/android-client/android/src/test/java/voltra/parsing/VoltraDecompressorNodeTest.kt
@@ -0,0 +1,57 @@
+package voltra.parsing
+
+import kotlinx.serialization.json.Json
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import voltra.models.VoltraNode
+
+/**
+ * Verifies [VoltraDecompressor.decompressNode] expands short keys in a standalone node tree —
+ * the client-rendered path decodes the on-device renderer's output as a bare [VoltraNode]
+ * (no `{v, variants, s, e}` envelope) and must decompress it before handing it to the Glance
+ * renderer, which expects expanded keys.
+ */
+@RunWith(RobolectricTestRunner::class)
+class VoltraDecompressorNodeTest {
+    private val json =
+        Json {
+            ignoreUnknownKeys = true
+            explicitNulls = false
+        }
+
+    @Test
+    fun expandsShortKeysInStandaloneNode() {
+        // Shape mirrors what renderAndroidVariantToJson emits: a Column with an inline style and
+        // a Text child with its own style. `s` -> style, `bg` -> backgroundColor, `fs` -> fontSize.
+        val node =
+            json.decodeFromString<VoltraNode>(
+                """
+                {"t":9,"p":{"s":{"bg":"#000000"}},"c":[{"t":18,"c":"Hi","p":{"s":{"fs":14}}}]}
+                """.trimIndent(),
+            )
+
+        val decompressed = VoltraDecompressor.decompressNode(node)
+
+        assertTrue("root should be an Element", decompressed is VoltraNode.Element)
+        val root = (decompressed as VoltraNode.Element).element
+        assertEquals(9, root.t)
+
+        @Suppress("UNCHECKED_CAST")
+        val rootStyle = root.p?.get("style") as? Map<String, Any?>
+        assertTrue("root prop 's' should expand to 'style'", rootStyle != null)
+        assertEquals("#000000", rootStyle!!["backgroundColor"])
+
+        val childNode = root.c
+        assertTrue("child should be an Array", childNode is VoltraNode.Array)
+        val child = (childNode as VoltraNode.Array).elements[0]
+        assertTrue("child should be an Element", child is VoltraNode.Element)
+
+        @Suppress("UNCHECKED_CAST")
+        val childStyle = (child as VoltraNode.Element).element.p?.get("style") as? Map<String, Any?>
+        assertTrue("child prop 's' should expand to 'style'", childStyle != null)
+        assertTrue("child style should contain expanded 'fontSize'", childStyle!!.containsKey("fontSize"))
+    }
+}
diff --git a/packages/android-client/expo-plugin/src/android/clientRendered.node.test.ts b/packages/android-client/expo-plugin/src/android/clientRendered.node.test.ts
new file mode 100644
index 00000000..7270a121
--- /dev/null
+++ b/packages/android-client/expo-plugin/src/android/clientRendered.node.test.ts
@@ -0,0 +1,110 @@
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+
+import type { AndroidWidgetConfig } from '../types'
+import { detectClientRenderedWidgets } from './clientRendered'
+
+function makeTempProject(files: Record<string, string>): { projectRoot: string; cleanup: () => void } {
+  const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'voltra-android-client-rendered-test-'))
+  for (const [rel, content] of Object.entries(files)) {
+    const abs = path.join(projectRoot, rel)
+    fs.mkdirSync(path.dirname(abs), { recursive: true })
+    fs.writeFileSync(abs, content)
+  }
+  return {
+    projectRoot,
+    cleanup: () => fs.rmSync(projectRoot, { recursive: true, force: true }),
+  }
+}
+
+function asWidget(partial: Partial<AndroidWidgetConfig>): AndroidWidgetConfig {
+  return {
+    id: 'placeholder',
+    displayName: 'Placeholder',
+    description: 'Placeholder',
+    targetCellWidth: 2,
+    targetCellHeight: 2,
+    ...partial,
+  }
+}
+
+// Detection emits a one-time EXPERIMENTAL console.warn; keep it out of test output (the dedicated
+// suite below asserts on it explicitly).
+beforeEach(() => {
+  jest.spyOn(console, 'warn').mockImplementation(() => {})
+})
+afterEach(() => {
+  jest.restoreAllMocks()
+})
+
+describe('detectClientRenderedWidgets (android)', () => {
+  it('flags a use voltra component as client-rendered when the id matches', () => {
+    const { projectRoot, cleanup } = makeTempProject({
+      'widgets/Foo.tsx': `
+        export const Foo = (props, env) => {
+          'use voltra'
+          return null
+        }
+      `,
+    })
+    try {
+      const [detected] = detectClientRenderedWidgets(
+        [asWidget({ id: 'Foo', initialStatePath: './widgets/Foo.tsx' })],
+        projectRoot
+      )
+      expect(detected.clientRendered).toBe(true)
+    } finally {
+      cleanup()
+    }
+  })
+})
+
+describe('detectClientRenderedWidgets (android) — experimental warning', () => {
+  // The warning fires at most once per module instance, so re-require a fresh module per test.
+  function freshDetect(): typeof detectClientRenderedWidgets {
+    let fn: typeof detectClientRenderedWidgets = detectClientRenderedWidgets
+    jest.isolateModules(() => {
+      fn = require('./clientRendered').detectClientRenderedWidgets
+    })
+    return fn
+  }
+
+  it('warns once (with EXPERIMENTAL + the widget id) when a client-rendered widget is detected', () => {
+    const detect = freshDetect()
+    const warn = console.warn as jest.Mock
+    const { projectRoot, cleanup } = makeTempProject({
+      'widgets/Foo.tsx': `
+        export const Foo = (props, env) => {
+          'use voltra'
+          return null
+        }
+      `,
+    })
+    try {
+      const widgets = [asWidget({ id: 'Foo', initialStatePath: './widgets/Foo.tsx' })]
+      detect(widgets, projectRoot)
+      detect(widgets, projectRoot)
+
+      expect(warn).toHaveBeenCalledTimes(1)
+      expect(warn.mock.calls[0][0]).toContain('EXPERIMENTAL')
+      expect(warn.mock.calls[0][0]).toContain('Foo')
+    } finally {
+      cleanup()
+    }
+  })
+
+  it('does not warn when all widgets are server-rendered', () => {
+    const detect = freshDetect()
+    const warn = console.warn as jest.Mock
+    const { projectRoot, cleanup } = makeTempProject({
+      'widgets/Bar.tsx': 'export default () => null\n',
+    })
+    try {
+      detect([asWidget({ id: 'Bar', initialStatePath: './widgets/Bar.tsx' })], projectRoot)
+      expect(warn).not.toHaveBeenCalled()
+    } finally {
+      cleanup()
+    }
+  })
+})
diff --git a/packages/android-client/expo-plugin/src/android/clientRendered.ts b/packages/android-client/expo-plugin/src/android/clientRendered.ts
new file mode 100644
index 00000000..23c78e67
--- /dev/null
+++ b/packages/android-client/expo-plugin/src/android/clientRendered.ts
@@ -0,0 +1,107 @@
+import * as fs from 'fs'
+import * as path from 'path'
+
+import { isWidgetLocalizedMap, type WidgetInitialStatePath } from '@use-voltra/expo-plugin'
+import { scanVoltraDirectives } from '@use-voltra/compiler'
+
+import type { AndroidWidgetConfig } from '../types'
+
+/**
+ * Client-rendered widget detection for Android — the counterpart of the iOS plugin's
+ * clientRendered.ts.
+ *
+ * A widget is client-rendered when the file referenced by `initialStatePath` contains a
+ * `'use voltra'` directive inside an exported function whose name equals the widget `id`. Such
+ * widgets download a JS bundle and render on-device (Hermes) instead of consuming server JSON.
+ *
+ * The widget `id` must equal the exported function name (the id becomes both the Metro bundle
+ * URL suffix and the widget's identity), so a mismatch fails loudly at prebuild.
+ */
+
+export type DetectedAndroidWidget =
+  | (AndroidWidgetConfig & { clientRendered: false })
+  | (AndroidWidgetConfig & {
+      clientRendered: true
+      clientComponentName: string
+      clientSourcePath: string
+    })
+
+// Emit the experimental notice at most once per prebuild process (detection runs from several
+// plugin steps).
+let hasWarnedExperimental = false
+
+export function detectClientRenderedWidgets(
+  widgets: AndroidWidgetConfig[],
+  projectRoot: string
+): DetectedAndroidWidget[] {
+  const detected = widgets.map((widget) => detectSingleWidget(widget, projectRoot))
+
+  if (!hasWarnedExperimental) {
+    const clientWidgetIds = detected.filter((widget) => widget.clientRendered).map((widget) => widget.id)
+    if (clientWidgetIds.length > 0) {
+      hasWarnedExperimental = true
+      console.warn(
+        `[voltra] Client-rendered widgets are EXPERIMENTAL (${clientWidgetIds.join(', ')}). ` +
+          'The widget JSX runs on-device in a separate JS engine; the API and build output may change, ' +
+          'and production rendering should be verified on a real device. Use at your own risk.'
+      )
+    }
+  }
+
+  return detected
+}
+
+function detectSingleWidget(widget: AndroidWidgetConfig, projectRoot: string): DetectedAndroidWidget {
+  if (!widget.initialStatePath) {
+    return { ...widget, clientRendered: false }
+  }
+
+  const sourcePath = resolveAnyInitialStatePath(widget.initialStatePath, projectRoot)
+  if (!sourcePath || !fs.existsSync(sourcePath)) {
+    return { ...widget, clientRendered: false }
+  }
+
+  const source = fs.readFileSync(sourcePath, 'utf8')
+
+  // Cheap pre-check before paying for a Babel parse — same shortcut the Metro scanner uses.
+  if (!source.includes("'use voltra'") && !source.includes('"use voltra"')) {
+    return { ...widget, clientRendered: false }
+  }
+
+  const directiveWidgets = scanVoltraDirectives({ filePath: sourcePath, source })
+  if (directiveWidgets.length === 0) {
+    return { ...widget, clientRendered: false }
+  }
+
+  const directiveWidget = directiveWidgets.find((candidate) => candidate.id === widget.id)
+  if (!directiveWidget) {
+    const componentName = directiveWidgets[0].componentName
+    throw new Error(
+      `[voltra] Widget id mismatch: widget "${widget.id}" in app.json has initialStatePath ` +
+        `pointing at ${path.relative(projectRoot, sourcePath)} but that file's 'use voltra' ` +
+        `directive belongs to component "${componentName}". For client-rendered widgets the ` +
+        `app.json id and the component name must match exactly (the id becomes the Metro bundle ` +
+        `URL suffix).`
+    )
+  }
+
+  return {
+    ...widget,
+    clientRendered: true,
+    clientComponentName: directiveWidget.componentName,
+    clientSourcePath: sourcePath,
+  }
+}
+
+function resolveAnyInitialStatePath(spec: WidgetInitialStatePath, projectRoot: string): string | null {
+  if (typeof spec === 'string') {
+    return path.resolve(projectRoot, spec)
+  }
+  if (isWidgetLocalizedMap(spec)) {
+    const firstPath = Object.values(spec).find(
+      (value): value is string => typeof value === 'string' && value.length > 0
+    )
+    return firstPath ? path.resolve(projectRoot, firstPath) : null
+  }
+  return null
+}
diff --git a/packages/android-client/expo-plugin/src/android/files/clientRenderedPrerender.ts b/packages/android-client/expo-plugin/src/android/files/clientRenderedPrerender.ts
new file mode 100644
index 00000000..79668576
--- /dev/null
+++ b/packages/android-client/expo-plugin/src/android/files/clientRenderedPrerender.ts
@@ -0,0 +1,81 @@
+import { evaluateWidgetModule, logger, type PrerenderedWidgetStates } from '@use-voltra/expo-plugin'
+
+import type { DetectedAndroidWidget } from '../clientRendered'
+
+/**
+ * Placeholder prerender for client-rendered Android widgets — the counterpart of the iOS
+ * plugin's clientRenderedPrerender.ts.
+ *
+ * Server-rendered widgets prerender from `exports.default` (a variants object). Client widgets
+ * instead export a `(props, env) => JSX` function, so there is no default state to prerender.
+ * To still show something before the first Metro fetch (and when offline), we call that function
+ * once at prebuild with empty props + a minimal env, render the single node via
+ * `renderAndroidVariantToJson`, and store it in the same `voltra_initial_states.json` the runtime
+ * already reads. `VoltraClientGlanceWidget` decodes that node for its fallback.
+ */
+
+const SINGLE_LOCALE_KEY = '__default'
+
+function buildPlaceholderEnv(): Record<string, unknown> {
+  return {
+    date: Date.now(),
+    widgetFamily: '200x200',
+    colorScheme: 'light',
+    locale: 'en-US',
+    configuration: undefined,
+    build: {
+      isDev: false,
+      metroUrl: null,
+      appVersion: 'unknown',
+      voltraVersion: '1.4.1',
+    },
+  }
+}
+
+export async function prerenderClientRenderedAndroidWidgets(
+  widgets: DetectedAndroidWidget[],
+  projectRoot: string
+): Promise<PrerenderedWidgetStates> {
+  const results: PrerenderedWidgetStates = new Map()
+
+  const clientWidgets = widgets.filter(
+    (w): w is Extract<DetectedAndroidWidget, { clientRendered: true }> => w.clientRendered
+  )
+  if (clientWidgets.length === 0) {
+    return results
+  }
+
+  // Dynamic import keeps the plugin CommonJS-compatible and resolves the current package entry.
+  const androidModuleId = '@use-voltra/android'
+  const { renderAndroidVariantToJson } = (await import(androidModuleId)) as {
+    renderAndroidVariantToJson: (element: unknown) => unknown
+  }
+
+  const placeholderEnv = buildPlaceholderEnv()
+
+  for (const widget of clientWidgets) {
+    try {
+      const exports = evaluateWidgetModule(projectRoot, widget.clientSourcePath)
+      const widgetFn = exports[widget.clientComponentName]
+      if (typeof widgetFn !== 'function') {
+        throw new Error(
+          `Expected the file to export a function named "${widget.clientComponentName}" ` +
+            `(the widget id from app.json). Found: ${Object.keys(exports).join(', ') || '(no named exports)'}`
+        )
+      }
+
+      const element = widgetFn({}, placeholderEnv)
+      const json = renderAndroidVariantToJson(element)
+      results.set(widget.id, new Map([[SINGLE_LOCALE_KEY, JSON.stringify(json)]]))
+    } catch (error) {
+      throw new Error(
+        `Failed to prerender client-rendered widget "${widget.id}": ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      )
+    }
+  }
+
+  logger.info(`Prerendered ${clientWidgets.length} client-rendered Android widget placeholder(s)`)
+  return results
+}
diff --git a/packages/android-client/expo-plugin/src/android/files/configDefaults.node.test.ts b/packages/android-client/expo-plugin/src/android/files/configDefaults.node.test.ts
new file mode 100644
index 00000000..2a2b4f74
--- /dev/null
+++ b/packages/android-client/expo-plugin/src/android/files/configDefaults.node.test.ts
@@ -0,0 +1,70 @@
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+
+import type { AndroidWidgetConfig } from '../../types'
+import { generateAndroidConfigDefaults } from './configDefaults'
+
+function makeTempProjectRoot(): { platformProjectRoot: string; cleanup: () => void } {
+  const platformProjectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'voltra-android-config-defaults-'))
+  return {
+    platformProjectRoot,
+    cleanup: () => fs.rmSync(platformProjectRoot, { recursive: true, force: true }),
+  }
+}
+
+function widget(partial: Partial<AndroidWidgetConfig>): AndroidWidgetConfig {
+  return {
+    id: 'W',
+    displayName: 'W',
+    description: 'W',
+    targetCellWidth: 2,
+    targetCellHeight: 2,
+    ...partial,
+  }
+}
+
+const DEFAULTS_PATH = ['app', 'src', 'main', 'assets', 'voltra', 'widget_config_defaults.json']
+
+describe('generateAndroidConfigDefaults', () => {
+  it('emits the declared defaults keyed by widget id', async () => {
+    const { platformProjectRoot, cleanup } = makeTempProjectRoot()
+    try {
+      await generateAndroidConfigDefaults({
+        platformProjectRoot,
+        widgets: [
+          widget({
+            id: 'AndroidClientDemoWidget',
+            appIntent: { parameters: [{ name: 'label', title: 'Label', default: 'Hello' }] },
+          }),
+        ],
+      })
+
+      const file = path.join(platformProjectRoot, ...DEFAULTS_PATH)
+      expect(fs.existsSync(file)).toBe(true)
+      expect(JSON.parse(fs.readFileSync(file, 'utf8'))).toEqual({
+        AndroidClientDemoWidget: { label: 'Hello' },
+      })
+    } finally {
+      cleanup()
+    }
+  })
+
+  it('omits parameters without a default, and writes nothing when no widget declares defaults', async () => {
+    const { platformProjectRoot, cleanup } = makeTempProjectRoot()
+    try {
+      await generateAndroidConfigDefaults({
+        platformProjectRoot,
+        widgets: [
+          widget({ id: 'NoConfig' }),
+          widget({ id: 'NoDefault', appIntent: { parameters: [{ name: 'city', title: 'City' }] } }),
+        ],
+      })
+
+      const file = path.join(platformProjectRoot, ...DEFAULTS_PATH)
+      expect(fs.existsSync(file)).toBe(false)
+    } finally {
+      cleanup()
+    }
+  })
+})
diff --git a/packages/android-client/expo-plugin/src/android/files/configDefaults.ts b/packages/android-client/expo-plugin/src/android/files/configDefaults.ts
new file mode 100644
index 00000000..8b05e173
--- /dev/null
+++ b/packages/android-client/expo-plugin/src/android/files/configDefaults.ts
@@ -0,0 +1,48 @@
+import fs from 'fs'
+import path from 'path'
+
+import { logger } from '@use-voltra/expo-plugin'
+
+import type { AndroidWidgetConfig } from '../../types'
+
+export interface GenerateConfigDefaultsOptions {
+  widgets: AndroidWidgetConfig[]
+  platformProjectRoot: string
+}
+
+/**
+ * Emits the code-declared widget configuration defaults to
+ * `assets/voltra/widget_config_defaults.json`, read at render time by VoltraConfigurationStore and
+ * surfaced as `env.configuration` before the user configures anything (the Android equivalent of
+ * iOS's `@Parameter(default:)`).
+ *
+ * Shape: `{ "<widgetId>": { "<paramName>": "<default>" } }`. Only parameters that declare a
+ * `default` are emitted. No file is written when nothing declares defaults.
+ */
+export async function generateAndroidConfigDefaults(options: GenerateConfigDefaultsOptions): Promise<void> {
+  const { widgets, platformProjectRoot } = options
+
+  const defaults: Record<string, Record<string, string>> = {}
+  for (const widget of widgets) {
+    const params = widget.appIntent?.parameters ?? []
+    const widgetDefaults: Record<string, string> = {}
+    for (const param of params) {
+      if (typeof param.default === 'string') {
+        widgetDefaults[param.name] = param.default
+      }
+    }
+    if (Object.keys(widgetDefaults).length > 0) {
+      defaults[widget.id] = widgetDefaults
+    }
+  }
+
+  if (Object.keys(defaults).length === 0) {
+    return
+  }
+
+  const voltraAssetsDir = path.join(platformProjectRoot, 'app', 'src', 'main', 'assets', 'voltra')
+  fs.mkdirSync(voltraAssetsDir, { recursive: true })
+  fs.writeFileSync(path.join(voltraAssetsDir, 'widget_config_defaults.json'), JSON.stringify(defaults, null, 2))
+
+  logger.info(`Generated widget_config_defaults.json for ${Object.keys(defaults).length} widget(s)`)
+}
diff --git a/packages/android-client/expo-plugin/src/android/files/index.ts b/packages/android-client/expo-plugin/src/android/files/index.ts
index b0212c9b..32448a66 100644
--- a/packages/android-client/expo-plugin/src/android/files/index.ts
+++ b/packages/android-client/expo-plugin/src/android/files/index.ts
@@ -1,7 +1,9 @@
 import { ConfigPlugin, withDangerousMod } from '@expo/config-plugins'
 
 import type { AndroidWidgetConfig } from '../../types'
+import { detectClientRenderedWidgets } from '../clientRendered'
 import { generateAndroidAssets } from './assets'
+import { generateAndroidConfigDefaults } from './configDefaults'
 import { copyAndroidFonts } from './fonts'
 import { generateAndroidInitialStates } from './initialStates'
 import { generateWidgetReceivers } from './kotlin'
@@ -44,6 +46,10 @@ export const generateAndroidWidgetFiles: ConfigPlugin<GenerateAndroidWidgetFiles
         )
       }
 
+      // Tag each widget server- vs client-rendered once; receivers and initial-state prerender
+      // both branch on it. Other generators ignore the extra fields.
+      const detectedWidgets = detectClientRenderedWidgets(widgets, projectRoot)
+
       // Generate assets (drawable images and preview images)
       const previewImageMap = await generateAndroidAssets({
         platformProjectRoot,
@@ -56,7 +62,7 @@ export const generateAndroidWidgetFiles: ConfigPlugin<GenerateAndroidWidgetFiles
       await generateWidgetReceivers({
         platformProjectRoot,
         packageName,
-        widgets,
+        widgets: detectedWidgets,
       })
 
       // Generate XML files (widget info, layouts, strings)
@@ -89,6 +95,12 @@ export const generateAndroidWidgetFiles: ConfigPlugin<GenerateAndroidWidgetFiles
       await generateAndroidInitialStates({
         platformProjectRoot,
         projectRoot: config.modRequest.projectRoot,
+        widgets: detectedWidgets,
+      })
+
+      // Emit code-declared client widget configuration defaults (env.configuration).
+      await generateAndroidConfigDefaults({
+        platformProjectRoot,
         widgets,
       })
 
diff --git a/packages/android-client/expo-plugin/src/android/files/initialStates.ts b/packages/android-client/expo-plugin/src/android/files/initialStates.ts
index b8ecc551..553f922e 100644
--- a/packages/android-client/expo-plugin/src/android/files/initialStates.ts
+++ b/packages/android-client/expo-plugin/src/android/files/initialStates.ts
@@ -1,14 +1,16 @@
 import fs from 'fs'
 import path from 'path'
 
-import type { AndroidWidgetConfig } from '../../types'
 import { logger, prerenderWidgetState, type PrerenderedWidgetStates } from '@use-voltra/expo-plugin'
 
+import type { DetectedAndroidWidget } from '../clientRendered'
+import { prerenderClientRenderedAndroidWidgets } from './clientRenderedPrerender'
+
 /** Wrapped asset shape when multiple locales are built; matches Android reader in VoltraWidgetManager */
 export const VOLTRA_LOCALIZED_INITIAL_STATE_KEY = '__voltraLocales'
 
 export interface GenerateInitialStatesOptions {
-  widgets: AndroidWidgetConfig[]
+  widgets: DetectedAndroidWidget[]
   projectRoot: string
   platformProjectRoot: string
 }
@@ -30,13 +32,22 @@ export async function generateAndroidInitialStates(options: GenerateInitialState
     renderAndroidWidgetToString: RenderAndroidWidgetToString
   }
 
-  // Prerender widget states (per locale when `initialStatePath` is a locale map)
+  // Server-rendered widgets prerender from `exports.default`. Client-rendered widgets have no
+  // default export (just a `(props, env) => JSX` function), so they're excluded here and
+  // prerendered separately below — feeding a client file to the server prerender would throw.
+  const serverWidgets = widgets.filter((w) => !w.clientRendered)
   const prerenderedStates: PrerenderedWidgetStates = await prerenderWidgetState(
-    widgets,
+    serverWidgets,
     projectRoot,
     renderAndroidWidgetToString
   )
 
+  // Single-node placeholders for client-rendered widgets (first paint / offline fallback).
+  const clientStates = await prerenderClientRenderedAndroidWidgets(widgets, projectRoot)
+  for (const [id, perLocale] of clientStates.entries()) {
+    prerenderedStates.set(id, perLocale)
+  }
+
   if (prerenderedStates.size === 0) {
     return
   }
diff --git a/packages/android-client/expo-plugin/src/android/files/kotlin.ts b/packages/android-client/expo-plugin/src/android/files/kotlin.ts
index bff40b0a..2e07a4fb 100644
--- a/packages/android-client/expo-plugin/src/android/files/kotlin.ts
+++ b/packages/android-client/expo-plugin/src/android/files/kotlin.ts
@@ -2,13 +2,14 @@ import dedent from 'dedent'
 import * as fs from 'fs'
 import * as path from 'path'
 
-import type { AndroidWidgetConfig } from '../../types'
 import { widgetLabelEnglish } from '@use-voltra/expo-plugin'
 
+import type { DetectedAndroidWidget } from '../clientRendered'
+
 export interface GenerateKotlinFilesProps {
   platformProjectRoot: string
   packageName: string
-  widgets: AndroidWidgetConfig[]
+  widgets: DetectedAndroidWidget[]
 }
 
 // ============================================================================
@@ -48,10 +49,28 @@ export async function generateWidgetReceivers(props: GenerateKotlinFilesProps):
  * Generates Kotlin code for a single widget receiver class.
  * If the widget has serverUpdate configured, includes WorkManager scheduling.
  */
-function generateWidgetReceiverClass(widget: AndroidWidgetConfig, packageName: string): string {
+function generateWidgetReceiverClass(widget: DetectedAndroidWidget, packageName: string): string {
   const className = `VoltraWidget_${widget.id}Receiver`
   const labelForComment = widgetLabelEnglish(widget.displayName)
 
+  // Client-rendered widgets host VoltraClientGlanceWidget (on-device JS render) and have no
+  // server payload, so they never schedule WorkManager server updates.
+  if (widget.clientRendered) {
+    return dedent`
+      package ${packageName}.widget
+
+      import voltra.widget.VoltraClientWidgetReceiver
+
+      /**
+       * Auto-generated client-rendered widget receiver for ${labelForComment}
+       * Widget ID: ${widget.id}
+       */
+      class ${className} : VoltraClientWidgetReceiver() {
+          override val widgetId: String = "${widget.id}"
+      }
+    `
+  }
+
   if (widget.serverUpdate) {
     const refreshEnabled = widget.serverUpdate.refresh === true
     // Widget with server-driven updates: schedule WorkManager periodic task
diff --git a/packages/android-client/expo-plugin/src/android/files/xml.ts b/packages/android-client/expo-plugin/src/android/files/xml.ts
index 54cafa00..bd67a558 100644
--- a/packages/android-client/expo-plugin/src/android/files/xml.ts
+++ b/packages/android-client/expo-plugin/src/android/files/xml.ts
@@ -5,6 +5,7 @@ import * as path from 'path'
 import { isWidgetLocalizedMap, logger, widgetLabelEnglish } from '@use-voltra/expo-plugin'
 
 import type { AndroidWidgetConfig } from '../../types'
+import { androidWidgetResourceId } from '../resourceName'
 
 export interface GenerateXmlFilesProps {
   platformProjectRoot: string
@@ -95,7 +96,7 @@ export async function generateWidgetPreviewLayouts(props: GenerateXmlFilesProps)
 
   // Write widget info XML for all widgets, including preview references where available
   for (const widget of widgets) {
-    const widgetInfoPath = path.join(xmlPath, `voltra_widget_${widget.id}_info.xml`)
+    const widgetInfoPath = path.join(xmlPath, `voltra_widget_${androidWidgetResourceId(widget.id)}_info.xml`)
     const previewImageResourceName = previewImageMap.get(widget.id)
     const previewLayoutResourceName = previewLayoutMap.get(widget.id)
     const widgetInfoContent = generateWidgetInfoXml(widget, previewImageResourceName, previewLayoutResourceName)
@@ -147,7 +148,9 @@ function generateWidgetInfoXml(
         android:initialLayout="@layout/voltra_widget_placeholder"
         android:resizeMode="${resizeMode}"
         android:widgetCategory="${widgetCategory}"
-        android:description="@string/voltra_widget_${widget.id}_description"${previewImageAttr}${previewLayoutAttr}>
+        android:description="@string/voltra_widget_${androidWidgetResourceId(
+          widget.id
+        )}_description"${previewImageAttr}${previewLayoutAttr}>
     </appwidget-provider>
   `
 }
@@ -284,7 +287,8 @@ function generateVoltraWidgetsStringResourcesXml(widgets: AndroidWidgetConfig[],
     .map((widget) => {
       const label = escapeAndroidStringRes(resolveAndroidWidgetLabel(widget, 'displayName', localeKey))
       const desc = escapeAndroidStringRes(resolveAndroidWidgetLabel(widget, 'description', localeKey))
-      return `<string name="voltra_widget_${widget.id}_label">${label}</string>\n    <string name="voltra_widget_${widget.id}_description">${desc}</string>`
+      const resId = androidWidgetResourceId(widget.id)
+      return `<string name="voltra_widget_${resId}_label">${label}</string>\n    <string name="voltra_widget_${resId}_description">${desc}</string>`
     })
     .join('\n    ')
 
@@ -376,7 +380,7 @@ function generateAutoImagePreviewLayout(widgetId: string, drawableResourceName:
             android:layout_height="match_parent"
             android:src="@drawable/${drawableResourceName}"
             android:scaleType="centerCrop"
-            android:contentDescription="@string/voltra_widget_${widgetId}_description" />
+            android:contentDescription="@string/voltra_widget_${androidWidgetResourceId(widgetId)}_description" />
     </FrameLayout>
   `
 }
@@ -405,7 +409,7 @@ async function generatePreviewLayouts(
 
   for (const widget of widgets) {
     let layoutContent: string | null = null
-    const layoutResourceName = `voltra_widget_${widget.id}_preview`
+    const layoutResourceName = `voltra_widget_${androidWidgetResourceId(widget.id)}_preview`
     const layoutFilePath = path.join(layoutPath, `${layoutResourceName}.xml`)
 
     // Strategy 1: User provided custom preview layout
diff --git a/packages/android-client/expo-plugin/src/android/gradle.node.test.ts b/packages/android-client/expo-plugin/src/android/gradle.node.test.ts
new file mode 100644
index 00000000..cdf3e2b8
--- /dev/null
+++ b/packages/android-client/expo-plugin/src/android/gradle.node.test.ts
@@ -0,0 +1,32 @@
+import { __test__ } from './gradle'
+
+const { MARKER, addWidgetBundleGradle } = __test__
+
+const BASE_GRADLE = `apply plugin: "com.android.application"
+
+android {
+    namespace "com.example.app"
+}
+`
+
+describe('addWidgetBundleGradle', () => {
+  it('appends the release widget-bundling wiring', () => {
+    const result = addWidgetBundleGradle(BASE_GRADLE)
+    expect(result).toContain(MARKER)
+    expect(result).toContain('tasks.register("voltraBundleWidgets", Exec)')
+    expect(result).toContain("resolve('@use-voltra/metro/bundle-widgets')")
+    expect(result).toContain('--platform android')
+    // release-gated + wired into the asset merge
+    expect(result).toContain('variant.buildType.name == "release"')
+    expect(result).toContain('merge${variant.name.capitalize()}Assets')
+    // original contents preserved
+    expect(result).toContain('apply plugin: "com.android.application"')
+  })
+
+  it('is idempotent — a second pass does not duplicate the snippet', () => {
+    const once = addWidgetBundleGradle(BASE_GRADLE)
+    const twice = addWidgetBundleGradle(once)
+    expect(twice).toBe(once)
+    expect(twice.match(new RegExp(MARKER.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&'), 'g'))).toHaveLength(1)
+  })
+})
diff --git a/packages/android-client/expo-plugin/src/android/gradle.ts b/packages/android-client/expo-plugin/src/android/gradle.ts
new file mode 100644
index 00000000..48b6d4ab
--- /dev/null
+++ b/packages/android-client/expo-plugin/src/android/gradle.ts
@@ -0,0 +1,71 @@
+import { ConfigPlugin, withAppBuildGradle } from '@expo/config-plugins'
+
+import { logger } from '@use-voltra/expo-plugin'
+
+import type { AndroidWidgetConfig } from '../types'
+import { detectClientRenderedWidgets } from './clientRendered'
+
+const MARKER = '// @voltra-widget-bundling'
+
+// Release-only Gradle wiring that bakes each client-rendered widget's production JS bundle into the
+// app's assets — the Android analog of iOS's release "Bundle Voltra client widgets" build phase.
+// Debug keeps fetching from Metro (and hot-reloading); only release variants depend on the task,
+// and the generated dir is empty otherwise. Re-bakes every build (it can't enumerate widget-source
+// inputs). The bundle lands at assets/voltra/voltra-widget-<id>.bundle, which the runtime's release
+// loader reads from Bundle assets.
+const GRADLE_SNIPPET = `
+${MARKER} — generated by @use-voltra/android-client; do not edit
+def voltraProjectRoot = file("\${rootDir}/..")
+def voltraWidgetAssetsDir = file("\${buildDir}/generated/voltra/assets")
+android.sourceSets.getByName("main").assets.srcDir(voltraWidgetAssetsDir)
+
+def voltraBundleWidgets = tasks.register("voltraBundleWidgets", Exec) {
+    description = "Bake client-rendered Voltra widget bundles into assets (release)."
+    workingDir voltraProjectRoot
+    environment "VOLTRA_PROJECT_ROOT", voltraProjectRoot.absolutePath
+    environment "VOLTRA_OUT_DIR", new File(voltraWidgetAssetsDir, "voltra").absolutePath
+    environment "VOLTRA_BUNDLER_RESOLVER", "const m=require('module'),p=require('path');process.stdout.write(m.createRequire(p.join(process.argv[1],'package.json')).resolve('@use-voltra/metro/bundle-widgets'))"
+    commandLine "bash", "-c", 'BUNDLER="$(node -e "$VOLTRA_BUNDLER_RESOLVER" "$VOLTRA_PROJECT_ROOT")"; if [ -z "$BUNDLER" ]; then echo "error: Voltra could not resolve @use-voltra/metro/bundle-widgets from $VOLTRA_PROJECT_ROOT — install @use-voltra/metro so release widgets can be baked." >&2; exit 1; fi; node "$BUNDLER" --platform android --out-dir "$VOLTRA_OUT_DIR" --project-root "$VOLTRA_PROJECT_ROOT"'
+    outputs.upToDateWhen { false }
+}
+
+android.applicationVariants.all { variant ->
+    if (variant.buildType.name == "release") {
+        tasks.named("merge\${variant.name.capitalize()}Assets").configure { dependsOn voltraBundleWidgets }
+    }
+}
+`
+
+/**
+ * Appends the release widget-bundling Gradle wiring to `app/build.gradle`, idempotently, and only
+ * when at least one widget is client-rendered (server-rendered apps need no JS bundle baked).
+ */
+export const withWidgetBundleGradle: ConfigPlugin<{ widgets: AndroidWidgetConfig[] }> = (config, { widgets }) => {
+  return withAppBuildGradle(config, (cfg) => {
+    const hasClientRenderedWidgets = detectClientRenderedWidgets(widgets, cfg.modRequest.projectRoot).some(
+      (widget) => widget.clientRendered
+    )
+    if (!hasClientRenderedWidgets) {
+      return cfg
+    }
+
+    if (cfg.modResults.language !== 'groovy') {
+      logger.warn('Voltra: app/build.gradle is not Groovy — skipping client widget release bundling wiring.')
+      return cfg
+    }
+
+    cfg.modResults.contents = addWidgetBundleGradle(cfg.modResults.contents)
+    return cfg
+  })
+}
+
+/** Append the widget-bundling snippet to build.gradle contents, idempotently (returns unchanged
+ *  contents if already present). */
+export function addWidgetBundleGradle(contents: string): string {
+  if (contents.includes(MARKER)) {
+    return contents
+  }
+  return `${contents.trimEnd()}\n${GRADLE_SNIPPET}\n`
+}
+
+export const __test__ = { MARKER, addWidgetBundleGradle }
diff --git a/packages/android-client/expo-plugin/src/android/index.ts b/packages/android-client/expo-plugin/src/android/index.ts
index 311f6d79..6be478f6 100644
--- a/packages/android-client/expo-plugin/src/android/index.ts
+++ b/packages/android-client/expo-plugin/src/android/index.ts
@@ -3,6 +3,7 @@ import { ConfigPlugin, withPlugins } from '@expo/config-plugins'
 import type { AndroidPluginProps } from '../types'
 import { validateAndroidWidgetConfig } from '../validation'
 import { generateAndroidWidgetFiles } from './files'
+import { withWidgetBundleGradle } from './gradle'
 import { configureAndroidManifest } from './manifest'
 
 /**
@@ -24,5 +25,6 @@ export const withAndroid: ConfigPlugin<AndroidPluginProps> = (config, props) =>
   return withPlugins(config, [
     [generateAndroidWidgetFiles, { widgets, userImagesPath, fonts }],
     [configureAndroidManifest, { enableNotifications, widgets }],
+    [withWidgetBundleGradle, { widgets }],
   ])
 }
diff --git a/packages/android-client/expo-plugin/src/android/manifest.ts b/packages/android-client/expo-plugin/src/android/manifest.ts
index 51c97002..4f45b15c 100644
--- a/packages/android-client/expo-plugin/src/android/manifest.ts
+++ b/packages/android-client/expo-plugin/src/android/manifest.ts
@@ -2,6 +2,7 @@ import { ConfigPlugin, withAndroidManifest } from '@expo/config-plugins'
 import { AndroidConfig } from 'expo/config-plugins'
 
 import type { AndroidWidgetConfig } from '../types'
+import { androidWidgetResourceId } from './resourceName'
 
 export interface ConfigureAndroidManifestProps {
   enableNotifications?: boolean
@@ -63,6 +64,7 @@ export const configureAndroidManifest: ConfigPlugin<ConfigureAndroidManifestProp
     // Add a receiver for each widget
     for (const widget of widgets) {
       const receiverClassName = `.widget.VoltraWidget_${widget.id}Receiver`
+      const resId = androidWidgetResourceId(widget.id)
 
       // Check if receiver already exists
       const alreadyExists = existingReceivers.some(
@@ -75,7 +77,7 @@ export const configureAndroidManifest: ConfigPlugin<ConfigureAndroidManifestProp
           $: {
             'android:name': receiverClassName,
             'android:exported': 'true' as const,
-            'android:label': `@string/voltra_widget_${widget.id}_label`,
+            'android:label': `@string/voltra_widget_${resId}_label`,
           },
           'intent-filter': [
             {
@@ -92,7 +94,7 @@ export const configureAndroidManifest: ConfigPlugin<ConfigureAndroidManifestProp
             {
               $: {
                 'android:name': 'android.appwidget.provider',
-                'android:resource': `@xml/voltra_widget_${widget.id}_info`,
+                'android:resource': `@xml/voltra_widget_${resId}_info`,
               },
             },
           ],
diff --git a/packages/android-client/expo-plugin/src/android/resourceName.ts b/packages/android-client/expo-plugin/src/android/resourceName.ts
new file mode 100644
index 00000000..07b07f2e
--- /dev/null
+++ b/packages/android-client/expo-plugin/src/android/resourceName.ts
@@ -0,0 +1,11 @@
+/**
+ * Android resource names (XML filenames, string names, etc.) must contain only lowercase a-z,
+ * 0-9, or underscore. Widget ids may be PascalCase — client-rendered widgets use their component
+ * name as the id (it is also the Metro bundle URL key and the receiver class-name segment), which
+ * is invalid as a resource name. Derive a valid resource-name segment from the id.
+ *
+ * Idempotent for already-valid (lowercase/underscore) ids, so server widgets are unaffected.
+ */
+export function androidWidgetResourceId(id: string): string {
+  return id.toLowerCase().replace(/[^a-z0-9_]/g, '_')
+}
diff --git a/packages/android-client/expo-plugin/src/types.ts b/packages/android-client/expo-plugin/src/types.ts
index e173f0b0..d29df66b 100644
--- a/packages/android-client/expo-plugin/src/types.ts
+++ b/packages/android-client/expo-plugin/src/types.ts
@@ -2,6 +2,22 @@ import type { ConfigPlugin } from '@expo/config-plugins'
 
 import type { WidgetInitialStatePath, WidgetLabel } from '@use-voltra/expo-plugin'
 
+/**
+ * A single user-configurable parameter for a client-rendered widget. Android has no system-managed
+ * widget configuration UI (unlike iOS's WidgetConfigurationIntent), so the value is set at runtime
+ * via `setWidgetConfiguration`; `default` is the code-declared value shown before any runtime edit.
+ * The same `appIntent` key is used as on iOS for a single cross-platform `app.json` schema.
+ */
+export interface AppIntentParameter {
+  name: string
+  title?: string
+  default?: string
+}
+
+export interface AndroidWidgetAppIntentConfig {
+  parameters: AppIntentParameter[]
+}
+
 /**
  * Configuration for a single Android home screen widget.
  */
@@ -21,6 +37,12 @@ export interface AndroidWidgetConfig {
   serverUpdate?: AndroidWidgetServerUpdateConfig
   previewImage?: string
   previewLayout?: string
+  /**
+   * Code-declared configuration parameters surfaced to a client-rendered widget as
+   * `env.configuration`. `parameters[].default` is emitted to the app's assets so the widget shows
+   * it before any runtime configuration; runtime values (set via `setWidgetConfiguration`) override.
+   */
+  appIntent?: AndroidWidgetAppIntentConfig
 }
 
 /**
diff --git a/packages/android-client/expo-plugin/tsconfig.typecheck.json b/packages/android-client/expo-plugin/tsconfig.typecheck.json
index 58e6f899..0b484180 100644
--- a/packages/android-client/expo-plugin/tsconfig.typecheck.json
+++ b/packages/android-client/expo-plugin/tsconfig.typecheck.json
@@ -5,6 +5,7 @@
     "rootDir": "../../..",
     "baseUrl": "../../..",
     "paths": {
+      "@use-voltra/compiler": ["packages/compiler/src/index.ts"],
       "@use-voltra/expo-plugin": ["packages/expo-plugin/src/index.ts"]
     }
   },
diff --git a/packages/android-client/package.json b/packages/android-client/package.json
index c0cb4095..93d3f5ff 100644
--- a/packages/android-client/package.json
+++ b/packages/android-client/package.json
@@ -48,6 +48,7 @@
     "@babel/core": "^7.27.4",
     "@expo/config-plugins": "~10.1.2",
     "@use-voltra/android": "workspace:^",
+    "@use-voltra/compiler": "workspace:^",
     "@use-voltra/expo-plugin": "workspace:^",
     "dedent": "^1.7.1",
     "vd-tool": "^4.0.2"
diff --git a/packages/android-client/src/index.ts b/packages/android-client/src/index.ts
index efa2cd96..9f9ef0e0 100644
--- a/packages/android-client/src/index.ts
+++ b/packages/android-client/src/index.ts
@@ -50,6 +50,7 @@ export {
   getActiveWidgets,
   reloadAndroidWidgets,
   requestPinAndroidWidget,
+  setWidgetConfiguration,
   updateAndroidWidget,
 } from './widgets/api.js'
 export type {
@@ -72,3 +73,4 @@ export {
   VoltraWidgetPreview,
   type VoltraWidgetPreviewProps,
 } from './components/VoltraWidgetPreview.js'
+export { enableWidgetHotReload } from './utils/enableWidgetHotReload.js'
diff --git a/packages/android-client/src/native/NativeVoltraAndroid.ts b/packages/android-client/src/native/NativeVoltraAndroid.ts
index 272cf439..118a3d6d 100644
--- a/packages/android-client/src/native/NativeVoltraAndroid.ts
+++ b/packages/android-client/src/native/NativeVoltraAndroid.ts
@@ -93,6 +93,7 @@ export interface Spec extends TurboModule {
   openAndroidNotificationSettings(): Promise<void>
   updateAndroidWidget(widgetId: string, jsonString: string, options?: Readonly<{ deepLinkUrl?: string }>): Promise<void>
   reloadAndroidWidgets(widgetIds?: string[] | null): Promise<void>
+  setWidgetConfiguration(widgetId: string, key: string, value: string): Promise<void>
   clearAndroidWidget(widgetId: string): Promise<void>
   clearAllAndroidWidgets(): Promise<void>
   requestPinGlanceAppWidget(widgetId: string, options?: RequestPinGlanceAppWidgetOptionsSpec): Promise<boolean>
diff --git a/packages/android-client/src/utils/enableWidgetHotReload.ts b/packages/android-client/src/utils/enableWidgetHotReload.ts
new file mode 100644
index 00000000..980d9bbd
--- /dev/null
+++ b/packages/android-client/src/utils/enableWidgetHotReload.ts
@@ -0,0 +1,32 @@
+import { reloadAndroidWidgets } from '../widgets/api.js'
+
+declare global {
+  var __accept: (...args: unknown[]) => void
+}
+
+/**
+ * Trigger a widget reload on every Metro Fast Refresh patch (DEV only).
+ *
+ * Hooks the global `__accept` callback Metro fires when a Fast Refresh patch lands in the host
+ * app's JS runtime. When fired, reloads all widgets — for client-rendered widgets this re-runs
+ * `provideGlance`, which re-fetches the freshest bundle from Metro and re-renders. Counterpart of
+ * iOS's `enableWidgetHotReload`.
+ *
+ * Effective while the host app's JS thread is alive (foreground). Call once at app startup.
+ * Returns `dispose()` to restore the prior `__accept`. No-op in release builds.
+ */
+export function enableWidgetHotReload(): () => void {
+  if (!__DEV__) {
+    return () => {}
+  }
+
+  const oldAccept = global['__accept']
+  global['__accept'] = (...args) => {
+    void reloadAndroidWidgets()
+    oldAccept?.(...args)
+  }
+
+  return () => {
+    global['__accept'] = oldAccept
+  }
+}
diff --git a/packages/android-client/src/utils/index.ts b/packages/android-client/src/utils/index.ts
index 49f45673..25cfc113 100644
--- a/packages/android-client/src/utils/index.ts
+++ b/packages/android-client/src/utils/index.ts
@@ -1 +1,2 @@
+export * from './enableWidgetHotReload.js'
 export * from './useUpdateOnHMR.js'
diff --git a/packages/android-client/src/widgets/api.ts b/packages/android-client/src/widgets/api.ts
index 8ce67d34..7eabc58a 100644
--- a/packages/android-client/src/widgets/api.ts
+++ b/packages/android-client/src/widgets/api.ts
@@ -49,3 +49,12 @@ export const requestPinAndroidWidget = async (
 export const getActiveWidgets = async (): Promise<WidgetInfo[]> => {
   return getNativeVoltraAndroid().getActiveWidgets() as Promise<WidgetInfo[]>
 }
+
+/**
+ * Set a configuration value for a client-rendered widget and re-render it. The value is
+ * surfaced as `env.configuration[key]` in the widget's `(props, env) => JSX` render. Stand-in
+ * for a Glance configuration activity.
+ */
+export const setWidgetConfiguration = async (widgetId: string, key: string, value: string): Promise<void> => {
+  return getNativeVoltraAndroid().setWidgetConfiguration(widgetId, key, value)
+}
diff --git a/packages/android/src/index.ts b/packages/android/src/index.ts
index a849cb61..ab67f5bd 100644
--- a/packages/android/src/index.ts
+++ b/packages/android/src/index.ts
@@ -13,6 +13,10 @@ export { renderAndroidLiveUpdateToJson, renderAndroidLiveUpdateToString } from '
 export { AndroidOngoingNotification } from './ongoing-notification/components.js'
 export { renderAndroidOngoingNotificationPayload } from './ongoing-notification/renderer.js'
 export { renderAndroidViewToJson, renderAndroidWidgetToJson, renderAndroidWidgetToString } from './widgets/renderer.js'
+// Single-node renderer used by client-rendered widgets (on-device Hermes render). Analog of
+// iOS `renderVoltraVariantToJson`. Invoked with `(props, env)` per render via the generated
+// widget entry.
+export { renderAndroidVariantToJson } from './renderer/index.js'
 
 // Android types
 export type { VoltraAndroidBaseProps } from './jsx/baseProps.js'
@@ -92,4 +96,4 @@ export type { RowProps } from './jsx/Row.js'
 export type { SpacerProps } from './jsx/Spacer.js'
 export type { TextProps } from './jsx/Text.js'
 export { isAndroidEnv, isIosEnv } from '@use-voltra/core'
-export type { MaterialColorScheme, WidgetBuildEnvironment, WidgetEnvironment } from '@use-voltra/core'
+export type { WidgetBuildEnvironment, WidgetEnvironment } from '@use-voltra/core'
diff --git a/packages/core/src/widget-environment.ts b/packages/core/src/widget-environment.ts
index aec480d3..e0805576 100644
--- a/packages/core/src/widget-environment.ts
+++ b/packages/core/src/widget-environment.ts
@@ -6,8 +6,8 @@
  * argument is populated by the native runtime at draw time and carries:
  *
  * - **Runtime device state** (`colorScheme`, `widgetFamily`, etc.) captured per render
- * - **Platform-specific runtime state** (`widgetRenderingMode` on iOS, `materialColors` on
- *   Android), present only on the platform that has the concept
+ * - **Platform-specific runtime state** (`widgetRenderingMode` on iOS), present only on the
+ *   platform that has the concept
  * - **AppIntent / user-configured params** under `env.configuration` (TypeScript-typed per
  *   widget via the generic parameter)
  * - **Build env** under `env.build.*` — values that don't change between renders inside a
@@ -50,16 +50,6 @@ export type WidgetEnvironment<TConfig extends Record<string, unknown> | undefine
    * Maps to SwiftUI `@Environment(\.showsWidgetContainerBackground)`. iOS 17+. */
   showsWidgetContainerBackground?: boolean
 
-  // ---------------------------------------------------------------------------
-  // Android-only runtime values
-  // Present only when rendering on Android; `undefined` on iOS.
-  // ---------------------------------------------------------------------------
-
-  /** Android — Material You dynamic color tokens captured from
-   * `MaterialTheme.colorScheme`. Field-for-field maps onto Compose `ColorScheme`
-   * (primary, onPrimary, surface, onSurface, etc.). */
-  materialColors?: MaterialColorScheme
-
   // ---------------------------------------------------------------------------
   // System-managed configuration
   // ---------------------------------------------------------------------------
@@ -98,38 +88,6 @@ export type WidgetBuildEnvironment = {
   voltraVersion: string
 }
 
-/**
- * Material You dynamic color tokens captured from Android `MaterialTheme.colorScheme`.
- * Field names map 1:1 onto Compose's `ColorScheme` properties. Each value is an RGBA
- * hex string (`#RRGGBBAA` or `#RRGGBB`). Available on Android only.
- */
-export type MaterialColorScheme = {
-  primary: string
-  onPrimary: string
-  primaryContainer: string
-  onPrimaryContainer: string
-  secondary: string
-  onSecondary: string
-  secondaryContainer: string
-  onSecondaryContainer: string
-  tertiary: string
-  onTertiary: string
-  tertiaryContainer: string
-  onTertiaryContainer: string
-  background: string
-  onBackground: string
-  surface: string
-  onSurface: string
-  surfaceVariant: string
-  onSurfaceVariant: string
-  outline: string
-  outlineVariant: string
-  error: string
-  onError: string
-  errorContainer: string
-  onErrorContainer: string
-}
-
 /**
  * Type guard — returns true when the runtime env is an iOS-platform env.
  *
@@ -146,9 +104,11 @@ export function isIosEnv(
 
 /**
  * Type guard — returns true when the runtime env is an Android-platform env.
+ *
+ * Android carries no platform-only runtime field (Material You colors are consumed via
+ * `AndroidDynamicColors` tokens resolved by the native renderer, not through `env`), so this is
+ * the complement of {@link isIosEnv}.
  */
-export function isAndroidEnv(
-  env: WidgetEnvironment
-): env is WidgetEnvironment & { materialColors: NonNullable<WidgetEnvironment['materialColors']> } {
-  return env.materialColors !== undefined
+export function isAndroidEnv(env: WidgetEnvironment): boolean {
+  return !isIosEnv(env)
 }
diff --git a/packages/ios/src/index.ts b/packages/ios/src/index.ts
index 6fe6efd7..f296104f 100644
--- a/packages/ios/src/index.ts
+++ b/packages/ios/src/index.ts
@@ -33,4 +33,4 @@ export type {
 export { renderWidgetToJson, renderWidgetToString } from './widgets/renderer.js'
 export type { ScheduledWidgetEntry, WidgetFamily, WidgetInfo, WidgetVariants } from './widgets/types.js'
 export { isAndroidEnv, isIosEnv } from '@use-voltra/core'
-export type { MaterialColorScheme, WidgetBuildEnvironment, WidgetEnvironment } from '@use-voltra/core'
+export type { WidgetBuildEnvironment, WidgetEnvironment } from '@use-voltra/core'
diff --git a/packages/metro/src/widgetRegistry.ts b/packages/metro/src/widgetRegistry.ts
index 3f3af3ae..84d7c442 100644
--- a/packages/metro/src/widgetRegistry.ts
+++ b/packages/metro/src/widgetRegistry.ts
@@ -61,6 +61,26 @@ function safeFileName(value: string): string {
   return value.replace(/[^a-zA-Z0-9_.-]+/g, '-')
 }
 
+// Per-platform render shim. Each generated entry imports `renderVariantToJson` from this module;
+// Metro resolves the `.ios`/`.android` file by the bundle request's `platform`, so one entry serves
+// both platforms (iOS → renderVoltraVariantToJson, Android → renderAndroidVariantToJson) without
+// baking a platform-specific renderer import into the entry.
+const RENDER_SHIM_BASENAME = 'voltra-render-shim'
+
+const RENDER_SHIM_FILES: Record<string, string> = {
+  [`${RENDER_SHIM_BASENAME}.ios.js`]:
+    "export { renderVoltraVariantToJson as renderVariantToJson } from '@use-voltra/ios'\n",
+  [`${RENDER_SHIM_BASENAME}.android.js`]:
+    "export { renderAndroidVariantToJson as renderVariantToJson } from '@use-voltra/android'\n",
+}
+
+function ensureRenderShim(generatedRoot: string): void {
+  ensureDirectory(generatedRoot)
+  for (const [fileName, content] of Object.entries(RENDER_SHIM_FILES)) {
+    writeFileIfChanged(path.join(generatedRoot, fileName), content)
+  }
+}
+
 export class DuplicateVoltraWidgetError extends Error {
   constructor({
     widgetId,
@@ -105,11 +125,14 @@ export function createWidgetRegistry({ projectRoot = process.cwd() }: { projectR
     widget: VoltraDirectiveWidget
   ): Pick<RegisteredVoltraWidget, 'generatedEntryPath' | 'generatedEntryRelativePath'> {
     ensureDirectory(generatedEntryRoot)
+    ensureRenderShim(generatedRoot)
 
     const entryFileName = `${safeFileName(widget.id)}-${hash(`${widget.sourcePath}:${widget.exportName}`)}.js`
     const generatedEntryPath = path.join(generatedEntryRoot, entryFileName)
     const importPath = toPosixPath(path.relative(generatedEntryRoot, widget.sourcePath)).replace(/\.[cm]?[jt]sx?$/, '')
     const normalizedImportPath = importPath.startsWith('.') ? importPath : `./${importPath}`
+    const shimRelative = toPosixPath(path.relative(generatedEntryRoot, path.join(generatedRoot, RENDER_SHIM_BASENAME)))
+    const shimImportPath = shimRelative.startsWith('.') ? shimRelative : `./${shimRelative}`
     const exportExpression =
       widget.exportName === 'default' ? 'WidgetModule.default' : `WidgetModule[${JSON.stringify(widget.exportName)}]`
 
@@ -117,7 +140,7 @@ export function createWidgetRegistry({ projectRoot = process.cwd() }: { projectR
       generatedEntryPath,
       [
         "import { createElement } from 'react'",
-        "import { renderVoltraVariantToJson } from '@use-voltra/ios'",
+        `import { renderVariantToJson } from ${JSON.stringify(shimImportPath)}`,
         `import * as WidgetModule from ${JSON.stringify(normalizedImportPath)}`,
         '',
         `const Widget = ${exportExpression}`,
@@ -127,11 +150,12 @@ export function createWidgetRegistry({ projectRoot = process.cwd() }: { projectR
         '}',
         '',
         '// Voltra client-rendered widget entry - invoked by the native JS runtime on every render.',
+        '// `renderVariantToJson` resolves per-platform via the render shim (see RENDER_SHIM_BASENAME).',
         'export function render(propsJSON, envJSON) {',
         "  const props = typeof propsJSON === 'string' ? (propsJSON ? JSON.parse(propsJSON) : {}) : (propsJSON || {})",
         "  const env = typeof envJSON === 'string' ? (envJSON ? JSON.parse(envJSON) : {}) : (envJSON || {})",
         '  const WidgetWithEnv = (forwardedProps) => Widget(forwardedProps, env)',
-        '  const resolved = renderVoltraVariantToJson(createElement(WidgetWithEnv, props))',
+        '  const resolved = renderVariantToJson(createElement(WidgetWithEnv, props))',
         '  return JSON.stringify(resolved)',
         '}',
         '',
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b0d446da..3604f83a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -240,6 +240,9 @@ importers:
       '@use-voltra/android':
         specifier: workspace:^
         version: link:../android
+      '@use-voltra/compiler':
+        specifier: workspace:^
+        version: link:../compiler
       '@use-voltra/expo-plugin':
         specifier: workspace:^
         version: link:../expo-plugin