diff --git a/native/expo-modules/thumbhash/android/src/main/java/app/comm/android/thumbhash/ThumbhashModule.kt b/native/expo-modules/thumbhash/android/src/main/java/app/comm/android/thumbhash/ThumbhashModule.kt
--- a/native/expo-modules/thumbhash/android/src/main/java/app/comm/android/thumbhash/ThumbhashModule.kt
+++ b/native/expo-modules/thumbhash/android/src/main/java/app/comm/android/thumbhash/ThumbhashModule.kt
@@ -1,14 +1,112 @@
 package app.comm.android.thumbhash
 
+import android.content.ContentResolver
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.ImageDecoder
+import android.net.Uri
+import android.os.Build
+import android.util.Base64
+import androidx.annotation.RequiresApi
+import androidx.core.graphics.scale
+import androidx.core.util.component1
+import androidx.core.util.component2
+import expo.modules.core.errors.CodedException
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
+import thirdparty.ThumbHash
+import kotlin.math.max
+
+// Thumbhash requires images that are max 100x100 pixels
+private const val THUMB_SIZE = 100
 
 class ThumbhashModule : Module() {
   override fun definition() = ModuleDefinition {
     Name("Thumbhash")
 
-    AsyncFunction("generateThumbHash") {
-      "unimplemented"
+    AsyncFunction("generateThumbHash", this@ThumbhashModule::generateThumbHash)
+  }
+
+  // region Function implementations
+
+  private fun generateThumbHash(photoURI: Uri): String {
+    val bitmap = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+      // For API >= 28 we can use the ImageDecoder API which is more modern
+      // and allows to resize bitmap to desired size while loading the file
+      val source = ImageDecoder.createSource(this.contentResolver, photoURI)
+      ImageDecoder.decodeBitmap(source, this.decoderListener)
+    } else {
+      // For older devices, we use the BitmapFactory thing which is less
+      // flexible, but at least we can request for the ARGB_8888 to avoid
+      // future conversions. We rescale the bitmap afterwards
+      val opts = BitmapFactory.Options().apply {
+        inPreferredConfig = Bitmap.Config.ARGB_8888
+      }
+      this.contentResolver.openInputStream(photoURI).use { stream ->
+        BitmapFactory.decodeStream(stream, null, opts)
+      }?.let {
+        val w = THUMB_SIZE * it.width / max(it.width, it.height)
+        val h = THUMB_SIZE * it.height / max(it.width, it.height)
+        it.scale(w, h, filter = false)
+      } ?: throw BitmapDecodeFailureException(photoURI.toString())
     }
+
+    val rgba = bitmap.toRGBA()
+    val thumbHash = ThumbHash.rgbaToThumbHash(bitmap.width, bitmap.height, rgba)
+    return Base64.encodeToString(thumbHash, Base64.DEFAULT)
   }
+
+  // endregion
+
+  @RequiresApi(Build.VERSION_CODES.P)
+  private val decoderListener =
+    ImageDecoder.OnHeaderDecodedListener { imageDecoder, imageInfo, _ ->
+      val (w, h) = imageInfo.size
+      val newWidth = THUMB_SIZE * w / max(w, h)
+      val newHeight = THUMB_SIZE * h / max(w, h)
+      // this usually defaults bitmap config to ARGB_8888
+      imageDecoder.allocator = ImageDecoder.ALLOCATOR_SOFTWARE
+      imageDecoder.setTargetSize(newWidth, newHeight)
+    }
+
+  private val contentResolver: ContentResolver
+    get() = requireNotNull(this.appContext.reactContext) {
+      "React Application Context is null"
+    }.contentResolver
 }
