diff --git a/.changeset/sour-wombats-invite.md b/.changeset/sour-wombats-invite.md
new file mode 100644
index 00000000..741091d7
--- /dev/null
+++ b/.changeset/sour-wombats-invite.md
@@ -0,0 +1,6 @@
+---
+"@infinitered/react-native-mlkit-barcode-scanning": minor
+"example-app": minor
+---
+
+add react native mlkit barcode scanning module
diff --git a/apps/ExampleApp/app.json b/apps/ExampleApp/app.json
index ad770a10..8f4eb6ea 100644
--- a/apps/ExampleApp/app.json
+++ b/apps/ExampleApp/app.json
@@ -74,7 +74,8 @@
         {
           "photosPermission": "This app uses the photo library to select images for Machine Learning purposes. i.e. Object and Image detection."
         }
-      ]
+      ],
+      "expo-asset"
     ],
     "experiments": {
       "tsconfigPaths": true
diff --git a/apps/ExampleApp/app/components/CameraModal.tsx b/apps/ExampleApp/app/components/CameraModal.tsx
new file mode 100644
index 00000000..a77c02b6
--- /dev/null
+++ b/apps/ExampleApp/app/components/CameraModal.tsx
@@ -0,0 +1,223 @@
+import React, { useRef, useState } from "react"
+import {
+  Modal,
+  View,
+  TouchableOpacity,
+  ActivityIndicator,
+  ViewStyle,
+  TextStyle,
+} from "react-native"
+import { useSafeAreaInsets } from "react-native-safe-area-context"
+import { CameraView, useCameraPermissions, CameraType } from "expo-camera"
+import { Text } from "./Text"
+import { Button } from "./Button"
+import { colors, spacing } from "../theme"
+
+interface CameraModalProps {
+  visible: boolean
+  onCapture: (uri: string) => void
+  onClose: () => void
+}
+
+export function CameraModal({ visible, onCapture, onClose }: CameraModalProps) {
+  const cameraRef = useRef<CameraView>(null)
+  const [permission, requestPermission] = useCameraPermissions()
+  const [isCapturing, setIsCapturing] = useState(false)
+  const [facing, setFacing] = useState<CameraType>("back")
+  const insets = useSafeAreaInsets()
+
+  const toggleFacing = () => {
+    setFacing((current) => (current === "back" ? "front" : "back"))
+  }
+
+  const handleCapture = async () => {
+    if (!cameraRef.current || isCapturing) return
+
+    setIsCapturing(true)
+    try {
+      const photo = await cameraRef.current.takePictureAsync({
+        quality: 0.5,
+      })
+      if (photo?.uri) {
+        onCapture(photo.uri)
+      }
+    } catch (error) {
+      console.error("Error capturing photo:", error)
+    } finally {
+      setIsCapturing(false)
+    }
+  }
+
+  if (!permission) {
+    return null
+  }
+
+  if (!permission.granted) {
+    return (
+      <Modal visible={visible} animationType="slide" onRequestClose={onClose}>
+        <View style={[$container, { paddingTop: insets.top, paddingBottom: insets.bottom }]}>
+          <View style={$permissionContainer}>
+            <Text style={$permissionText}>Camera permission is required to take photos.</Text>
+            <Button
+              text="Grant Permission"
+              preset="reversed"
+              onPress={requestPermission}
+              style={$permissionButton}
+            />
+            <Button
+              text="Cancel"
+              preset="default"
+              onPress={onClose}
+              style={$cancelButton}
+              textStyle={$cancelButtonText}
+            />
+          </View>
+        </View>
+      </Modal>
+    )
+  }
+
+  return (
+    <Modal visible={visible} animationType="slide" onRequestClose={onClose}>
+      <View style={$container}>
+        <CameraView ref={cameraRef} style={$camera} facing={facing}>
+          <View style={[$overlay, { paddingTop: insets.top, paddingBottom: insets.bottom }]}>
+            <View style={$topBar}>
+              <TouchableOpacity style={$closeButton} onPress={onClose}>
+                <Text style={$closeButtonText}>✕</Text>
+              </TouchableOpacity>
+              <TouchableOpacity style={$flipButton} onPress={toggleFacing}>
+                <Text style={$flipButtonText}>⟲</Text>
+              </TouchableOpacity>
+            </View>
+            <View style={$bottomBar}>
+              <TouchableOpacity
+                style={[$captureButton, isCapturing && $captureButtonDisabled]}
+                onPress={handleCapture}
+                disabled={isCapturing}
+              >
+                {isCapturing ? (
+                  <ActivityIndicator color={colors.palette.neutral900} />
+                ) : (
+                  <View style={$captureButtonInner} />
+                )}
+              </TouchableOpacity>
+            </View>
+          </View>
+        </CameraView>
+      </View>
+    </Modal>
+  )
+}
+
+const $container: ViewStyle = {
+  flex: 1,
+  backgroundColor: colors.palette.neutral900,
+}
+
+const $camera: ViewStyle = {
+  flex: 1,
+}
+
+const $overlay: ViewStyle = {
+  flex: 1,
+  justifyContent: "space-between",
+}
+
+const $topBar: ViewStyle = {
+  flexDirection: "row",
+  justifyContent: "space-between",
+  padding: spacing.md,
+}
+
+const $flipButton: ViewStyle = {
+  width: 44,
+  height: 44,
+  borderRadius: 22,
+  backgroundColor: colors.palette.overlay50,
+  justifyContent: "center",
+  alignItems: "center",
+  paddingBottom: 8,
+  paddingRight: 2,
+}
+
+const $flipButtonText: TextStyle = {
+  color: colors.palette.neutral100,
+  fontSize: 28,
+  textAlign: "center",
+  // marginTop: -8,
+  alignItems: "center",
+  alignSelf: "center",
+}
+
+const $closeButton: ViewStyle = {
+  width: 44,
+  height: 44,
+  borderRadius: 22,
+  backgroundColor: colors.palette.overlay50,
+  justifyContent: "center",
+  alignItems: "center",
+}
+
+const $closeButtonText: TextStyle = {
+  color: colors.palette.neutral100,
+  fontSize: 20,
+  fontWeight: "bold",
+}
+
+const $bottomBar: ViewStyle = {
+  flexDirection: "row",
+  justifyContent: "center",
+  paddingBottom: 40,
+}
+
+const $captureButton: ViewStyle = {
+  width: 80,
+  height: 80,
+  borderRadius: 40,
+  backgroundColor: colors.palette.neutral100,
+  justifyContent: "center",
+  alignItems: "center",
+  borderWidth: 4,
+  borderColor: "rgba(255,255,255,0.5)",
+}
+
+const $captureButtonDisabled: ViewStyle = {
+  opacity: 0.7,
+}
+
+const $captureButtonInner: ViewStyle = {
+  width: 60,
+  height: 60,
+  borderRadius: 30,
+  backgroundColor: colors.palette.neutral100,
+}
+
+const $permissionContainer: ViewStyle = {
+  flex: 1,
+  justifyContent: "center",
+  alignItems: "center",
+  padding: spacing.lg,
+}
+
+const $permissionText: TextStyle = {
+  fontSize: 16,
+  textAlign: "center",
+  marginBottom: spacing.lg,
+  color: colors.palette.neutral100,
+}
+
+const $permissionButton: ViewStyle = {
+  minWidth: 200,
+  marginBottom: spacing.sm,
+}
+
+const $cancelButton: ViewStyle = {
+  minWidth: 200,
+  backgroundColor: colors.transparent,
+  borderColor: colors.palette.neutral100,
+}
+
+const $cancelButtonText: TextStyle = {
+  color: colors.palette.neutral100,
+}
diff --git a/apps/ExampleApp/app/components/ImageSelector.tsx b/apps/ExampleApp/app/components/ImageSelector.tsx
index e11e6e4f..1e569618 100644
--- a/apps/ExampleApp/app/components/ImageSelector.tsx
+++ b/apps/ExampleApp/app/components/ImageSelector.tsx
@@ -6,6 +6,7 @@ import { Text } from "app/components/Text"
 import { useExampleImage, UseExampleImageStatus, SelectedImage } from "../utils/useExampleImage"
 import { RNMLKitImageView } from "./RNMLKitImageView"
 import { Button } from "./Button"
+import { CameraModal } from "./CameraModal"
 import { colors } from "../theme"
 import { ImageFilter, ImageGrouper } from "../utils/useExampleImage/examples"
 import { BoundingBox } from "@infinitered/react-native-mlkit-core"
@@ -36,7 +37,7 @@ export const ImageSelector = observer(function ImageSelector({
 }: ImageSelectorProps) {
   const [_status, _setStatus] = React.useState<UseExampleImageStatus>("init")
 
-  const { image, takePhoto, selectPhoto, clearPhoto } = useExampleImage({
+  const { image, takePhoto, selectPhoto, clearPhoto, showCameraModal, onCameraCapture, onCameraClose } = useExampleImage({
     filter: images?.filter ?? "all",
     groupBy: images?.groupBy ?? "none",
   })
@@ -94,6 +95,11 @@ export const ImageSelector = observer(function ImageSelector({
           />
         )}
       </View>
+      <CameraModal
+        visible={showCameraModal}
+        onCapture={onCameraCapture}
+        onClose={onCameraClose}
+      />
     </View>
   )
 })
diff --git a/apps/ExampleApp/app/navigators/AppNavigator.tsx b/apps/ExampleApp/app/navigators/AppNavigator.tsx
index 1e355b3c..98405560 100644
--- a/apps/ExampleApp/app/navigators/AppNavigator.tsx
+++ b/apps/ExampleApp/app/navigators/AppNavigator.tsx
@@ -35,6 +35,7 @@ export type AppStackParamList = {
   ObjectDetection: Record<string, never>
   DocumentScanner: Record<string, never>
   TextRecognition: Record<string, never>
+  BarcodeScanning: Record<string, never>
   // IGNITE_GENERATOR_ANCHOR_APP_STACK_PARAM_LIST
 }
 
@@ -63,6 +64,7 @@ const AppStack = observer(function AppStack() {
       <Stack.Screen name="ObjectDetection" component={Screens.ObjectDetectionScreen} />
       <Stack.Screen name="DocumentScanner" component={Screens.DocumentScannerScreen} />
       <Stack.Screen name="TextRecognition" component={Screens.TextRecognitionScreen} />
+      <Stack.Screen name="BarcodeScanning" component={Screens.BarcodeScanningScreen} />
       {/* IGNITE_GENERATOR_ANCHOR_APP_STACK_SCREENS */}
     </Stack.Navigator>
   )
diff --git a/apps/ExampleApp/app/screens/BarcodeScanningScreen.tsx b/apps/ExampleApp/app/screens/BarcodeScanningScreen.tsx
new file mode 100644
index 00000000..3bd42249
--- /dev/null
+++ b/apps/ExampleApp/app/screens/BarcodeScanningScreen.tsx
@@ -0,0 +1,241 @@
+import React, { FC, useState, useEffect, useCallback } from "react"
+import { observer } from "mobx-react-lite"
+import { ViewStyle, View, ImageStyle, TextStyle, ScrollView, Pressable } from "react-native"
+import { NativeStackScreenProps } from "@react-navigation/native-stack"
+import { AppStackScreenProps } from "../navigators"
+import { Text, Icon, ImageSelector, Screen } from "../components"
+import { useTypedNavigation } from "../navigators/useTypedNavigation"
+
+import RNMLKitBarcodeScanningModule, {
+  BarcodeFormat,
+} from "@infinitered/react-native-mlkit-barcode-scanning"
+import type {
+  BarcodeScannerOptions,
+  BarcodeScannerResult,
+} from "@infinitered/react-native-mlkit-barcode-scanning"
+import { UseExampleImageStatus, SelectedImage } from "../utils/useExampleImage"
+
+type BarcodeScanningScreenProps = NativeStackScreenProps<AppStackScreenProps<"BarcodeScanning">>
+
+function DebugOutput({ data }: { data: unknown }) {
+  const [expanded, setExpanded] = useState(false)
+
+  return (
+    <View style={$debugContainer}>
+      <Pressable onPress={() => setExpanded(!expanded)} style={$debugHeader}>
+        <Text style={$debugTitle}>{expanded ? "▼" : "▶"} Debug Output</Text>
+      </Pressable>
+      {expanded && (
+        <ScrollView style={$debugContent} horizontal>
+          <ScrollView nestedScrollEnabled>
+            <Text style={$debugText}>{JSON.stringify(data, null, 2)}</Text>
+          </ScrollView>
+        </ScrollView>
+      )}
+    </View>
+  )
+}
+
+const DEFAULT_OPTIONS: BarcodeScannerOptions = {
+  barcodeFormats: [BarcodeFormat.ALL],
+  enableAllPotentialBarcodes: false,
+}                                                                                                                                                                                                                                         
+
+export const BarcodeScanningScreen: FC<BarcodeScanningScreenProps> = observer(
+  function BarcodeScanningScreen() {
+    const navigation = useTypedNavigation<"BarcodeScanning">()
+
+    const [image, setImage] = useState<SelectedImage | null>(null)
+
+    const handleImageChange = useCallback((nextImage: SelectedImage) => {
+      setImage(nextImage)
+    }, [])
+
+    const [result, setResult] = useState<BarcodeScannerResult | null>(null)
+    const [status, setStatus] = useState<
+      "init" | "noPermissions" | "done" | "error" | "loading" | UseExampleImageStatus
+    >("init")
+
+    const onStatusChange = React.useCallback(
+      (status: "init" | "noPermissions" | "done" | "error" | "loading" | UseExampleImageStatus) => {
+        setStatus(status)
+      },
+      [],
+    )
+
+    const [isScanning, setIsScanning] = useState(false)
+
+    useEffect(() => {
+      const scanBarcode = async () => {
+        if (!image?.uri) return
+        setIsScanning(true)
+        try {
+          await RNMLKitBarcodeScanningModule.initialize(DEFAULT_OPTIONS)
+          const scanResult = await RNMLKitBarcodeScanningModule.process(image.uri)
+          setResult(scanResult)
+          setStatus("done")
+        } catch (error) {
+          console.error("Error scanning barcode:", error)
+          setStatus("error")
+        } finally {
+          setIsScanning(false)
+        }
+      }
+
+      scanBarcode().then(() => null)
+    }, [image])
+
+    const statusMessage = React.useMemo(() => {
+      if (!image && status !== "init") {
+        setStatus("init")
+      }
+      if (isScanning) {
+        return "Scanning for barcodes..."
+      }
+      switch (status) {
+        case "init":
+          return "Take a photo or select one from your camera roll"
+        case "noPermissions":
+          return "You need to grant camera permissions to take a photo"
+        case "takingPhoto":
+          return "Taking photo..."
+        case "selectingPhoto":
+          return "Selecting photo..."
+        case "done":
+          return result?.barcodes.length
+            ? `Found ${result.barcodes.length} barcode${result.barcodes.length > 1 ? "s" : ""}!`
+            : "No barcodes found"
+        case "error":
+          return "Error during scanning!"
+        case "loading":
+          return "Loading Example Images..."
+        default:
+          return ""
+      }
+    }, [result, image, status, isScanning])
+
+    const clearResults = useCallback(() => {
+      setResult(null)
+    }, [])
+
+    return (
+      <Screen style={$root} preset="scroll" safeAreaEdges={["top", "bottom"]}>
+        <View>
+          <Icon icon={"back"} onPress={() => navigation.navigate("Home")} style={$backIcon} />
+          <Text preset={"heading"} text="Barcode Scanning" />
+          <Text style={$description}>Take a photo of a barcode and scan it.</Text>
+        </View>
+        <ImageSelector
+          onImageChange={handleImageChange}
+          onImageClear={clearResults}
+          onStatusChange={onStatusChange}
+          statusMessage={statusMessage}
+          status={isScanning ? "loading" : status}
+          isLoading={false}
+          images={{
+            filter: "all",
+            groupBy: "label",
+          }}
+        />
+
+        {result && result.barcodes.length > 0 && (
+          <>
+            <View style={$resultContainer}>
+              <Text preset="subheading">Scanned Barcodes</Text>
+              {result.barcodes.map((barcode, index) => (
+                <View key={index} style={$barcodeItem}>
+                  <Text style={$barcodeLabel}>Format: {barcode.format}</Text>
+                  <Text style={$barcodeLabel}>Type: {barcode.valueType}</Text>
+                  {barcode.displayValue && (
+                    <Text style={$barcodeValue}>Value: {barcode.displayValue}</Text>
+                  )}
+                  {barcode.rawValue && barcode.rawValue !== barcode.displayValue && (
+                    <Text style={$barcodeRaw}>Raw: {barcode.rawValue}</Text>
+                  )}
+                </View>
+              ))}
+            </View>
+            <DebugOutput data={result} />
+          </>
+        )}
+      </Screen>
+    )
+  },
+)
+
+const $root: ViewStyle = {
+  flex: 1,
+  padding: 16,
+  display: "flex",
+  flexDirection: "column",
+}
+const $backIcon: ImageStyle = { marginVertical: 8 }
+
+const $description: TextStyle = {
+  marginVertical: 8,
+  color: "rgba(0,0,0,0.6)",
+}
+
+const $resultContainer: ViewStyle = {
+  width: "100%",
+  borderWidth: 1,
+  borderColor: "rgba(0,0,0,0.2)",
+  borderRadius: 8,
+  padding: 12,
+  marginVertical: 16,
+}
+
+const $barcodeItem: ViewStyle = {
+  marginTop: 12,
+  paddingTop: 12,
+  borderTopWidth: 1,
+  borderTopColor: "rgba(0,0,0,0.1)",
+}
+
+const $barcodeLabel: TextStyle = {
+  fontSize: 12,
+  color: "rgba(0,0,0,0.6)",
+  marginBottom: 4,
+}
+
+const $barcodeValue: TextStyle = {
+  fontSize: 16,
+  fontWeight: "600",
+  marginTop: 4,
+}
+
+const $barcodeRaw: TextStyle = {
+  fontSize: 12,
+  fontFamily: "monospace",
+  marginTop: 4,
+  color: "rgba(0,0,0,0.5)",
+}
+
+const $debugContainer: ViewStyle = {
+  width: "100%",
+  borderWidth: 1,
+  borderColor: "rgba(0,0,0,0.2)",
+  borderRadius: 8,
+  marginBottom: 24,
+  overflow: "hidden",
+}
+
+const $debugHeader: ViewStyle = {
+  padding: 12,
+  backgroundColor: "rgba(0,0,0,0.05)",
+}
+
+const $debugTitle: TextStyle = {
+  fontWeight: "bold",
+}
+
+const $debugContent: ViewStyle = {
+  maxHeight: 300,
+  padding: 12,
+  backgroundColor: "rgba(0,0,0,0.02)",
+}
+
+const $debugText: TextStyle = {
+  fontFamily: "monospace",
+  fontSize: 12,
+}
diff --git a/apps/ExampleApp/app/screens/FaceDetectionScreen/FaceDetectionScreen.tsx b/apps/ExampleApp/app/screens/FaceDetectionScreen/FaceDetectionScreen.tsx
index 943ab7cc..90166705 100644
--- a/apps/ExampleApp/app/screens/FaceDetectionScreen/FaceDetectionScreen.tsx
+++ b/apps/ExampleApp/app/screens/FaceDetectionScreen/FaceDetectionScreen.tsx
@@ -7,6 +7,7 @@ import { Screen, Text, Button, RNMLKitImageView, ScreenTitle } from "~/component
 import { useTypedNavigation } from "~/navigators/useTypedNavigation"
 import { colors } from "~/theme"
 import { useExampleImage } from "~/utils/useExampleImage"
+import { CameraModal } from "~/components/CameraModal"
 import { BOX_COLORS } from "~/screens"
 import { BoundingBox } from "@infinitered/react-native-mlkit-core"
 import {
@@ -33,7 +34,7 @@ const FaceDetectionScreenComponent: FC<FaceDetectionScreenProps> = observer(
   function FaceDetectionScreen() {
     const navigation = useTypedNavigation<"FaceDetection">()
 
-    const { image, clearPhoto, takePhoto, selectPhoto } = useExampleImage()
+    const { image, clearPhoto, takePhoto, selectPhoto, showCameraModal, onCameraCapture, onCameraClose } = useExampleImage()
 
     const {
       faces,
@@ -99,6 +100,11 @@ const FaceDetectionScreenComponent: FC<FaceDetectionScreenProps> = observer(
         ) : (
           <Button text={"Select Photo"} onPress={selectPhoto} style={$button} />
         )}
+        <CameraModal
+          visible={showCameraModal}
+          onCapture={onCameraCapture}
+          onClose={onCameraClose}
+        />
       </Screen>
     )
   },
diff --git a/apps/ExampleApp/app/screens/HomeScreen/demoInfo.ts b/apps/ExampleApp/app/screens/HomeScreen/demoInfo.ts
index 331dc0f2..eb4ca8f5 100644
--- a/apps/ExampleApp/app/screens/HomeScreen/demoInfo.ts
+++ b/apps/ExampleApp/app/screens/HomeScreen/demoInfo.ts
@@ -53,5 +53,11 @@ export const DEMO_LIST: DemoInfo[] = [
     screen: "TextRecognition",
     image: TEXT_RECOGNITION,
   },
+  {
+    title: "Barcode Scanning",
+    description: "Scan barcodes and QR codes from images",
+    screen: "BarcodeScanning",
+    image: FACE_HOLDER,
+  },
   ...PLATFORM_SPECIFIC_DEMOS,
 ]
diff --git a/apps/ExampleApp/app/screens/index.ts b/apps/ExampleApp/app/screens/index.ts
index 52f2fb39..2f8d0276 100644
--- a/apps/ExampleApp/app/screens/index.ts
+++ b/apps/ExampleApp/app/screens/index.ts
@@ -7,4 +7,5 @@ export * from "./ImageLabelingScreen"
 export * from "./DocumentScannerScreen"
 export { BOX_COLORS } from "./FaceDetectionScreen"
 export * from "./ObjectDetectionScreen"
-export * from "./TextRecognitionScreen"
\ No newline at end of file
+export * from "./TextRecognitionScreen"
+export * from "./BarcodeScanningScreen"
\ No newline at end of file
diff --git a/apps/ExampleApp/app/utils/useExampleImage/useExampleImage.ts b/apps/ExampleApp/app/utils/useExampleImage/useExampleImage.ts
index 10e2c79e..405b0397 100644
--- a/apps/ExampleApp/app/utils/useExampleImage/useExampleImage.ts
+++ b/apps/ExampleApp/app/utils/useExampleImage/useExampleImage.ts
@@ -6,6 +6,7 @@ import {
   ImagePickerAsset,
   useCameraPermissions,
 } from "expo-image-picker"
+import { Platform } from "react-native"
 import { useCallback, useState, useMemo } from "react"
 import { useAssets, Asset } from "expo-asset"
 import {
@@ -42,6 +43,10 @@ interface UseExpoCameraImageReturnType {
   nextPhoto?: (category: string) => void
   categories?: string[]
   status: UseExampleImageStatus
+  // Android camera modal support (workaround for expo-image-picker issues on Android 16)
+  showCameraModal: boolean
+  onCameraCapture: (uri: string) => void
+  onCameraClose: () => void
 }
 
 export interface RandomImage {
@@ -68,6 +73,7 @@ export function useExampleImage(predicates?: {
   const [status, setStatus] = useState<UseExampleImageStatus>("init")
   const [cameraPermission, requestCameraPermission] = useCameraPermissions()
   const [image, setImage] = useState<SelectedImage | undefined>(undefined)
+  const [showCameraModal, setShowCameraModal] = useState(false)
 
   const filter = predicates?.filter ? imageFilters[predicates.filter] : imageFilters.sfw
   const groupBy = predicates?.groupBy ? imageGroupers[predicates.groupBy] : imageGroupers.none
@@ -110,27 +116,61 @@ export function useExampleImage(predicates?: {
 
   const selectPhoto = useCallback(async () => {
     setStatus("selectingPhoto")
-    const result: ImagePickerResult = await launchImageLibraryAsync(IMAGE_PICKER_OPTIONS)
-    if (result.assets?.[0]) {
-      setImage({ ...result.assets?.[0], localUri: result.assets?.[0].uri } as SelectedImage)
-    } else {
+    try {
+      const result: ImagePickerResult = await launchImageLibraryAsync(IMAGE_PICKER_OPTIONS)
+      if (result.assets?.[0]) {
+        setImage({ ...result.assets?.[0], localUri: result.assets?.[0].uri } as SelectedImage)
+      } else {
+        setImage(undefined)
+      }
+    } catch (error) {
+      console.warn("Image picker error (may be non-fatal):", error)
       setImage(undefined)
     }
-  }, [setStatus]) // Note: Removed parentheses from launchImageLibraryAsync
+  }, [setStatus])
 
   const categories = Object.keys(annotatedAssets) as Array<keyof typeof annotatedAssets>
 
+  // Android camera modal callbacks (workaround for expo-image-picker issues on Android 16)
+  const onCameraCapture = useCallback(
+    (uri: string) => {
+      setShowCameraModal(false)
+      setImage({ uri, localUri: uri, width: 0, height: 0 } as SelectedImage)
+    },
+    [setImage],
+  )
+
+  const onCameraClose = useCallback(() => {
+    setShowCameraModal(false)
+    setStatus("init")
+  }, [setStatus])
+
   const takePhoto = useCallback(async () => {
+    // Android 16 workaround: use custom camera modal instead of expo-image-picker
+    // See: https://github.com/expo/expo/issues/39480
+    if (Platform.OS === "android") {
+      setStatus("takingPhoto")
+      setShowCameraModal(true)
+      return
+    }
+
+    // iOS: use original expo-image-picker flow
     const hasPermissions = await checkPermissions()
     if (!hasPermissions) {
       setImage(undefined)
       return
     }
+
     setStatus("takingPhoto")
-    const result: ImagePickerResult = await launchCameraAsync(IMAGE_PICKER_OPTIONS)
-    if (result.assets?.[0]) {
-      setImage({ ...result.assets?.[0], localUri: result.assets?.[0].uri } as SelectedImage)
-    } else {
+    try {
+      const result: ImagePickerResult = await launchCameraAsync(IMAGE_PICKER_OPTIONS)
+      if (result.assets?.[0]) {
+        setImage({ ...result.assets?.[0], localUri: result.assets?.[0].uri } as SelectedImage)
+      } else {
+        setImage(undefined)
+      }
+    } catch (error) {
+      console.warn("Camera error (may be non-fatal):", error)
       setImage(undefined)
     }
   }, [checkPermissions, setStatus])
@@ -178,7 +218,10 @@ export function useExampleImage(predicates?: {
       nextPhoto,
       categories,
       status,
+      showCameraModal,
+      onCameraCapture,
+      onCameraClose,
     }),
-    [image, clearPhoto, selectPhoto, takePhoto, nextPhoto, categories, status],
+    [image, clearPhoto, selectPhoto, takePhoto, nextPhoto, categories, status, showCameraModal, onCameraCapture, onCameraClose],
   )
 }
diff --git a/apps/ExampleApp/package.json b/apps/ExampleApp/package.json
index 0783ef09..1d7028e9 100644
--- a/apps/ExampleApp/package.json
+++ b/apps/ExampleApp/package.json
@@ -32,6 +32,7 @@
   "dependencies": {
     "@expo-google-fonts/space-grotesk": "^0.2.2",
     "@expo/metro-runtime": "~6.1.2",
+    "@infinitered/react-native-mlkit-barcode-scanning": "workspace:^5.0.0",
     "@infinitered/react-native-mlkit-document-scanner": "workspace:^5.0.0",
     "@infinitered/react-native-mlkit-face-detection": "workspace:^5.0.0",
     "@infinitered/react-native-mlkit-image-labeling": "workspace:^5.0.0",
@@ -45,7 +46,9 @@
     "expo": "^54.0.23",
     "expo-asset": "~12.0.9",
     "expo-build-properties": "~1.0.9",
+    "expo-camera": "~17.0.10",
     "expo-dev-client": "~6.0.17",
+    "expo-file-system": "~19.0.21",
     "expo-font": "~14.0.9",
     "expo-image": "~3.0.10",
     "expo-image-picker": "~17.0.8",
diff --git a/docs/barcode-scanning/category.json b/docs/barcode-scanning/category.json
new file mode 100644
index 00000000..333c8e38
--- /dev/null
+++ b/docs/barcode-scanning/category.json
@@ -0,0 +1,4 @@
+{
+    "label": "Barcode Scanner",
+    "position": 100
+  }
\ No newline at end of file
diff --git a/docs/barcode-scanning/index.md b/docs/barcode-scanning/index.md
new file mode 100644
index 00000000..fb19c9ad
--- /dev/null
+++ b/docs/barcode-scanning/index.md
@@ -0,0 +1,250 @@
+---
+sidebar_position: 1
+title: Getting Started
+---
+
+# Barcode Scanner
+
+## Getting Started
+
+This is an expo module that lets you use the [MLKit Barcode Scanning](https://developers.google.com/ml-kit/vision/barcode-scanning) library in your Expo app. It supports both Android and iOS platforms.
+
+## Installation
+
+Install like any other npm package:
+
+```bash
+#yarn
+yarn add @infinitered/react-native-mlkit-barcode-scanning
+
+#npm
+npm install @infinitered/react-native-mlkit-barcode-scanning
+```
+
+## Basic Usage
+
+### 1. Initialize the barcode scanner
+
+Before scanning, you need to initialize the scanner with your desired [options](./options).
+
+```tsx
+import RNMLKitBarcodeScanningModule, {
+  BarcodeFormat,
+} from "@infinitered/react-native-mlkit-barcode-scanning";
+import type { BarcodeScannerOptions } from "@infinitered/react-native-mlkit-barcode-scanning";
+
+const options: BarcodeScannerOptions = {
+  barcodeFormats: [BarcodeFormat.ALL],
+};
+
+await RNMLKitBarcodeScanningModule.initialize(options);
+```
+
+### 2. Process an image for barcodes
+
+Once initialized, pass an image path to the `process` method to scan for barcodes.
+
+```tsx
+const result = await RNMLKitBarcodeScanningModule.process(imagePath);
+
+// result.barcodes contains an array of detected barcodes
+for (const barcode of result.barcodes) {
+  console.log("Format:", barcode.format);
+  console.log("Value:", barcode.displayValue);
+  console.log("Type:", barcode.valueType);
+}
+```
+
+### 3. Full example
+
+Here's a complete example showing how to scan barcodes from an image:
+
+```tsx
+import React, { useState } from "react";
+import { View, Button, Text, Image } from "react-native";
+import * as ImagePicker from "expo-image-picker";
+import RNMLKitBarcodeScanningModule, {
+  BarcodeFormat,
+} from "@infinitered/react-native-mlkit-barcode-scanning";
+import type {
+  BarcodeScannerOptions,
+  BarcodeScannerResult,
+} from "@infinitered/react-native-mlkit-barcode-scanning";
+
+const DEFAULT_OPTIONS: BarcodeScannerOptions = {
+  barcodeFormats: [BarcodeFormat.ALL],
+};
+
+function BarcodeScannerExample() {
+  const [result, setResult] = useState<BarcodeScannerResult | null>(null);
+  const [imageUri, setImageUri] = useState<string | null>(null);
+
+  const scanBarcode = async () => {
+    // Pick an image
+    const pickerResult = await ImagePicker.launchImageLibraryAsync({
+      mediaTypes: ImagePicker.MediaTypeOptions.Images,
+    });
+
+    if (pickerResult.canceled) return;
+
+    const uri = pickerResult.assets[0].uri;
+    setImageUri(uri);
+
+    // Initialize and scan
+    await RNMLKitBarcodeScanningModule.initialize(DEFAULT_OPTIONS);
+    const scanResult = await RNMLKitBarcodeScanningModule.process(uri);
+    setResult(scanResult);
+  };
+
+  return (
+    <View style={{ flex: 1, padding: 16 }}>
+      <Button onPress={scanBarcode} title="Select Image to Scan" />
+
+      {imageUri && (
+        <Image
+          source={{ uri: imageUri }}
+          style={{ width: 200, height: 200, marginVertical: 16 }}
+        />
+      )}
+
+      {result && result.barcodes.length > 0 && (
+        <View>
+          <Text style={{ fontWeight: "bold" }}>
+            Found {result.barcodes.length} barcode(s):
+          </Text>
+          {result.barcodes.map((barcode, index) => (
+            <View key={index} style={{ marginTop: 8 }}>
+              <Text>Format: {barcode.format}</Text>
+              <Text>Type: {barcode.valueType}</Text>
+              <Text>Value: {barcode.displayValue}</Text>
+            </View>
+          ))}
+        </View>
+      )}
+
+      {result && result.barcodes.length === 0 && (
+        <Text>No barcodes found in the image.</Text>
+      )}
+    </View>
+  );
+}
+```
+
+## Supported Barcode Formats
+
+The scanner supports the following barcode formats:
+
+| Format       | Description                          |
+| ------------ | ------------------------------------ |
+| `ALL`        | Scan for all supported formats       |
+| `code128`    | Code 128 barcode                     |
+| `code39`     | Code 39 barcode                      |
+| `code93`     | Code 93 barcode                      |
+| `codaBar`    | Codabar barcode                      |
+| `dataMatrix` | Data Matrix 2D barcode               |
+| `EAN13`      | EAN-13 barcode                       |
+| `EAN8`       | EAN-8 barcode                        |
+| `ITF`        | ITF (Interleaved 2 of 5) barcode     |
+| `qrCode`     | QR Code                              |
+| `UPCA`       | UPC-A barcode                        |
+| `UPCE`       | UPC-E barcode                        |
+| `PDF417`     | PDF417 barcode                       |
+| `aztec`      | Aztec 2D barcode                     |
+
+:::tip Performance Tip
+For better performance, specify only the barcode formats you need instead of using `BarcodeFormat.ALL`. This reduces processing time by limiting the scanner to specific formats.
+:::
+
+## Barcode Value Types
+
+The scanner automatically detects the type of content encoded in a barcode. The `valueType` property indicates what kind of data was found:
+
+| Value Type        | Description                                      |
+| ----------------- | ------------------------------------------------ |
+| `TEXT`            | Plain text                                       |
+| `URL`             | URL/web link                                     |
+| `EMAIL`           | Email address (with optional subject/body)       |
+| `PHONE`           | Phone number                                     |
+| `SMS`             | SMS message (phone number and message)           |
+| `WIFI`            | Wi-Fi network credentials                        |
+| `GEO`             | Geographic coordinates                           |
+| `CONTACT_INFO`    | Contact information (vCard)                      |
+| `CALENDAR_EVENT`  | Calendar event                                   |
+| `DRIVER_LICENSE`  | Driver's license information                     |
+| `ISBN`            | ISBN book identifier                             |
+| `PRODUCT`         | Product code                                     |
+| `UNKNOWN`         | Unknown or unrecognized type                     |
+
+Based on the `valueType`, additional properties will be populated on the barcode object. For example, a barcode with `valueType: "WIFI"` will have a `wifi` property containing `ssid`, `password`, and `type` fields.
+
+## API Reference
+
+### Methods
+
+#### `initialize(options: BarcodeScannerOptions): Promise<void>`
+
+Initializes the barcode scanner with the specified options. Must be called before `process()`.
+
+#### `process(imagePath: string): Promise<BarcodeScannerResult>`
+
+Processes an image and returns any detected barcodes. The `imagePath` should be a valid local file URI.
+
+### Types
+
+#### `BarcodeScannerOptions`
+
+```ts
+interface BarcodeScannerOptions {
+  barcodeFormats?: BarcodeFormat[];
+  enableAllPotentialBarcodes?: boolean;
+}
+```
+
+| Property                     | Type             | Description                                              |
+| ---------------------------- | ---------------- | -------------------------------------------------------- |
+| `barcodeFormats`             | `BarcodeFormat[]`| Array of barcode formats to scan for. Defaults to `ALL`. |
+| `enableAllPotentialBarcodes` | `boolean`        | Enable detection of potential barcodes even if they can't be fully decoded. **Android only.** |
+
+#### `BarcodeScannerResult`
+
+```ts
+interface BarcodeScannerResult {
+  barcodes: Barcode[];
+}
+```
+
+#### `Barcode`
+
+```ts
+interface Barcode {
+  frame: RNMLKitRect;
+  rawValue?: string;
+  rawData?: BarcodeRawData;
+  displayValue?: string;
+  format: BarcodeFormat;
+  cornerPoints: RNMLKitPoint[];
+  valueType: BarcodeValueType;
+  // Type-specific properties
+  email?: BarcodeEmail;
+  phone?: BarcodePhone;
+  sms?: BarcodeSMS;
+  url?: BarcodeURLBookmark;
+  wifi?: BarcodeWifi;
+  geoPoint?: BarcodeGeoPoint;
+  contactInfo?: BarcodeContactInfo;
+  calendarEvent?: BarcodeCalendarEvent;
+  driverLicense?: BarcodeDriverLicense;
+}
+```
+
+| Property       | Type                  | Description                                           |
+| -------------- | --------------------- | ----------------------------------------------------- |
+| `frame`        | `RNMLKitRect`         | Bounding box of the barcode in the image              |
+| `rawValue`     | `string`              | Raw string value encoded in the barcode               |
+| `rawData`      | `BarcodeRawData`      | Raw bytes of the barcode data                         |
+| `displayValue` | `string`              | Human-readable value (may differ from rawValue)       |
+| `format`       | `BarcodeFormat`       | The format/type of barcode detected                   |
+| `cornerPoints` | `RNMLKitPoint[]`      | Corner coordinates of the barcode                     |
+| `valueType`    | `BarcodeValueType`    | The semantic type of the barcode content              |
+
+For more details on the ML Kit Barcode Scanning API, see the [official documentation](https://developers.google.com/ml-kit/vision/barcode-scanning).
\ No newline at end of file
diff --git a/docs/barcode-scanning/options.md b/docs/barcode-scanning/options.md
new file mode 100644
index 00000000..437f9cab
--- /dev/null
+++ b/docs/barcode-scanning/options.md
@@ -0,0 +1,63 @@
+---
+sidebar_position: 99
+title: Options
+---
+
+# Barcode Scanner Options
+
+A `BarcodeScannerOptions` object is used to configure the behavior of the barcode scanner. This interface provides optional properties that allow you to specify which barcode formats to scan for and enable additional detection features.
+
+| Property                     | Type              | Optional | Description                                                                      |
+| ---------------------------- | ----------------- | -------- | -------------------------------------------------------------------------------- |
+| `barcodeFormats`             | `BarcodeFormat[]` | Yes      | Array of barcode formats to scan for. Defaults to `ALL` if not specified.        |
+| `enableAllPotentialBarcodes` | `boolean`         | Yes      | Enable detection of potential barcodes even if they can't be fully decoded. **Android only.** |
+
+For more information on these options, see [the MLKit Docs](https://developers.google.com/ml-kit/vision/barcode-scanning/android).
+
+### Example Usage
+
+```ts
+import { BarcodeFormat } from "@infinitered/react-native-mlkit-barcode-scanning";
+import type { BarcodeScannerOptions } from "@infinitered/react-native-mlkit-barcode-scanning";
+
+// Scan for all barcode formats
+const allFormatsOptions: BarcodeScannerOptions = {
+  barcodeFormats: [BarcodeFormat.ALL],
+};
+
+// Scan only for QR codes and EAN-13 barcodes (better performance)
+const specificFormatsOptions: BarcodeScannerOptions = {
+  barcodeFormats: [BarcodeFormat.qrCode, BarcodeFormat.EAN13],
+};
+
+// Enable detection of partial/potential barcodes (Android only)
+const potentialBarcodesOptions: BarcodeScannerOptions = {
+  barcodeFormats: [BarcodeFormat.ALL],
+  enableAllPotentialBarcodes: true,
+};
+```
+
+### Available Barcode Formats
+
+The `BarcodeFormat` enum provides the following values:
+
+| Format       | Value          | Description                      |
+| ------------ | -------------- | -------------------------------- |
+| `ALL`        | `"all"`        | Scan for all supported formats   |
+| `code128`    | `"code128"`    | Code 128 barcode                 |
+| `code39`     | `"code39"`     | Code 39 barcode                  |
+| `code93`     | `"code93"`     | Code 93 barcode                  |
+| `codaBar`    | `"codaBar"`    | Codabar barcode                  |
+| `dataMatrix` | `"dataMatrix"` | Data Matrix 2D barcode           |
+| `EAN13`      | `"EAN13"`      | EAN-13 barcode                   |
+| `EAN8`       | `"EAN8"`       | EAN-8 barcode                    |
+| `ITF`        | `"ITF"`        | ITF (Interleaved 2 of 5) barcode |
+| `qrCode`     | `"qrCode"`     | QR Code                          |
+| `UPCA`       | `"UPCA"`       | UPC-A barcode                    |
+| `UPCE`       | `"UPCE"`       | UPC-E barcode                    |
+| `PDF417`     | `"PDF417"`     | PDF417 barcode                   |
+| `aztec`      | `"AZTEC"`      | Aztec 2D barcode                 |
+
+:::tip Performance Tip
+For better scanning performance, specify only the barcode formats you expect to encounter rather than using `BarcodeFormat.ALL`. This reduces processing overhead and can significantly improve scan speed.
+:::
diff --git a/modules/react-native-mlkit-barcode-scanning/.eslintrc.js b/modules/react-native-mlkit-barcode-scanning/.eslintrc.js
new file mode 100644
index 00000000..0dc2ae2a
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/.eslintrc.js
@@ -0,0 +1,8 @@
+module.exports = {
+  root: true,
+  extends: ["universe/native", "universe/web"],
+  ignorePatterns: ["build"],
+  rules: {
+    "@typescript-eslint/array-type": "off",
+  },
+};
diff --git a/modules/react-native-mlkit-barcode-scanning/.gitignore b/modules/react-native-mlkit-barcode-scanning/.gitignore
new file mode 100644
index 00000000..e64b91c9
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/.gitignore
@@ -0,0 +1,57 @@
+# OSX
+#
+.DS_Store
+
+# VSCode
+.vscode/
+jsconfig.json
+
+# Xcode
+#
+build/
+*.pbxuser
+!default.pbxuser
+*.mode1v3
+!default.mode1v3
+*.mode2v3
+!default.mode2v3
+*.perspectivev3
+!default.perspectivev3
+xcuserdata
+*.xccheckout
+*.moved-aside
+DerivedData
+*.hmap
+*.ipa
+*.xcuserstate
+project.xcworkspace
+
+# Android/IJ
+#
+.classpath
+.cxx
+.gradle
+.idea
+.project
+.settings
+local.properties
+android.iml
+android/app/libs
+android/keystores/debug.keystore
+
+# Cocoapods
+#
+example/ios/Pods
+
+# Ruby
+example/vendor/
+
+# node.js
+#
+node_modules/
+npm-debug.log
+yarn-debug.log
+yarn-error.log
+
+# Expo
+.expo/*
diff --git a/modules/react-native-mlkit-barcode-scanning/.npmignore b/modules/react-native-mlkit-barcode-scanning/.npmignore
new file mode 100644
index 00000000..fa6abe7c
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/.npmignore
@@ -0,0 +1,11 @@
+# Exclude all top-level hidden directories by convention
+/.*/
+
+__mocks__
+__tests__
+
+/babel.config.js
+/android/src/androidTest/
+/android/src/test/
+/android/build/
+/example/
diff --git a/modules/react-native-mlkit-barcode-scanning/.yarnrc.yml b/modules/react-native-mlkit-barcode-scanning/.yarnrc.yml
new file mode 100644
index 00000000..3186f3f0
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/.yarnrc.yml
@@ -0,0 +1 @@
+nodeLinker: node-modules
diff --git a/modules/react-native-mlkit-barcode-scanning/README.md b/modules/react-native-mlkit-barcode-scanning/README.md
new file mode 100644
index 00000000..8ec2c6e0
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/README.md
@@ -0,0 +1,5 @@
+# @infinitered/react-native-mlkit-barcode-scanning
+
+Check the friendly docs here! 📖](https://docs.infinite.red/react-native-mlkit/barcode-scanning)
+
+## Getting Started with react-native-mlkit-barcode-scanning
diff --git a/modules/react-native-mlkit-barcode-scanning/android/build.gradle b/modules/react-native-mlkit-barcode-scanning/android/build.gradle
new file mode 100644
index 00000000..83b3fefe
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/android/build.gradle
@@ -0,0 +1,63 @@
+apply plugin: 'com.android.library'
+
+group = 'red.infinite.reactnativemlkit.barcodescanning'
+version = '0.7.6'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useExpoPublishing()
+
+// If you want to use the managed Android SDK versions from expo-modules-core, set this to true.
+// The Android SDK versions will be bumped from time to time in SDK releases and may introduce breaking changes in your module code.
+// Most of the time, you may like to manage the Android SDK versions yourself.
+def useManagedAndroidSdkVersions = false
+if (useManagedAndroidSdkVersions) {
+  useDefaultAndroidSdkVersions()
+} else {
+  buildscript {
+    // Simple helper that allows the root project to override versions declared by this library.
+    ext.safeExtGet = { prop, fallback ->
+      rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+
+    // Ensures backward compatibility
+    ext.getKotlinVersion = {
+      if (ext.has("kotlinVersion")) {
+        ext.kotlinVersion()
+      } else {
+        ext.safeExtGet("kotlinVersion", "1.8.10")
+      }
+    }
+  }
+  project.android {
+    compileSdkVersion safeExtGet("compileSdkVersion", 36)
+    defaultConfig {
+      minSdkVersion safeExtGet("minSdkVersion", 24)
+      targetSdkVersion safeExtGet("targetSdkVersion", 36)
+    }
+  }
+}
+
+android {
+  namespace "red.infinite.reactnativemlkit.barcodescanning"
+  defaultConfig {
+    versionCode 1
+    versionName "0.7.6"
+  }
+  lintOptions {
+    abortOnError false
+  }
+}
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  implementation project(':expo-modules-core')
+  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
+  implementation 'com.google.mlkit:barcode-scanning:17.3.0'
+  implementation project(path: ':infinitered-react-native-mlkit-core')
+}
diff --git a/modules/react-native-mlkit-barcode-scanning/android/src/main/AndroidManifest.xml b/modules/react-native-mlkit-barcode-scanning/android/src/main/AndroidManifest.xml
new file mode 100644
index 00000000..bdae66c8
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/android/src/main/AndroidManifest.xml
@@ -0,0 +1,2 @@
+<manifest>
+</manifest>
diff --git a/modules/react-native-mlkit-barcode-scanning/android/src/main/java/red/infinite/reactnativemlkit/barcodescanning/RNMLKitBarcodeScanner.kt b/modules/react-native-mlkit-barcode-scanning/android/src/main/java/red/infinite/reactnativemlkit/barcodescanning/RNMLKitBarcodeScanner.kt
new file mode 100644
index 00000000..10baf0d1
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/android/src/main/java/red/infinite/reactnativemlkit/barcodescanning/RNMLKitBarcodeScanner.kt
@@ -0,0 +1,40 @@
+package red.infinite.reactnativemlkit.barcodescanning                        
+
+import android.net.Uri
+import com.google.mlkit.vision.common.InputImage
+import com.google.mlkit.vision.barcode.BarcodeScanning
+import com.google.mlkit.vision.barcode.BarcodeScanner
+import expo.modules.kotlin.AppContext
+import kotlinx.coroutines.CompletableDeferred
+import red.infinite.reactnativemlkit.core.RNMLKitImage
+import red.infinite.reactnativemlkit.barcodescanning.RNMLKitBarcodeScannerResult
+import red.infinite.reactnativemlkit.barcodescanning.RNMLKitBarcodeScannerOptions
+
+class RNMLKitBarcodeScanner(options: RNMLKitBarcodeScannerOptions) {
+
+    private var barcodeScanner: BarcodeScanner? = BarcodeScanning.getClient(options.options)
+
+    suspend fun detectInImage(imagePath: String, appContext: AppContext): Result<RNMLKitBarcodeScannerResult> {
+        val result = CompletableDeferred<Result<RNMLKitBarcodeScannerResult>>()
+
+        try {
+            if(appContext.reactContext == null) {
+                val exception = Exception("RNMLKitBarcodeScanner: React Context is null")
+                result.complete(Result.failure(exception))
+                return result.await()
+            }
+
+            var image: InputImage = RNMLKitImage(Uri.parse(imagePath), appContext.reactContext!!).image
+
+            barcodeScanner?.process(image)?.addOnSuccessListener { barcodes ->
+                val expoBarcodes = RNMLKitBarcodeScannerResult(barcodes, imagePath)
+                result.complete(Result.success(expoBarcodes))
+            }?.addOnFailureListener { e ->
+                result.complete(Result.failure(e))
+            }
+        } catch (e: Exception) {
+            result.complete(Result.failure(e))
+        }
+        return result.await()
+    }
+}
diff --git a/modules/react-native-mlkit-barcode-scanning/android/src/main/java/red/infinite/reactnativemlkit/barcodescanning/RNMLKitBarcodeScannerOptions.kt b/modules/react-native-mlkit-barcode-scanning/android/src/main/java/red/infinite/reactnativemlkit/barcodescanning/RNMLKitBarcodeScannerOptions.kt
new file mode 100644
index 00000000..63a06c99
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/android/src/main/java/red/infinite/reactnativemlkit/barcodescanning/RNMLKitBarcodeScannerOptions.kt
@@ -0,0 +1,74 @@
+package red.infinite.reactnativemlkit.barcodescanning
+
+import com.google.mlkit.vision.barcode.BarcodeScannerOptions
+import com.google.mlkit.vision.barcode.common.Barcode
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+
+data class RNMLKitBarcodeScannerOptionsRecord(
+    @Field var barcodeFormats: List<String>? = null,
+    @Field var enableAllPotentialBarcodes: Boolean? = null
+) : Record
+
+class RNMLKitBarcodeScannerOptions(
+    barcodeFormats: List<String>? = null,
+    enableAllPotentialBarcodes: Boolean? = null
+) {
+
+    var barcodeFormats: List<String> = barcodeFormats ?: listOf("all")
+    var enableAllPotentialBarcodes: Boolean = enableAllPotentialBarcodes ?: false
+
+    constructor(record: RNMLKitBarcodeScannerOptionsRecord) : this(
+        barcodeFormats = record.barcodeFormats,
+        enableAllPotentialBarcodes = record.enableAllPotentialBarcodes
+    )
+
+    val record: RNMLKitBarcodeScannerOptionsRecord
+        get() {
+            return RNMLKitBarcodeScannerOptionsRecord(
+                barcodeFormats = this.barcodeFormats,
+                enableAllPotentialBarcodes = this.enableAllPotentialBarcodes
+            )
+        }
+
+    val options: BarcodeScannerOptions
+        get() {
+            val optionsBuilder = if (barcodeFormats.contains("all") || barcodeFormats.isEmpty()) {
+                BarcodeScannerOptions.Builder()
+            } else {
+                val formats = barcodeFormats.map { formatStringToInt(it) }
+                val firstFormat = formats.first()
+                val remainingFormats = formats.drop(1).toIntArray()
+                BarcodeScannerOptions.Builder()
+                    .setBarcodeFormats(firstFormat, *remainingFormats)
+            }
+
+            if (this.enableAllPotentialBarcodes) {
+                optionsBuilder.enableAllPotentialBarcodes()
+            }
+
+            return optionsBuilder.build()
+        }
+
+    companion object {
+        fun formatStringToInt(format: String): Int {
+            return when (format) {
+                "all" -> Barcode.FORMAT_ALL_FORMATS
+                "code128" -> Barcode.FORMAT_CODE_128
+                "code39" -> Barcode.FORMAT_CODE_39
+                "code93" -> Barcode.FORMAT_CODE_93
+                "codaBar" -> Barcode.FORMAT_CODABAR
+                "dataMatrix" -> Barcode.FORMAT_DATA_MATRIX
+                "EAN13" -> Barcode.FORMAT_EAN_13
+                "EAN8" -> Barcode.FORMAT_EAN_8
+                "ITF" -> Barcode.FORMAT_ITF
+                "PDF417" -> Barcode.FORMAT_PDF417
+                "qrCode" -> Barcode.FORMAT_QR_CODE
+                "UPCA" -> Barcode.FORMAT_UPC_A
+                "UPCE" -> Barcode.FORMAT_UPC_E
+                "AZTEC" -> Barcode.FORMAT_AZTEC
+                else -> Barcode.FORMAT_ALL_FORMATS
+            }
+        }
+    }
+}
diff --git a/modules/react-native-mlkit-barcode-scanning/android/src/main/java/red/infinite/reactnativemlkit/barcodescanning/RNMLKitBarcodeScannerResult.kt b/modules/react-native-mlkit-barcode-scanning/android/src/main/java/red/infinite/reactnativemlkit/barcodescanning/RNMLKitBarcodeScannerResult.kt
new file mode 100644
index 00000000..453098ec
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/android/src/main/java/red/infinite/reactnativemlkit/barcodescanning/RNMLKitBarcodeScannerResult.kt
@@ -0,0 +1,340 @@
+package red.infinite.reactnativemlkit.barcodescanning
+
+import android.graphics.Point
+import expo.modules.kotlin.records.Record
+import expo.modules.kotlin.records.Field
+import com.google.mlkit.vision.barcode.common.Barcode
+import red.infinite.reactnativemlkit.core.RNMLKitRect
+import red.infinite.reactnativemlkit.core.RNMLKitPoint
+
+data class RNMLKitBarcodeScannerResultRecord(
+    @Field var barcodes: List<RNMLKitBarcode> = mutableListOf(),
+    @Field var imagePath: String
+) : Record
+
+class RNMLKitBarcodeScannerResult(private val barcodes: List<Barcode>, private val imagePath: String) {
+    val record: RNMLKitBarcodeScannerResultRecord
+        get() = RNMLKitBarcodeScannerResultRecord(
+            barcodes = barcodes.map { barcode -> RNMLKitBarcode.fromBarcode(barcode) },
+            imagePath = imagePath
+        )
+}
+
+data class RNMLKitBarcode(
+    @Field var frame: RNMLKitRect = RNMLKitRect.zero(),
+    @Field var rawValue: String? = null,
+    @Field var rawData: List<Int>? = null,
+    @Field var displayValue: String? = null,
+    @Field var format: String = "unknown",
+    @Field var cornerPoints: List<RNMLKitPoint> = emptyList(),
+    @Field var valueType: String = "UNKNOWN",
+    @Field var email: RNMLKitBarcodeEmail? = null,
+    @Field var phone: RNMLKitBarcodePhone? = null,
+    @Field var sms: RNMLKitBarcodeSMS? = null,
+    @Field var url: RNMLKitBarcodeURL? = null,
+    @Field var wifi: RNMLKitBarcodeWifi? = null,
+    @Field var geoPoint: RNMLKitBarcodeGeoPoint? = null,
+    @Field var contactInfo: RNMLKitBarcodeContactInfo? = null,
+    @Field var calendarEvent: RNMLKitBarcodeCalendarEvent? = null,
+    @Field var driverLicense: RNMLKitBarcodeDriverLicense? = null
+) : Record {
+    companion object {
+        fun fromBarcode(barcode: Barcode): RNMLKitBarcode {
+            return RNMLKitBarcode(
+                frame = barcode.boundingBox?.let { RNMLKitRect.fromRect(it) } ?: RNMLKitRect.zero(),
+                rawValue = barcode.rawValue,
+                rawData = barcode.rawBytes?.map { it.toInt() },
+                displayValue = barcode.displayValue,
+                format = formatIntToString(barcode.format),
+                cornerPoints = barcode.cornerPoints?.map { point ->
+                    RNMLKitPoint(point.x.toFloat(), point.y.toFloat())
+                } ?: emptyList(),
+                valueType = valueTypeIntToString(barcode.valueType),
+                email = barcode.email?.let { RNMLKitBarcodeEmail.fromEmail(it) },
+                phone = barcode.phone?.let { RNMLKitBarcodePhone.fromPhone(it) },
+                sms = barcode.sms?.let { RNMLKitBarcodeSMS.fromSms(it) },
+                url = barcode.url?.let { RNMLKitBarcodeURL.fromUrl(it) },
+                wifi = barcode.wifi?.let { RNMLKitBarcodeWifi.fromWifi(it) },
+                geoPoint = barcode.geoPoint?.let { RNMLKitBarcodeGeoPoint.fromGeoPoint(it) },
+                contactInfo = barcode.contactInfo?.let { RNMLKitBarcodeContactInfo.fromContactInfo(it) },
+                calendarEvent = barcode.calendarEvent?.let { RNMLKitBarcodeCalendarEvent.fromCalendarEvent(it) },
+                driverLicense = barcode.driverLicense?.let { RNMLKitBarcodeDriverLicense.fromDriverLicense(it) }
+            )
+        }
+
+        fun formatIntToString(format: Int): String {
+            return when (format) {
+                Barcode.FORMAT_ALL_FORMATS -> "all"
+                Barcode.FORMAT_CODE_128 -> "code128"
+                Barcode.FORMAT_CODE_39 -> "code39"
+                Barcode.FORMAT_CODE_93 -> "code93"
+                Barcode.FORMAT_CODABAR -> "codaBar"
+                Barcode.FORMAT_DATA_MATRIX -> "dataMatrix"
+                Barcode.FORMAT_EAN_13 -> "EAN13"
+                Barcode.FORMAT_EAN_8 -> "EAN8"
+                Barcode.FORMAT_ITF -> "ITF"
+                Barcode.FORMAT_PDF417 -> "PDF417"
+                Barcode.FORMAT_QR_CODE -> "qrCode"
+                Barcode.FORMAT_UPC_A -> "UPCA"
+                Barcode.FORMAT_UPC_E -> "UPCE"
+                Barcode.FORMAT_AZTEC -> "AZTEC"
+                else -> "unknown"
+            }
+        }
+
+        fun valueTypeIntToString(valueType: Int): String {
+            return when (valueType) {
+                Barcode.TYPE_UNKNOWN -> "UNKNOWN"
+                Barcode.TYPE_CONTACT_INFO -> "CONTACT_INFO"
+                Barcode.TYPE_EMAIL -> "EMAIL"
+                Barcode.TYPE_ISBN -> "ISBN"
+                Barcode.TYPE_PHONE -> "PHONE"
+                Barcode.TYPE_PRODUCT -> "PRODUCT"
+                Barcode.TYPE_SMS -> "SMS"
+                Barcode.TYPE_TEXT -> "TEXT"
+                Barcode.TYPE_URL -> "URL"
+                Barcode.TYPE_WIFI -> "WIFI"
+                Barcode.TYPE_GEO -> "GEO"
+                Barcode.TYPE_DRIVER_LICENSE -> "DRIVER_LICENSE"
+                Barcode.TYPE_CALENDAR_EVENT -> "CALENDAR_EVENT"
+                else -> "UNKNOWN"
+            }
+        }
+    }
+}
+
+data class RNMLKitBarcodeEmail(
+    @Field var address: String? = null,
+    @Field var body: String? = null,
+    @Field var subject: String? = null,
+    @Field var type: String = "UNKNOWN"
+) : Record {
+    companion object {
+        fun fromEmail(email: Barcode.Email): RNMLKitBarcodeEmail {
+            return RNMLKitBarcodeEmail(
+                address = email.address,
+                body = email.body,
+                subject = email.subject,
+                type = when (email.type) {
+                    Barcode.Email.TYPE_HOME -> "HOME"
+                    Barcode.Email.TYPE_WORK -> "WORK"
+                    else -> "UNKNOWN"
+                }
+            )
+        }
+    }
+}
+
+data class RNMLKitBarcodePhone(
+    @Field var number: String? = null,
+    @Field var type: String = "UNKNOWN"
+) : Record {
+    companion object {
+        fun fromPhone(phone: Barcode.Phone): RNMLKitBarcodePhone {
+            return RNMLKitBarcodePhone(
+                number = phone.number,
+                type = when (phone.type) {
+                    Barcode.Phone.TYPE_HOME -> "HOME"
+                    Barcode.Phone.TYPE_WORK -> "WORK"
+                    Barcode.Phone.TYPE_FAX -> "FAX"
+                    Barcode.Phone.TYPE_MOBILE -> "MOBILE"
+                    else -> "UNKNOWN"
+                }
+            )
+        }
+    }
+}
+
+data class RNMLKitBarcodeSMS(
+    @Field var message: String? = null,
+    @Field var phoneNumber: String? = null
+) : Record {
+    companion object {
+        fun fromSms(sms: Barcode.Sms): RNMLKitBarcodeSMS {
+            return RNMLKitBarcodeSMS(
+                message = sms.message,
+                phoneNumber = sms.phoneNumber
+            )
+        }
+    }
+}
+
+data class RNMLKitBarcodeURL(
+    @Field var title: String? = null,
+    @Field var url: String? = null
+) : Record {
+    companion object {
+        fun fromUrl(url: Barcode.UrlBookmark): RNMLKitBarcodeURL {
+            return RNMLKitBarcodeURL(
+                title = url.title,
+                url = url.url
+            )
+        }
+    }
+}
+
+data class RNMLKitBarcodeWifi(
+    @Field var ssid: String? = null,
+    @Field var password: String? = null,
+    @Field var type: String = "OPEN"
+) : Record {
+    companion object {
+        fun fromWifi(wifi: Barcode.WiFi): RNMLKitBarcodeWifi {
+            return RNMLKitBarcodeWifi(
+                ssid = wifi.ssid,
+                password = wifi.password,
+                type = when (wifi.encryptionType) {
+                    Barcode.WiFi.TYPE_WPA -> "WPA"
+                    Barcode.WiFi.TYPE_WEP -> "WEP"
+                    else -> "OPEN"
+                }
+            )
+        }
+    }
+}
+
+data class RNMLKitBarcodeGeoPoint(
+    @Field var latitude: Double = 0.0,
+    @Field var longitude: Double = 0.0
+) : Record {
+    companion object {
+        fun fromGeoPoint(geoPoint: Barcode.GeoPoint): RNMLKitBarcodeGeoPoint {
+            return RNMLKitBarcodeGeoPoint(
+                latitude = geoPoint.lat,
+                longitude = geoPoint.lng
+            )
+        }
+    }
+}
+
+data class RNMLKitBarcodeAddress(
+    @Field var addressLines: List<String>? = null,
+    @Field var type: String = "UNKNOWN"
+) : Record {
+    companion object {
+        fun fromAddress(address: Barcode.Address): RNMLKitBarcodeAddress {
+            return RNMLKitBarcodeAddress(
+                addressLines = address.addressLines?.toList(),
+                type = when (address.type) {
+                    Barcode.Address.TYPE_HOME -> "HOME"
+                    Barcode.Address.TYPE_WORK -> "WORK"
+                    else -> "UNKNOWN"
+                }
+            )
+        }
+    }
+}
+
+data class RNMLKitBarcodePersonName(
+    @Field var formattedName: String? = null,
+    @Field var first: String? = null,
+    @Field var last: String? = null,
+    @Field var middle: String? = null,
+    @Field var prefix: String? = null,
+    @Field var pronunciation: String? = null,
+    @Field var suffix: String? = null
+) : Record {
+    companion object {
+        fun fromPersonName(name: Barcode.PersonName): RNMLKitBarcodePersonName {
+            return RNMLKitBarcodePersonName(
+                formattedName = name.formattedName,
+                first = name.first,
+                last = name.last,
+                middle = name.middle,
+                prefix = name.prefix,
+                pronunciation = name.pronunciation,
+                suffix = name.suffix
+            )
+        }
+    }
+}
+
+data class RNMLKitBarcodeContactInfo(
+    @Field var addresses: List<RNMLKitBarcodeAddress>? = null,
+    @Field var emails: List<RNMLKitBarcodeEmail>? = null,
+    @Field var name: RNMLKitBarcodePersonName? = null,
+    @Field var phones: List<RNMLKitBarcodePhone>? = null,
+    @Field var urls: List<String>? = null,
+    @Field var jobTitle: String? = null,
+    @Field var organization: String? = null
+) : Record {
+    companion object {
+        fun fromContactInfo(contactInfo: Barcode.ContactInfo): RNMLKitBarcodeContactInfo {
+            return RNMLKitBarcodeContactInfo(
+                addresses = contactInfo.addresses?.map { RNMLKitBarcodeAddress.fromAddress(it) },
+                emails = contactInfo.emails?.map { RNMLKitBarcodeEmail.fromEmail(it) },
+                name = contactInfo.name?.let { RNMLKitBarcodePersonName.fromPersonName(it) },
+                phones = contactInfo.phones?.map { RNMLKitBarcodePhone.fromPhone(it) },
+                urls = contactInfo.urls?.toList(),
+                jobTitle = contactInfo.title,
+                organization = contactInfo.organization
+            )
+        }
+    }
+}
+
+data class RNMLKitBarcodeCalendarEvent(
+    @Field var eventDescription: String? = null,
+    @Field var location: String? = null,
+    @Field var organizer: String? = null,
+    @Field var status: String? = null,
+    @Field var summary: String? = null,
+    @Field var start: Long? = null,
+    @Field var end: Long? = null
+) : Record {
+    companion object {
+        fun fromCalendarEvent(event: Barcode.CalendarEvent): RNMLKitBarcodeCalendarEvent {
+            return RNMLKitBarcodeCalendarEvent(
+                eventDescription = event.description,
+                location = event.location,
+                organizer = event.organizer,
+                status = event.status,
+                summary = event.summary,
+                start = event.start?.let { calendarDateTimeToMillis(it) },
+                end = event.end?.let { calendarDateTimeToMillis(it) }
+            )
+        }
+
+        private fun calendarDateTimeToMillis(dateTime: Barcode.CalendarDateTime): Long {
+            val calendar = java.util.Calendar.getInstance()
+            calendar.set(dateTime.year, dateTime.month - 1, dateTime.day, dateTime.hours, dateTime.minutes, dateTime.seconds)
+            return calendar.timeInMillis
+        }
+    }
+}
+
+data class RNMLKitBarcodeDriverLicense(
+    @Field var firstName: String? = null,
+    @Field var middleName: String? = null,
+    @Field var lastName: String? = null,
+    @Field var gender: String? = null,
+    @Field var addressCity: String? = null,
+    @Field var addressState: String? = null,
+    @Field var addressStreet: String? = null,
+    @Field var addressZip: String? = null,
+    @Field var birthDate: String? = null,
+    @Field var documentType: String? = null,
+    @Field var expiryDate: String? = null,
+    @Field var issuingDate: String? = null,
+    @Field var issuingCountry: String? = null
+) : Record {
+    companion object {
+        fun fromDriverLicense(license: Barcode.DriverLicense): RNMLKitBarcodeDriverLicense {
+            return RNMLKitBarcodeDriverLicense(
+                firstName = license.firstName,
+                middleName = license.middleName,
+                lastName = license.lastName,
+                gender = license.gender,
+                addressCity = license.addressCity,
+                addressState = license.addressState,
+                addressStreet = license.addressStreet,
+                addressZip = license.addressZip,
+                birthDate = license.birthDate,
+                documentType = license.documentType,
+                expiryDate = license.expiryDate,
+                issuingDate = license.issueDate,
+                issuingCountry = license.issuingCountry
+            )
+        }
+    }
+}
diff --git a/modules/react-native-mlkit-barcode-scanning/android/src/main/java/red/infinite/reactnativemlkit/barcodescanning/RNMLKitBarcodeScanningModule.kt b/modules/react-native-mlkit-barcode-scanning/android/src/main/java/red/infinite/reactnativemlkit/barcodescanning/RNMLKitBarcodeScanningModule.kt
new file mode 100644
index 00000000..fcba417b
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/android/src/main/java/red/infinite/reactnativemlkit/barcodescanning/RNMLKitBarcodeScanningModule.kt
@@ -0,0 +1,57 @@
+package red.infinite.reactnativemlkit.barcodescanning
+
+import android.net.Uri
+
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import kotlinx.coroutines.runBlocking
+import red.infinite.reactnativemlkit.core.RNMLKitModule
+
+class RNMLKitBarcodeScanningModule : RNMLKitModule("RNMLKitBarcodeScanning") {
+  private var barcodeScanner: RNMLKitBarcodeScanner? = null
+  // Each module class must implement the definition function. The definition consists of components
+  // that describes the module's functionality and behavior.
+  // See https://docs.expo.dev/modules/module-api for more details about available components.
+  override fun definition() = ModuleDefinition {
+    // Sets the name of the module that JavaScript code will use to refer to the module. Takes a string as an argument.
+    // Can be inferred from module's class name, but it's recommended to set it explicitly for clarity.
+    // The module will be accessible from `requireNativeModule('RNMLKitBarcodeScanning')` in JavaScript.
+    Name("RNMLKitBarcodeScanning")
+
+
+    AsyncFunction("initialize") { options: RNMLKitBarcodeScannerOptionsRecord, promise: Promise ->
+        log.d("initialize: Initializing Barcode Scanner")
+        val scannerOptions = RNMLKitBarcodeScannerOptions(options)
+        barcodeScanner = RNMLKitBarcodeScanner(scannerOptions)
+        log.d("initialize: Barcode Scanner initialized")
+        promise.resolve(null)
+    }
+
+    // Defines a JavaScript function that always returns a Promise and whose native code
+    // is by default dispatched on the different thread than the JavaScript runtime runs on.
+    AsyncFunction("process") { imagePath: String, promise: Promise ->
+      val imageUri = Uri.parse(imagePath)
+
+      runBlocking suspend@{
+        val barcodeScanner = barcodeScanner
+        if (barcodeScanner == null) {
+          handleException(promise, message = "Barcode Scanner not initialized")
+          return@suspend
+        }
+        try {
+          var result =
+              barcodeScanner.detectInImage(imagePath, appContext).getOrElse {
+                handleException(promise, it)
+                throw it
+              }
+          promise.resolve(result.record)
+        } catch (e: Exception) {
+          handleException(promise, e)
+        }
+
+      }
+    }
+  }
+}
diff --git a/modules/react-native-mlkit-barcode-scanning/babel.config.js b/modules/react-native-mlkit-barcode-scanning/babel.config.js
new file mode 100644
index 00000000..d089e047
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/babel.config.js
@@ -0,0 +1,5 @@
+// babel.config.js
+module.exports = {
+  presets: ["module:@react-native/babel-preset"],
+  plugins: [["@babel/plugin-transform-private-methods", { loose: true }]],
+};
diff --git a/modules/react-native-mlkit-barcode-scanning/expo-module.config.json b/modules/react-native-mlkit-barcode-scanning/expo-module.config.json
new file mode 100644
index 00000000..7bcb8bf3
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/expo-module.config.json
@@ -0,0 +1,9 @@
+{
+  "platforms": ["ios", "android", "web"],
+  "apple": {
+    "modules": ["RNMLKitBarcodeScanningModule"]
+  },
+  "android": {
+    "modules": ["red.infinite.reactnativemlkit.barcodescanning.RNMLKitBarcodeScanningModule"]
+  }
+}
diff --git a/modules/react-native-mlkit-barcode-scanning/index.ts b/modules/react-native-mlkit-barcode-scanning/index.ts
new file mode 100644
index 00000000..a8269f6f
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/index.ts
@@ -0,0 +1,4 @@
+// Reexport the native module. On web, it will be resolved to RNMLKitBarcodeScanningModule.web.ts
+// and on native platforms to RNMLKitBarcodeScanningModule.ts
+export { default } from "./src/RNMLKitBarcodeScanningModule";
+export * from "./src/RNMLKitBarcodeScanning.types";
diff --git a/modules/react-native-mlkit-barcode-scanning/ios/RNMLKitBarcodeScannerOptions.swift b/modules/react-native-mlkit-barcode-scanning/ios/RNMLKitBarcodeScannerOptions.swift
new file mode 100644
index 00000000..289e0079
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/ios/RNMLKitBarcodeScannerOptions.swift
@@ -0,0 +1,45 @@
+import ExpoModulesCore
+import MLKitBarcodeScanning
+
+struct RNMLKitBarcodeScannerOptionsRecord: Record {
+    @Field
+    var barcodeFormats: [String]? = nil
+
+    @Field
+    var enableAllPotentialBarcodes: Bool? = nil
+}
+
+func formatStringToBarcodeFormat(_ format: String) -> BarcodeFormat {
+    switch format {
+    case "all": return .all
+    case "code128": return .code128
+    case "code39": return .code39
+    case "code93": return .code93
+    case "codaBar": return .codaBar
+    case "dataMatrix": return .dataMatrix
+    case "EAN13": return .EAN13
+    case "EAN8": return .EAN8
+    case "ITF": return .ITF
+    case "PDF417": return .PDF417
+    case "qrCode": return .qrCode
+    case "UPCA": return .UPCA
+    case "UPCE": return .UPCE
+    case "AZTEC": return .aztec
+    default: return .all
+    }
+}
+
+func buildBarcodeScannerOptions(from record: RNMLKitBarcodeScannerOptionsRecord) -> BarcodeScannerOptions {
+    let formats = record.barcodeFormats ?? ["all"]
+
+    var combinedFormats: BarcodeFormat = []
+    if formats.contains("all") || formats.isEmpty {
+        combinedFormats = .all
+    } else {
+        for format in formats {
+            combinedFormats.insert(formatStringToBarcodeFormat(format))
+        }
+    }
+
+    return BarcodeScannerOptions(formats: combinedFormats)
+}
diff --git a/modules/react-native-mlkit-barcode-scanning/ios/RNMLKitBarcodeScannerResult.swift b/modules/react-native-mlkit-barcode-scanning/ios/RNMLKitBarcodeScannerResult.swift
new file mode 100644
index 00000000..e45689e5
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/ios/RNMLKitBarcodeScannerResult.swift
@@ -0,0 +1,521 @@
+//
+//  RNMLKitBarcodeScannerResult.swift
+//  RNMLKitBarcodeScanning
+//
+
+import ExpoModulesCore
+import Foundation
+import MLKitBarcodeScanning
+import MLKitVision
+
+// MARK: - Main Result
+
+struct RNMLKitBarcodeScannerResultRecord: Record {
+    @Field
+    var barcodes: [RNMLKitBarcode] = []
+}
+
+public class RNMLKitBarcodeScannerResult {
+    var barcodes: [MLKitBarcodeScanning.Barcode]
+
+    init(barcodes: [MLKitBarcodeScanning.Barcode]) {
+        self.barcodes = barcodes
+    }
+
+    var record: RNMLKitBarcodeScannerResultRecord {
+        let result = RNMLKitBarcodeScannerResultRecord()
+        result.barcodes = self.barcodes.map { barcode in
+            RNMLKitBarcode.from(barcode: barcode)
+        }
+        return result
+    }
+}
+
+// MARK: - Barcode
+
+struct RNMLKitBarcode: Record {
+    @Field
+    var frame: RNMLKitRect = .init()
+    @Field
+    var rawValue: String?
+    @Field
+    var rawData: [Int]?
+    @Field
+    var displayValue: String?
+    @Field
+    var format: String = ""
+    @Field
+    var cornerPoints: [RNMLKitPoint] = []
+    @Field
+    var valueType: String = ""
+    @Field
+    var email: RNMLKitBarcodeEmail?
+    @Field
+    var phone: RNMLKitBarcodePhone?
+    @Field
+    var sms: RNMLKitBarcodeSMS?
+    @Field
+    var url: RNMLKitBarcodeURLBookmark?
+    @Field
+    var wifi: RNMLKitBarcodeWifi?
+    @Field
+    var geoPoint: RNMLKitBarcodeGeoPoint?
+    @Field
+    var contactInfo: RNMLKitBarcodeContactInfo?
+    @Field
+    var calendarEvent: RNMLKitBarcodeCalendarEvent?
+    @Field
+    var driverLicense: RNMLKitBarcodeDriverLicense?
+
+    static func from(barcode: MLKitBarcodeScanning.Barcode) -> RNMLKitBarcode {
+        var result = RNMLKitBarcode()
+
+        result.frame = RNMLKitRect.fromCGRect(rect: barcode.frame)
+        result.rawValue = barcode.rawValue
+        result.rawData = barcode.rawData.map { [UInt8]($0).map { Int($0) } }
+        result.displayValue = barcode.displayValue
+        result.format = formatToString(barcode.format)
+        result.cornerPoints = barcode.cornerPoints?.map { point in
+            RNMLKitPoint.fromNSValue(point: point)
+        } ?? []
+        result.valueType = valueTypeToString(barcode.valueType)
+
+        // Convert nested objects if present
+        if let email = barcode.email {
+            result.email = RNMLKitBarcodeEmail.from(email: email)
+        }
+
+        if let phone = barcode.phone {
+            result.phone = RNMLKitBarcodePhone.from(phone: phone)
+        }
+
+        if let sms = barcode.sms {
+            result.sms = RNMLKitBarcodeSMS.from(sms: sms)
+        }
+
+        if let urlBookmark = barcode.url {
+            result.url = RNMLKitBarcodeURLBookmark.from(url: urlBookmark)
+        }
+
+        if let wifi = barcode.wifi {
+            result.wifi = RNMLKitBarcodeWifi.from(wifi: wifi)
+        }
+
+        if let geoPoint = barcode.geoPoint {
+            result.geoPoint = RNMLKitBarcodeGeoPoint.from(geoPoint: geoPoint)
+        }
+
+        if let contactInfo = barcode.contactInfo {
+            result.contactInfo = RNMLKitBarcodeContactInfo.from(contactInfo: contactInfo)
+        }
+
+        if let calendarEvent = barcode.calendarEvent {
+            result.calendarEvent = RNMLKitBarcodeCalendarEvent.from(calendarEvent: calendarEvent)
+        }
+
+        if let driverLicense = barcode.driverLicense {
+            result.driverLicense = RNMLKitBarcodeDriverLicense.from(driverLicense: driverLicense)
+        }
+
+        return result
+    }
+
+    static func formatToString(_ format: BarcodeFormat) -> String {
+        if format.contains(.code128) { return "CODE_128" }
+        if format.contains(.code39) { return "CODE_39" }
+        if format.contains(.code93) { return "CODE_93" }
+        if format.contains(.codaBar) { return "CODABAR" }
+        if format.contains(.dataMatrix) { return "DATA_MATRIX" }
+        if format.contains(.EAN13) { return "EAN_13" }
+        if format.contains(.EAN8) { return "EAN_8" }
+        if format.contains(.ITF) { return "ITF" }
+        if format.contains(.qrCode) { return "QR_CODE" }
+        if format.contains(.UPCA) { return "UPC_A" }
+        if format.contains(.UPCE) { return "UPC_E" }
+        if format.contains(.PDF417) { return "PDF417" }
+        if format.contains(.aztec) { return "AZTEC" }
+        return "UNKNOWN"
+    }
+
+    static func valueTypeToString(_ valueType: BarcodeValueType) -> String {
+        switch valueType {
+        case .contactInfo: return "CONTACT_INFO"
+        case .email: return "EMAIL"
+        case .ISBN: return "ISBN"
+        case .phone: return "PHONE"
+        case .product: return "PRODUCT"
+        case .SMS: return "SMS"
+        case .text: return "TEXT"
+        case .URL: return "URL"
+        case .wiFi: return "WIFI"
+        case .geographicCoordinates: return "GEO"
+        case .calendarEvent: return "CALENDAR_EVENT"
+        case .driversLicense: return "DRIVER_LICENSE"
+        default: return "UNKNOWN"
+        }
+    }
+}
+
+// MARK: - Email
+
+struct RNMLKitBarcodeEmail: Record {
+    @Field
+    var address: String?
+    @Field
+    var body: String?
+    @Field
+    var subject: String?
+    @Field
+    var type: String = "UNKNOWN"
+
+    static func from(email: BarcodeEmail) -> RNMLKitBarcodeEmail {
+        let result = RNMLKitBarcodeEmail()
+        result.address = email.address
+        result.body = email.body
+        result.subject = email.subject
+        result.type = emailTypeToString(email.type)
+        return result
+    }
+
+    static func emailTypeToString(_ type: BarcodeEmailType) -> String {
+        switch type {
+        case .work: return "WORK"
+        case .home: return "HOME"
+        default: return "UNKNOWN"
+        }
+    }
+}
+
+// MARK: - Phone
+
+struct RNMLKitBarcodePhone: Record {
+    @Field
+    var number: String?
+    @Field
+    var type: String = "UNKNOWN"
+
+    static func from(phone: BarcodePhone) -> RNMLKitBarcodePhone {
+        let result = RNMLKitBarcodePhone()
+        result.number = phone.number
+        result.type = phoneTypeToString(phone.type)
+        return result
+    }
+
+    static func phoneTypeToString(_ type: BarcodePhoneType) -> String {
+        switch type {
+        case .work: return "WORK"
+        case .home: return "HOME"
+        case .fax: return "FAX"
+        case .mobile: return "MOBILE"
+        default: return "UNKNOWN"
+        }
+    }
+}
+
+// MARK: - SMS
+
+struct RNMLKitBarcodeSMS: Record {
+    @Field
+    var message: String?
+    @Field
+    var phoneNumber: String?
+
+    static func from(sms: BarcodeSMS) -> RNMLKitBarcodeSMS {
+        let result = RNMLKitBarcodeSMS()
+        result.message = sms.message
+        result.phoneNumber = sms.phoneNumber
+        return result
+    }
+}
+
+// MARK: - URL Bookmark
+
+struct RNMLKitBarcodeURLBookmark: Record {
+    @Field
+    var title: String?
+    @Field
+    var url: String?
+
+    static func from(url: BarcodeURLBookmark) -> RNMLKitBarcodeURLBookmark {
+        let result = RNMLKitBarcodeURLBookmark()
+        result.title = url.title
+        result.url = url.url
+        return result
+    }
+}
+
+// MARK: - WiFi
+
+struct RNMLKitBarcodeWifi: Record {
+    @Field
+    var ssid: String?
+    @Field
+    var password: String?
+    @Field
+    var type: String = "OPEN"
+
+    static func from(wifi: BarcodeWifi) -> RNMLKitBarcodeWifi {
+        let result = RNMLKitBarcodeWifi()
+        result.ssid = wifi.ssid
+        result.password = wifi.password
+        result.type = wifiEncryptionTypeToString(wifi.type)
+        return result
+    }
+
+    static func wifiEncryptionTypeToString(_ type: BarcodeWiFiEncryptionType) -> String {
+        switch type {
+        case .open: return "OPEN"
+        case .WPA: return "WPA"
+        case .WEP: return "WEP"
+        default: return "OPEN"
+        }
+    }
+}
+
+// MARK: - Geo Point
+
+struct RNMLKitBarcodeGeoPoint: Record {
+    @Field
+    var latitude: Double = 0.0
+    @Field
+    var longitude: Double = 0.0
+
+    static func from(geoPoint: BarcodeGeoPoint) -> RNMLKitBarcodeGeoPoint {
+        let result = RNMLKitBarcodeGeoPoint()
+        result.latitude = geoPoint.latitude
+        result.longitude = geoPoint.longitude
+        return result
+    }
+}
+
+// MARK: - Address
+
+struct RNMLKitBarcodeAddress: Record {
+    @Field
+    var addressLines: [String] = []
+    @Field
+    var type: String = "UNKNOWN"
+
+    static func from(address: BarcodeAddress) -> RNMLKitBarcodeAddress {
+        let result = RNMLKitBarcodeAddress()
+        result.addressLines = address.addressLines ?? []
+        result.type = addressTypeToString(address.type)
+        return result
+    }
+
+    static func addressTypeToString(_ type: BarcodeAddressType) -> String {
+        switch type {
+        case .work: return "WORK"
+        case .home: return "HOME"
+        default: return "UNKNOWN"
+        }
+    }
+}
+
+// MARK: - Person Name
+
+struct RNMLKitBarcodePersonName: Record {
+    @Field
+    var formattedName: String?
+    @Field
+    var first: String?
+    @Field
+    var last: String?
+    @Field
+    var middle: String?
+    @Field
+    var prefix: String?
+    @Field
+    var pronunciation: String?
+    @Field
+    var suffix: String?
+
+    static func from(name: BarcodePersonName) -> RNMLKitBarcodePersonName {
+        let result = RNMLKitBarcodePersonName()
+        result.formattedName = name.formattedName
+        result.first = name.first
+        result.last = name.last
+        result.middle = name.middle
+        result.prefix = name.prefix
+        result.pronunciation = name.pronunciation
+        result.suffix = name.suffix
+        return result
+    }
+}
+
+// MARK: - Contact Info
+
+struct RNMLKitBarcodeContactInfo: Record {
+    @Field
+    var addresses: [RNMLKitBarcodeAddress]?
+    @Field
+    var emails: [RNMLKitBarcodeEmail]?
+    @Field
+    var name: RNMLKitBarcodePersonName?
+    @Field
+    var phones: [RNMLKitBarcodePhone]?
+    @Field
+    var urls: [String]?
+    @Field
+    var jobTitle: String?
+    @Field
+    var organization: String?
+
+    static func from(contactInfo: BarcodeContactInfo) -> RNMLKitBarcodeContactInfo {
+        var result = RNMLKitBarcodeContactInfo()
+
+        if let addresses = contactInfo.addresses {
+            result.addresses = addresses.map { RNMLKitBarcodeAddress.from(address: $0) }
+        }
+
+        if let emails = contactInfo.emails {
+            result.emails = emails.map { RNMLKitBarcodeEmail.from(email: $0) }
+        }
+
+        if let name = contactInfo.name {
+            result.name = RNMLKitBarcodePersonName.from(name: name)
+        }
+
+        if let phones = contactInfo.phones {
+            result.phones = phones.map { RNMLKitBarcodePhone.from(phone: $0) }
+        }
+
+        result.urls = contactInfo.urls
+        result.jobTitle = contactInfo.jobTitle
+        result.organization = contactInfo.organization
+
+        return result
+    }
+}
+
+// MARK: - Calendar Event
+
+struct RNMLKitBarcodeCalendarEvent: Record {
+    @Field
+    var eventDescription: String?
+    @Field
+    var location: String?
+    @Field
+    var organizer: String?
+    @Field
+    var status: String?
+    @Field
+    var summary: String?
+    @Field
+    var start: String?
+    @Field
+    var end: String?
+
+    static func from(calendarEvent: BarcodeCalendarEvent) -> RNMLKitBarcodeCalendarEvent {
+        let result = RNMLKitBarcodeCalendarEvent()
+        result.eventDescription = calendarEvent.eventDescription
+        result.location = calendarEvent.location
+        result.organizer = calendarEvent.organizer
+        result.status = calendarEvent.status
+        result.summary = calendarEvent.summary
+
+        // Convert dates to ISO8601 strings if present
+        if let start = calendarEvent.start {
+            result.start = ISO8601DateFormatter().string(from: start)
+        }
+        if let end = calendarEvent.end {
+            result.end = ISO8601DateFormatter().string(from: end)
+        }
+
+        return result
+    }
+}
+
+// MARK: - Driver License
+
+struct RNMLKitBarcodeDriverLicense: Record {
+    @Field
+    var addressCity: String?
+    @Field
+    var addressState: String?
+    @Field
+    var addressStreet: String?
+    @Field
+    var addressZip: String?
+    @Field
+    var birthDate: String?
+    @Field
+    var documentType: String?
+    @Field
+    var expiryDate: String?
+    @Field
+    var firstName: String?
+    @Field
+    var gender: String?
+    @Field
+    var issuingCountry: String?
+    @Field
+    var issuingDate: String?
+    @Field
+    var lastName: String?
+    @Field
+    var licenseNumber: String?
+    @Field
+    var middleName: String?
+
+    static func from(driverLicense: BarcodeDriverLicense) -> RNMLKitBarcodeDriverLicense {
+        var result = RNMLKitBarcodeDriverLicense()
+        result.addressCity = driverLicense.addressCity
+        result.addressState = driverLicense.addressState
+        result.addressStreet = driverLicense.addressStreet
+        result.addressZip = driverLicense.addressZip
+        result.birthDate = driverLicense.birthDate
+        result.documentType = driverLicense.documentType
+        result.expiryDate = driverLicense.expiryDate
+        result.firstName = driverLicense.firstName
+        result.gender = driverLicense.gender
+        result.issuingCountry = driverLicense.issuingCountry
+        result.issuingDate = driverLicense.issuingDate
+        result.lastName = driverLicense.lastName
+        result.licenseNumber = driverLicense.licenseNumber
+        result.middleName = driverLicense.middleName
+
+        return result
+    }
+}
+
+// MARK: - Helper Types from Core
+
+struct RNMLKitPoint: Record {
+    @Field
+    var x: CGFloat = 0
+    @Field
+    var y: CGFloat = 0
+
+    static func fromNSValue(point: NSValue) -> RNMLKitPoint {
+        let cgPoint = point.cgPointValue
+        let result = RNMLKitPoint()
+        result.x = cgPoint.x
+        result.y = cgPoint.y
+        return result
+    }
+}
+
+struct RNMLKitRect: Record {
+    @Field
+    var origin: RNMLKitPoint = RNMLKitPoint()
+    @Field
+    var size: RNMLKitPoint = RNMLKitPoint()
+
+    static func fromCGRect(rect: CGRect) -> RNMLKitRect {
+        var result = RNMLKitRect()
+
+        let origin = RNMLKitPoint()
+        origin.x = rect.origin.x
+        origin.y = rect.origin.y
+
+        let size = RNMLKitPoint()
+        size.x = rect.width
+        size.y = rect.height
+
+        result.origin = origin
+        result.size = size
+
+        return result
+    }
+}
diff --git a/modules/react-native-mlkit-barcode-scanning/ios/RNMLKitBarcodeScanning.podspec b/modules/react-native-mlkit-barcode-scanning/ios/RNMLKitBarcodeScanning.podspec
new file mode 100644
index 00000000..7895dfe5
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/ios/RNMLKitBarcodeScanning.podspec
@@ -0,0 +1,29 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'RNMLKitBarcodeScanning'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platform       = :ios, '15.1'
+  s.swift_version  = '5.4'
+  s.source         = { git: 'http://github.com/infinitered/react-native-mlkit' }
+  s.static_framework = true
+
+  s.dependency 'GoogleMLKit/BarcodeScanning'
+  s.dependency 'ExpoModulesCore'
+  s.dependency 'RNMLKitCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule'
+  }
+
+  s.source_files = "**/*.{h,m,mm,swift,hpp,cpp}"
+end
diff --git a/modules/react-native-mlkit-barcode-scanning/ios/RNMLKitBarcodeScanningModule.swift b/modules/react-native-mlkit-barcode-scanning/ios/RNMLKitBarcodeScanningModule.swift
new file mode 100644
index 00000000..ad949e56
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/ios/RNMLKitBarcodeScanningModule.swift
@@ -0,0 +1,59 @@
+import ExpoModulesCore
+import MLKitBarcodeScanning
+import RNMLKitCore
+
+// TODO: move this to core?
+// Function to reject a promise with a specified message and domain
+func rejectPromiseWithMessage(promise: Promise, message: String, domain: String)
+{
+    promise.reject(
+        NSError(
+            domain: domain, code: 1,
+            userInfo: [NSLocalizedDescriptionKey: message])
+    )
+}
+
+let ERROR_DOMAIN: String =
+    "red.infinite.reactnativemlkit.BarcodeScanningErrorDomain"
+
+public class RNMLKitBarcodeScanningModule: Module {
+    var barcodeScanner: BarcodeScanner? = nil
+
+    public func definition() -> ModuleDefinition {
+        Name("RNMLKitBarcodeScanning")
+
+        AsyncFunction("initialize") { (options: RNMLKitBarcodeScannerOptionsRecord, promise: Promise) in
+            let scannerOptions = buildBarcodeScannerOptions(from: options)
+            self.barcodeScanner = BarcodeScanner.barcodeScanner(options: scannerOptions)
+            promise.resolve(nil)
+        }
+
+        AsyncFunction("process") { (imagePath: String, promise: Promise) in
+            let logger = Logger(logHandlers: [
+                createOSLogHandler(category: Logger.EXPO_LOG_CATEGORY)
+            ])
+
+            Task {
+                do {
+                    guard let barcodeScanner = self.barcodeScanner else {
+                        rejectPromiseWithMessage(
+                            promise: promise,
+                            message:
+                                "[RNMLKitBarcodeScanning.process] Barcode Scanner not initiliazed",
+                            domain: ERROR_DOMAIN)
+                        return
+                    }
+                    let image = try RNMLKitImage(imagePath: imagePath)
+                    let barcodes = try await barcodeScanner.process(image.visionImage)
+
+                    logger.debug(barcodes)
+
+                    let result = RNMLKitBarcodeScannerResult(barcodes: barcodes)
+                    promise.resolve(result.record)
+                } catch {
+                    rejectPromiseWithMessage(promise: promise, message: "[RNMLKitBarcodeScanning.process] Error processing barcode: \(error)", domain: ERROR_DOMAIN)
+                }
+            }
+        }
+    }
+}
diff --git a/modules/react-native-mlkit-barcode-scanning/package.json b/modules/react-native-mlkit-barcode-scanning/package.json
new file mode 100644
index 00000000..9a3c699c
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/package.json
@@ -0,0 +1,47 @@
+{
+  "name": "@infinitered/react-native-mlkit-barcode-scanning",
+  "version": "5.0.0",
+  "description": "MLKit Barcode Scanning for React Native with Expo",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "expo-module build",
+    "ci:build": "tsc",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "../../scripts/test-module.sh",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "react-native-mlkit-barcode-scanning",
+    "RNMLKitBarcodeScanning"
+  ],
+  "repository": "https://www.github.com/infinitered/react-native-mlkit",
+  "bugs": {
+    "url": "https://www.github.com/infinitered/react-native-mlkit/issues"
+  },
+  "author": "Tyler Williams <tyler@infinite.red> (https://www.github.com/coolsoftwaretyler)",
+  "license": "MIT",
+  "homepage": "https://docs.infinite.red/react-native-mlkit/barcode-scanning",
+  "dependencies": {
+    "@infinitered/react-native-mlkit-core": "5.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "~19.1.10",
+    "expo-module-scripts": "^3.4.1",
+    "expo-modules-core": "~3.0.25"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  },
+  "expo": {
+    "autolinking": {
+      "nativeModulesDir": "../../modules"
+    }
+  }
+}
diff --git a/modules/react-native-mlkit-barcode-scanning/src/RNMLKitBarcodeScanning.types.ts b/modules/react-native-mlkit-barcode-scanning/src/RNMLKitBarcodeScanning.types.ts
new file mode 100644
index 00000000..00255562
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/src/RNMLKitBarcodeScanning.types.ts
@@ -0,0 +1,206 @@
+import {
+  RNMLKitRect,
+  RNMLKitPoint,
+} from "@infinitered/react-native-mlkit-core";
+
+export enum BarcodeFormat {
+  ALL = "all",
+  code128 = "code128",
+  code39 = "code39",
+  code93 = "code93",
+  codaBar = "codaBar",
+  dataMatrix = "dataMatrix",
+  EAN13 = "EAN13",
+  EAN8 = "EAN8",
+  ITF = "ITF",
+  qrCode = "qrCode",
+  UPCA = "UPCA",
+  UPCE = "UPCE",
+  PDF417 = "PDF417",
+  aztec = "AZTEC",
+}
+
+/**
+ * Possible value types. Taken from Android API reference:
+ * https://developers.google.com/android/reference/com/google/mlkit/vision/barcode/common/Barcode.BarcodeValueType?hl=en
+ */
+export enum BarcodeValueType {
+  UNKNOWN = "UNKNOWN",
+  CONTACT_INFO = "CONTACT_INFO",
+  EMAIL = "EMAIL",
+  ISBN = "ISBN",
+  PHONE = "PHONE",
+  PRODUCT = "PRODUCT",
+  SMS = "SMS",
+  TEXT = "TEXT",
+  URL = "URL",
+  WIFI = "WIFI",
+  GEO = "GEO",
+  DRIVER_LICENSE = "DRIVER_LICENSE",
+  CALENDAR_EVENT = "CALENDAR_EVENT",
+}
+
+export interface BarcodeScannerOptions {
+  barcodeFormats?: BarcodeFormat[];
+  enableAllPotentialBarcodes?: boolean;
+}
+
+export interface BarcodeScannerResult {
+  barcodes: Barcode[];
+}
+
+/**
+ * RawData is a byte[] in Android, and Data in iOS:
+ * https://developers.google.com/android/reference/com/google/mlkit/vision/barcode/common/Barcode#getRawValue()
+ * https://developers.google.com/ml-kit/reference/swift/mlkitbarcodescanning/api/reference/Classes/Barcode
+ * https://developer.apple.com/documentation/foundation/data
+ */
+export type BarcodeRawData = Uint8Array[];
+
+/**
+ * Possible email types. Taken from Android API reference:
+ * https://developers.google.com/android/reference/com/google/mlkit/vision/barcode/common/Barcode.Email.FormatType
+ */
+export enum BarcodeEmailType {
+  HOME = "HOME",
+  WORK = "WORK",
+  UNKNOWN = "UNKNOWN",
+}
+
+export interface BarcodeEmail {
+  address?: string;
+  body?: string;
+  subject?: string;
+  type: BarcodeEmailType;
+}
+
+/**
+ * Possible phone types. Taken from Android API reference:
+ * https://developers.google.com/android/reference/com/google/mlkit/vision/barcode/common/Barcode.Phone.FormatType
+ */
+export enum BarcodePhoneType {
+  UNKNOWN = "UNKNOWN",
+  WORK = "WORK",
+  HOME = "HOME",
+  FAX = "FAX",
+  MOBILE = "MOBILE",
+}
+
+export interface BarcodePhone {
+  number?: string;
+  type: BarcodePhoneType;
+}
+
+export interface BarcodeSMS {
+  message?: string;
+  phoneNumber?: string;
+}
+
+export interface BarcodeURLBookmark {
+  title?: string;
+  url?: string;
+}
+
+/**
+ * https://developers.google.com/android/reference/com/google/mlkit/vision/barcode/common/Barcode.WiFi.EncryptionType
+ */
+export enum BarcodeWifiEncryptionType {
+  OPEN = "OPEN",
+  WPA = "WPA",
+  WEP = "WEP",
+}
+
+export interface BarcodeWifi {
+  ssid?: string;
+  password?: string;
+  type: BarcodeWifiEncryptionType;
+}
+
+export interface BarcodeGeoPoint {
+  latitude: number;
+  longitude: number;
+}
+
+/**
+ * https://developers.google.com/android/reference/com/google/mlkit/vision/barcode/common/Barcode.Address.AddressType
+ */
+export enum BarcodeAddressType {
+  UNKNOWN = "UNKNOWN",
+  WORK = "WORK",
+  HOME = "HOME",
+}
+
+export interface BarcodeAddress {
+  addressLines?: Array<string>;
+  type: BarcodeAddressType;
+}
+
+export interface BarcodePersonName {
+  formattedName?: string;
+  first?: string;
+  last?: string;
+  middle?: string;
+  prefix?: string;
+  pronunciation?: string;
+  suffix?: string;
+}
+
+export interface BarcodeContactInfo {
+  addresses?: Array<BarcodeAddress>;
+  emails?: Array<BarcodeEmail>;
+  name?: BarcodePersonName;
+  phones?: Array<BarcodePhone>;
+  urls?: Array<string>;
+  jobTitle?: string;
+  organization?: string;
+}
+
+export interface BarcodeCalendarEvent {
+  eventDescription?: string;
+  location?: string;
+  organizer?: string;
+  status?: string;
+  summary?: string;
+  start?: number; // We use an epoch millisecond time stamp to represent the Date field here
+  end?: number; // We use an epoch millisecond time stamp to represent the Date field here
+}
+
+/**
+ * DL for driver's license, ID for ID cards
+ */
+export type BarcodeDriverLicenseDocumentType = "DL" | "ID";
+
+export interface BarcodeDriverLicense {
+  firstName?: string;
+  middleName?: string;
+  lastName?: string;
+  gender?: string;
+  addressCity?: string;
+  addressState?: string;
+  addressStreet?: string;
+  addressZip?: string;
+  birthDate?: string;
+  documentType?: BarcodeDriverLicenseDocumentType;
+  expiryDate?: string;
+  issuingDate?: string;
+  issuingCountry?: string;
+}
+
+export interface Barcode {
+  frame: RNMLKitRect;
+  rawValue?: string;
+  rawData?: BarcodeRawData;
+  displayValue?: string;
+  format: BarcodeFormat;
+  cornerPoints: RNMLKitPoint[];
+  valueType: BarcodeValueType;
+  email?: BarcodeEmail;
+  phone?: BarcodePhone;
+  sms?: BarcodeSMS;
+  url?: BarcodeURLBookmark;
+  wifi?: BarcodeWifi;
+  geoPoint?: BarcodeGeoPoint;
+  contactInfo?: BarcodeContactInfo;
+  calendarEvent?: BarcodeCalendarEvent;
+  driverLicense?: BarcodeDriverLicense;
+}
diff --git a/modules/react-native-mlkit-barcode-scanning/src/RNMLKitBarcodeScanningModule.ts b/modules/react-native-mlkit-barcode-scanning/src/RNMLKitBarcodeScanningModule.ts
new file mode 100644
index 00000000..2665d7dc
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/src/RNMLKitBarcodeScanningModule.ts
@@ -0,0 +1,16 @@
+import { NativeModule, requireNativeModule } from "expo";
+
+import {
+  BarcodeScannerOptions,
+  BarcodeScannerResult,
+} from "./RNMLKitBarcodeScanning.types";
+
+declare class RNMLKitBarcodeScanningModule extends NativeModule {
+  initialize(options: BarcodeScannerOptions): Promise<void>;
+  process(imagePath: string): Promise<BarcodeScannerResult>;
+}
+
+// This call loads the native module object from the JSI.
+export default requireNativeModule<RNMLKitBarcodeScanningModule>(
+  "RNMLKitBarcodeScanning"
+);
diff --git a/modules/react-native-mlkit-barcode-scanning/src/index.test.ts b/modules/react-native-mlkit-barcode-scanning/src/index.test.ts
new file mode 100644
index 00000000..dd21e350
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/src/index.test.ts
@@ -0,0 +1,5 @@
+describe("placeholder test", () => {
+  it("should pass", () => {
+    expect(true).toBe(true);
+  });
+});
diff --git a/modules/react-native-mlkit-barcode-scanning/src/index.ts b/modules/react-native-mlkit-barcode-scanning/src/index.ts
new file mode 100644
index 00000000..0feb259b
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/src/index.ts
@@ -0,0 +1,2 @@
+export { default } from './RNMLKitBarcodeScanningModule';
+export * from './RNMLKitBarcodeScanning.types';
diff --git a/modules/react-native-mlkit-barcode-scanning/tsconfig.json b/modules/react-native-mlkit-barcode-scanning/tsconfig.json
new file mode 100644
index 00000000..af4318d3
--- /dev/null
+++ b/modules/react-native-mlkit-barcode-scanning/tsconfig.json
@@ -0,0 +1,13 @@
+{
+  "extends": "@infinitered/tsconfig/expo-module",
+  "compilerOptions": {
+    "outDir": "./build"
+  },
+  "include": [
+    "./src"
+  ],
+  "exclude": [
+    "**/__mocks__/*",
+    "**/__tests__/*"
+  ]
+}
diff --git a/modules/react-native-mlkit-document-scanner/android/src/main/java/red/infinite/reactnativemlkit/documentscanner/RNMLKitDocumentScannerModule.kt b/modules/react-native-mlkit-document-scanner/android/src/main/java/red/infinite/reactnativemlkit/documentscanner/RNMLKitDocumentScannerModule.kt
index 96f5a364..b8bad1dc 100644
--- a/modules/react-native-mlkit-document-scanner/android/src/main/java/red/infinite/reactnativemlkit/documentscanner/RNMLKitDocumentScannerModule.kt
+++ b/modules/react-native-mlkit-document-scanner/android/src/main/java/red/infinite/reactnativemlkit/documentscanner/RNMLKitDocumentScannerModule.kt
@@ -10,6 +10,9 @@ import expo.modules.kotlin.modules.ModuleDefinition
 import expo.modules.kotlin.Promise
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
 
 
 import red.infinite.reactnativemlkit.documentscanner.contracts.DocumentScannerContract
@@ -20,19 +23,77 @@ import red.infinite.reactnativemlkit.documentscanner.contracts.PdfInfo
 import android.app.Activity
 
 class RNMLKitDocumentScannerModule : Module() {
-      override fun definition() = ModuleDefinition {
+    companion object {
+        private const val TAG = "RNMLKitDocScan"
+        
+        /**
+         * Static storage for pending results that survives activity recreation.
+         * This is necessary because when "Don't keep activities" is enabled,
+         * the activity (and this module instance) is destroyed while the scanner
+         * is running. When the activity is recreated, a new module instance is
+         * created, but we need to access the result stored by the previous instance.
+         */
+        @Volatile
+        private var staticPendingResult: PendingDocumentScannerResult? = null
+        
+        /**
+         * Continuation that will be resumed when a result arrives after activity recreation.
+         * This allows the new coroutine (from a retry) to receive the result that was
+         * stored by handleResultUponActivityDestruction.
+         */
+        @Volatile
+        private var pendingContinuation: kotlin.coroutines.Continuation<DocumentScannerContractResult>? = null
+    }
+
+    override fun definition() = ModuleDefinition {
         Name("RNMLKitDocumentScanner")
 
         // region JS API
 
-        AsyncFunction("launchDocumentScannerAsync") Coroutine { options: RNMLKitDocumentScannerOptions -> 
+        AsyncFunction("launchDocumentScannerAsync") Coroutine { options: RNMLKitDocumentScannerOptions ->
+            // First, check if we have a pending result from a previous activity destruction
+            val pending = consumePendingResult()
+            if (pending != null) {
+                Log.d(TAG, "Returning pending result from activity recreation")
+                return@Coroutine RNMLKitDocumentScannerResponse(
+                    canceled = false,
+                    pages = pending.pages,
+                    pdf = pending.pdf
+                )
+            }
+
             val contractOptions = options.toDocumentScannerContractOptions()
             launchContract({ scannerLauncher.launch(contractOptions) }, options)
         }
+        
+        /**
+         * Check if there's a pending result from a scan that completed while the activity was destroyed.
+         * This can be called by JS on app resume to check if a previous scan completed successfully.
+         */
+        Function("getPendingResult") {
+            val pending = consumePendingResult()
+            if (pending != null) {
+                Log.d(TAG, "getPendingResult: returning pending result")
+                RNMLKitDocumentScannerResponse(
+                    canceled = false,
+                    pages = pending.pages,
+                    pdf = pending.pdf
+                )
+            } else {
+                null
+            }
+        }
+        
+        /**
+         * Check if a scan is potentially pending (activity was destroyed during scan).
+         * This is a lightweight check that doesn't consume the result.
+         */
+        Function("hasPendingResult") {
+            staticPendingResult != null || pendingDocumentScannerResult != null
+        }
 
         // endregion
 
-
         RegisterActivityContracts {
             scannerLauncher = registerForActivityResult(
                 DocumentScannerContract(this@RNMLKitDocumentScannerModule)
@@ -41,15 +102,41 @@ class RNMLKitDocumentScannerModule : Module() {
     }
 
     private lateinit var scannerLauncher: AppContextActivityResultLauncher<DocumentScannerContractOptions, DocumentScannerContractResult>
+    
+    // Instance-level pending result (kept for backwards compatibility)
     private var pendingDocumentScannerResult: PendingDocumentScannerResult? = null
 
-
     private fun handleException(promise: Promise, e: Throwable? = null, message: String? = null) {
         val errorMessage = message ?: "RNMLKitDocScan - Error: ${e?.message}"
-        Log.e("RNMLKitDocScan", "Error: $errorMessage", e)
+        Log.e(TAG, "Error: $errorMessage", e)
         promise.reject(CodedException(errorMessage, e))
     }
 
+    /**
+     * Consumes and returns any pending result from activity recreation.
+     * Returns null if no pending result exists.
+     */
+    private fun consumePendingResult(): PendingDocumentScannerResult? {
+        // Check static storage first (survives activity recreation)
+        val staticResult = staticPendingResult
+        if (staticResult != null) {
+            staticPendingResult = null
+            pendingDocumentScannerResult = null
+            Log.d(TAG, "consumePendingResult: returning static result")
+            return staticResult
+        }
+        
+        // Fall back to instance storage
+        val instanceResult = pendingDocumentScannerResult
+        if (instanceResult != null) {
+            pendingDocumentScannerResult = null
+            Log.d(TAG, "consumePendingResult: returning instance result")
+            return instanceResult
+        }
+        
+        return null
+    }
+
     /**
      * Calls [scannerLauncher] and handles the result.
      */
@@ -58,7 +145,9 @@ class RNMLKitDocumentScannerModule : Module() {
         options: RNMLKitDocumentScannerOptions
     ): Any {
         return try {
-            var result = launchScanner(scannerLauncher)
+            val result = launchScanner(scannerLauncher)
+            // Clear any static pending result since we got a direct result
+            staticPendingResult = null
             return RNMLKitDocumentScannerResponse(
                 canceled = false,
                 pages = result.pages,
@@ -70,25 +159,58 @@ class RNMLKitDocumentScannerModule : Module() {
     }
 
     /**
-     * Function that would store the results coming from 3-rd party Activity in case Android decides to
+     * Function that stores the results coming from 3rd party Activity in case Android decides to
      * destroy the launching application that is backgrounded.
+     * 
+     * This callback is invoked by the ActivityResultContract when the scanner completes,
+     * even if the original activity was destroyed. We store the result in BOTH instance
+     * and static storage to handle different recreation scenarios.
      */
     private fun handleResultUponActivityDestruction(result: DocumentScannerContractResult, options: RNMLKitDocumentScannerOptions) {
-        if (result is DocumentScannerContractResult.Success) {
-            pendingDocumentScannerResult = PendingDocumentScannerResult(result.pages, result.pdf, options)
+        Log.d(TAG, "handleResultUponActivityDestruction called with result type: ${result::class.simpleName}")
+        
+        when (result) {
+            is DocumentScannerContractResult.Success -> {
+                val pendingResult = PendingDocumentScannerResult(result.pages, result.pdf, options)
+                // Store in both locations to handle different scenarios
+                pendingDocumentScannerResult = pendingResult
+                staticPendingResult = pendingResult
+                Log.d(TAG, "Stored pending result: pages=${result.pages?.size}, pdf=${result.pdf?.uri}")
+                
+                // If there's a waiting continuation (from a retry), resume it
+                pendingContinuation?.let { continuation ->
+                    pendingContinuation = null
+                    Log.d(TAG, "Resuming pending continuation with success result")
+                    continuation.resume(result)
+                }
+            }
+            is DocumentScannerContractResult.Cancelled -> {
+                Log.d(TAG, "Scan was cancelled")
+                pendingContinuation?.let { continuation ->
+                    pendingContinuation = null
+                    continuation.resume(result)
+                }
+            }
+            is DocumentScannerContractResult.Error -> {
+                Log.d(TAG, "Scan resulted in error")
+                pendingContinuation?.let { continuation ->
+                    pendingContinuation = null
+                    continuation.resume(result)
+                }
+            }
         }
     }
 
     /**
-   * Launches document scanner
-   */
+     * Launches document scanner
+     */
     private suspend fun launchScanner(
         scannerLauncher: suspend () -> DocumentScannerContractResult
     ): DocumentScannerContractResult.Success = withContext(Dispatchers.IO) {
         when (val scannerResult = scannerLauncher()) {
-        is DocumentScannerContractResult.Success -> scannerResult
-        is DocumentScannerContractResult.Cancelled -> throw OperationCanceledException()
-        is DocumentScannerContractResult.Error -> throw FailedToScanDocumentException()
+            is DocumentScannerContractResult.Success -> scannerResult
+            is DocumentScannerContractResult.Cancelled -> throw OperationCanceledException()
+            is DocumentScannerContractResult.Error -> throw FailedToScanDocumentException()
         }
     }
 }
@@ -100,4 +222,4 @@ internal data class PendingDocumentScannerResult(
     val pages: List<String>? = null,
     val pdf: PdfInfo? = null,
     val options: RNMLKitDocumentScannerOptions
-)
+)
\ No newline at end of file
diff --git a/yarn.lock b/yarn.lock
index 5ad0cde0..6d1a8011 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -4637,6 +4637,21 @@ __metadata:
   languageName: unknown
   linkType: soft
 
+"@infinitered/react-native-mlkit-barcode-scanning@workspace:^5.0.0, @infinitered/react-native-mlkit-barcode-scanning@workspace:modules/react-native-mlkit-barcode-scanning":
+  version: 0.0.0-use.local
+  resolution: "@infinitered/react-native-mlkit-barcode-scanning@workspace:modules/react-native-mlkit-barcode-scanning"
+  dependencies:
+    "@infinitered/react-native-mlkit-core": 5.0.0
+    "@types/react": ~19.1.10
+    expo-module-scripts: ^3.4.1
+    expo-modules-core: ~3.0.25
+  peerDependencies:
+    expo: "*"
+    react: "*"
+    react-native: "*"
+  languageName: unknown
+  linkType: soft
+
 "@infinitered/react-native-mlkit-core@5.0.0, @infinitered/react-native-mlkit-core@workspace:modules/react-native-mlkit-core":
   version: 0.0.0-use.local
   resolution: "@infinitered/react-native-mlkit-core@workspace:modules/react-native-mlkit-core"
@@ -12036,6 +12051,7 @@ __metadata:
     "@babel/runtime": ^7.20.0
     "@expo-google-fonts/space-grotesk": ^0.2.2
     "@expo/metro-runtime": ~6.1.2
+    "@infinitered/react-native-mlkit-barcode-scanning": "workspace:^5.0.0"
     "@infinitered/react-native-mlkit-document-scanner": "workspace:^5.0.0"
     "@infinitered/react-native-mlkit-face-detection": "workspace:^5.0.0"
     "@infinitered/react-native-mlkit-image-labeling": "workspace:^5.0.0"
@@ -12072,7 +12088,9 @@ __metadata:
     expo-asset: ~12.0.9
     expo-atlas: ^0.3.0
     expo-build-properties: ~1.0.9
+    expo-camera: ~17.0.10
     expo-dev-client: ~6.0.17
+    expo-file-system: ~19.0.21
     expo-font: ~14.0.9
     expo-image: ~3.0.10
     expo-image-picker: ~17.0.8
@@ -12220,6 +12238,23 @@ __metadata:
   languageName: node
   linkType: hard
 
+"expo-camera@npm:~17.0.10":
+  version: 17.0.10
+  resolution: "expo-camera@npm:17.0.10"
+  dependencies:
+    invariant: ^2.2.4
+  peerDependencies:
+    expo: "*"
+    react: "*"
+    react-native: "*"
+    react-native-web: "*"
+  peerDependenciesMeta:
+    react-native-web:
+      optional: true
+  checksum: 5cae1769e8483e2d8f0fe52e18083040a52a6beb0178470cb28d7669f9ec6565be6861223842e82b1b8a20ab7178987e969cf295958b0a28bfdd6e5ad1e1ddc8
+  languageName: node
+  linkType: hard
+
 "expo-constants@npm:~18.0.10, expo-constants@npm:~18.0.8, expo-constants@npm:~18.0.9":
   version: 18.0.10
   resolution: "expo-constants@npm:18.0.10"
@@ -12290,6 +12325,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"expo-file-system@npm:~19.0.21":
+  version: 19.0.21
+  resolution: "expo-file-system@npm:19.0.21"
+  peerDependencies:
+    expo: "*"
+    react-native: "*"
+  checksum: 26b4c95c8d30580723995bf8e32287b72eadf0e3442ca14854c15dc47021c4c22eefbc490ab4fadf98b3f0b14847eba3012dfe663c8a8b42de7b1587f6811d8f
+  languageName: node
+  linkType: hard
+
 "expo-font@npm:~14.0.9":
   version: 14.0.9
   resolution: "expo-font@npm:14.0.9"