+
+// region Utility extension functions
+
+fun Bitmap.toRGBA(): ByteArray {
+  // ensure we're using the ARGB_8888 format
+  val bitmap: Bitmap = when (this.config) {
+      Bitmap.Config.ARGB_8888 -> this
+      else -> this.copy(Bitmap.Config.ARGB_8888, false)
+  }
+  val pixels = IntArray(bitmap.width * bitmap.height).also {
+    bitmap.getPixels(it, 0, bitmap.width, 0, 0, bitmap.width, bitmap.height)
+  }
+  val bytes = ByteArray(pixels.size * 4)
+  var i = 0
+  for (pixel in pixels) {
+    // Get components assuming is ARGB
+    val a = pixel shr 24 and 0xff
+    val r = pixel shr 16 and 0xff
+    val g = pixel shr 8 and 0xff
+    val b = pixel and 0xff
+    bytes[i++] = r.toByte()
+    bytes[i++] = g.toByte()
+    bytes[i++] = b.toByte()
+    bytes[i++] = a.toByte()
+  }
+  return bytes
+}
+
+// endregion
+
+// region Exception definitions
+
+private class BitmapDecodeFailureException(uri: String) :
+  CodedException("Failed to decode Bitmap for URI: $uri")
+
+// endregion
diff --git a/native/expo-modules/thumbhash/android/src/main/java/thirdparty/LICENSE.txt b/native/expo-modules/thumbhash/android/src/main/java/thirdparty/LICENSE.txt
new file mode 100644
--- /dev/null
+++ b/native/expo-modules/thumbhash/android/src/main/java/thirdparty/LICENSE.txt
@@ -0,0 +1,19 @@
+Copyright (c) 2023 Evan Wallace
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/native/expo-modules/thumbhash/android/src/main/java/thirdparty/ThumbHash.java b/native/expo-modules/thumbhash/android/src/main/java/thirdparty/ThumbHash.java
new file mode 100644
--- /dev/null
+++ b/native/expo-modules/thumbhash/android/src/main/java/thirdparty/ThumbHash.java
@@ -0,0 +1,148 @@
+package thirdparty;
+
+import androidx.annotation.NonNull;
+
+// ThumbHash Java implementation thanks to @evanw https://github.com/evanw/thumbhash
+public final class ThumbHash {
+  /**
+   * Encodes an RGBA image to a ThumbHash. RGB should not be premultiplied by A.
+   *
+   * @param w    The width of the input image. Must be ≤100px.
+   * @param h    The height of the input image. Must be ≤100px.
+   * @param rgba The pixels in the input image, row-by-row. Must have w*h*4 elements.
+   * @return The ThumbHash as a byte array.
+   */
+  @NonNull
+  public static byte[] rgbaToThumbHash(int w, int h, byte[] rgba) {
+    // Encoding an image larger than 100x100 is slow with no benefit
+    if (w > 100 || h > 100) throw new IllegalArgumentException(w + "x" + h + " doesn't fit in 100x100");
+
+    // Determine the average color
+    float avg_r = 0, avg_g = 0, avg_b = 0, avg_a = 0;
+    for (int i = 0, j = 0; i < w * h; i++, j += 4) {
+      float alpha = (rgba[j + 3] & 255) / 255.0f;
+      avg_r += alpha / 255.0f * (rgba[j] & 255);
+      avg_g += alpha / 255.0f * (rgba[j + 1] & 255);
+      avg_b += alpha / 255.0f * (rgba[j + 2] & 255);
+      avg_a += alpha;
+    }
+    if (avg_a > 0) {
+      avg_r /= avg_a;
+      avg_g /= avg_a;
+      avg_b /= avg_a;
+    }
+
+    boolean hasAlpha = avg_a < w * h;
+    int l_limit = hasAlpha ? 5 : 7; // Use fewer luminance bits if there's alpha
+    int lx = Math.max(1, Math.round((float) (l_limit * w) / (float) Math.max(w, h)));
+    int ly = Math.max(1, Math.round((float) (l_limit * h) / (float) Math.max(w, h)));
+    float[] l = new float[w * h]; // luminance
+    float[] p = new float[w * h]; // yellow - blue
+    float[] q = new float[w * h]; // red - green
+    float[] a = new float[w * h]; // alpha
+
+    // Convert the image from RGBA to LPQA (composite atop the average color)
+    for (int i = 0, j = 0; i < w * h; i++, j += 4) {
+      float alpha = (rgba[j + 3] & 255) / 255.0f;
+      float r = avg_r * (1.0f - alpha) + alpha / 255.0f * (rgba[j] & 255);
+      float g = avg_g * (1.0f - alpha) + alpha / 255.0f * (rgba[j + 1] & 255);
+      float b = avg_b * (1.0f - alpha) + alpha / 255.0f * (rgba[j + 2] & 255);
+      l[i] = (r + g + b) / 3.0f;
+      p[i] = (r + g) / 2.0f - b;
+      q[i] = r - g;
+      a[i] = alpha;
+    }
+
+    // Encode using the DCT into DC (constant) and normalized AC (varying) terms
+    Channel l_channel = new Channel(Math.max(3, lx), Math.max(3, ly)).encode(w, h, l);
+    Channel p_channel = new Channel(3, 3).encode(w, h, p);
+    Channel q_channel = new Channel(3, 3).encode(w, h, q);
+    Channel a_channel = hasAlpha ? new Channel(5, 5).encode(w, h, a) : null;
+
+    // Write the constants
+    boolean isLandscape = w > h;
+    int header24 = Math.round(63.0f * l_channel.dc)
+      | (Math.round(31.5f + 31.5f * p_channel.dc) << 6)
+      | (Math.round(31.5f + 31.5f * q_channel.dc) << 12)
+      | (Math.round(31.0f * l_channel.scale) << 18)
+      | (hasAlpha ? 1 << 23 : 0);
+    int header16 = (isLandscape ? ly : lx)
+      | (Math.round(63.0f * p_channel.scale) << 3)
+      | (Math.round(63.0f * q_channel.scale) << 9)
+      | (isLandscape ? 1 << 15 : 0);
+    int ac_start = hasAlpha ? 6 : 5;
+    int ac_count = l_channel.ac.length + p_channel.ac.length + q_channel.ac.length
+      + (hasAlpha ? a_channel.ac.length : 0);
+    byte[] hash = new byte[ac_start + (ac_count + 1) / 2];
+    hash[0] = (byte) header24;
+    hash[1] = (byte) (header24 >> 8);
+    hash[2] = (byte) (header24 >> 16);
+    hash[3] = (byte) header16;
+    hash[4] = (byte) (header16 >> 8);
+    if (hasAlpha) hash[5] = (byte) (Math.round(15.0f * a_channel.dc)
+      | (Math.round(15.0f * a_channel.scale) << 4));
+
+    // Write the varying factors
+    int ac_index = 0;
+    ac_index = l_channel.writeTo(hash, ac_start, ac_index);
+    ac_index = p_channel.writeTo(hash, ac_start, ac_index);
+    ac_index = q_channel.writeTo(hash, ac_start, ac_index);
+    if (hasAlpha) a_channel.writeTo(hash, ac_start, ac_index);
+    return hash;
+  }
+
+  private static final class Channel {
+    int nx;
+    int ny;
+    float dc;
+    float[] ac;
+    float scale;
+
+    Channel(int nx, int ny) {
+      this.nx = nx;
+      this.ny = ny;
+      int n = 0;
+      for (int cy = 0; cy < ny; cy++)
+        for (int cx = cy > 0 ? 0 : 1; cx * ny < nx * (ny - cy); cx++)
+          n++;
+      ac = new float[n];
+    }
+
+    Channel encode(int w, int h, float[] channel) {
+      int n = 0;
+      float[] fx = new float[w];
+      for (int cy = 0; cy < ny; cy++) {
+        for (int cx = 0; cx * ny < nx * (ny - cy); cx++) {
+          float f = 0;
+          for (int x = 0; x < w; x++)
+            fx[x] = (float) Math.cos(Math.PI / w * cx * (x + 0.5f));
+          for (int y = 0; y < h; y++) {
+            float fy = (float) Math.cos(Math.PI / h * cy * (y + 0.5f));
+            for (int x = 0; x < w; x++)
+              f += channel[x + y * w] * fx[x] * fy;
+          }
+          f /= w * h;
+          if (cx > 0 || cy > 0) {
+            ac[n++] = f;
+            scale = Math.max(scale, Math.abs(f));
+          } else {
+            dc = f;
+          }
+        }
+      }
+      if (scale > 0)
+        for (int i = 0; i < ac.length; i++)
+          ac[i] = 0.5f + 0.5f / scale * ac[i];
+      return this;
+    }
+
+    int writeTo(byte[] hash, int start, int index) {
+      for (float v : ac) {
+        hash[start + (index >> 1)] |= Math.round(15.0f * v) << ((index & 1) << 2);
+        index++;
+      }
+      return index;
+    }
+  }
+}
+