diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index c6c8fae6..2e27d71e 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -32,7 +32,7 @@ androidx-test-ext-junit = "1.1.5"
 
 dropbox-differ = "0.0.1"
 google-android-material = "1.5.0"
-json = "20231013"
+gson = "2.10.1"
 junit = "4.13.2"
 ktor-serialization-kotlinx-xml = "2.3.0"
 squareup-okhttp = "5.0.0-alpha.11"
@@ -77,7 +77,7 @@ compose-ui-graphics-desktop = { module = "org.jetbrains.compose.ui:ui-graphics-d
 compose-ui-test-junit4-desktop = { module = "org.jetbrains.compose.ui:ui-test-junit4-desktop", version.ref = "composeDesktop" }
 dropbox-differ = { module = "com.dropbox.differ:differ", version.ref = "dropbox-differ" }
 google-android-material = { module = "com.google.android.material:material", version.ref = "google-android-material" }
-json = { module = "org.json:json", version.ref = "json" }
+gson = { module = "com.google.code.gson:gson", version.ref = "gson"}
 junit = { module = "junit:junit", version.ref = "junit" }
 ktor-serialization-kotlinx-xml = { module = "io.ktor:ktor-serialization-kotlinx-xml", version.ref = "ktor-serialization-kotlinx-xml" }
 squareup-okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "squareup-okhttp" }
diff --git a/include-build/roborazzi-core/build.gradle b/include-build/roborazzi-core/build.gradle
index 5dd4152f..3d0dfb22 100644
--- a/include-build/roborazzi-core/build.gradle
+++ b/include-build/roborazzi-core/build.gradle
@@ -32,7 +32,7 @@ kotlin {
     }
     commonJvmMain {
       dependencies {
-        compileOnly libs.json
+        compileOnly libs.gson
         api libs.dropbox.differ
         implementation libs.junit
       }
@@ -46,7 +46,7 @@ kotlin {
     }
     jvmMain {
       dependencies {
-        implementation libs.json
+        implementation libs.gson
       }
     }
     jvmTest {
@@ -61,6 +61,7 @@ kotlin {
         compileOnly libs.androidx.compose.ui.test.junit4
         api libs.androidx.test.espresso.core
         implementation libs.androidx.core.ktx
+        implementation libs.gson
       }
     }
 
diff --git a/include-build/roborazzi-core/src/commonJvmMain/kotlin/com/github/takahirom/roborazzi/CaptureResult.kt b/include-build/roborazzi-core/src/commonJvmMain/kotlin/com/github/takahirom/roborazzi/CaptureResult.kt
index 0a8380ec..a13159b3 100644
--- a/include-build/roborazzi-core/src/commonJvmMain/kotlin/com/github/takahirom/roborazzi/CaptureResult.kt
+++ b/include-build/roborazzi-core/src/commonJvmMain/kotlin/com/github/takahirom/roborazzi/CaptureResult.kt
@@ -1,124 +1,105 @@
 package com.github.takahirom.roborazzi
 
+import com.github.takahirom.roborazzi.CaptureResults.Companion.gson
+import com.google.gson.annotations.JsonAdapter
+import com.google.gson.annotations.SerializedName
 import java.io.File
 import java.io.FileReader
-import org.json.JSONObject
 
+@JsonAdapter(CaptureResult.JsonAdapter::class)
 sealed interface CaptureResult {
-  fun toJson(): JSONObject
+  val type: String
   val timestampNs: Long
   val compareFile: File?
   val actualFile: File?
   val goldenFile: File?
 
   data class Recorded(
+    @SerializedName("golden_file_path")
     override val goldenFile: File,
+    @SerializedName("timestamp")
     override val timestampNs: Long,
   ) : CaptureResult {
+
+    override val type = "recorded"
     override val actualFile: File?
       get() = null
     override val compareFile: File?
       get() = null
-
-    override fun toJson(): JSONObject {
-      val json = JSONObject()
-      json.put("type", "recorded")
-      json.put("golden_file_path", goldenFile.absolutePath)
-      json.put("timestamp", timestampNs)
-      return json
-    }
   }
 
   data class Added(
+    @SerializedName("compare_file_path")
     override val compareFile: File,
+    @SerializedName("actual_file_path")
     override val actualFile: File,
+    @SerializedName("golden_file_path")
     override val goldenFile: File,
+    @SerializedName("timestamp")
     override val timestampNs: Long,
   ) : CaptureResult {
-    override fun toJson(): JSONObject {
-      val json = JSONObject()
-      json.put("type", "added")
-      json.put("compare_file_path", compareFile.absolutePath)
-      json.put("actual_file_path", actualFile.absolutePath)
-      json.put("golden_file_path", goldenFile.absolutePath)
-      json.put("timestamp", timestampNs)
-      return json
-    }
+    override val type = "added"
   }
 
   data class Changed(
+    @SerializedName("compare_file_path")
     override val compareFile: File,
+    @SerializedName("golden_file_path")
     override val goldenFile: File,
+    @SerializedName("actual_file_path")
     override val actualFile: File,
+    @SerializedName("timestamp")
     override val timestampNs: Long
   ) : CaptureResult {
-    override fun toJson(): JSONObject {
-      val json = JSONObject()
-      json.put("type", "changed")
-      json.put("compare_file_path", compareFile.absolutePath)
-      json.put("actual_file_path", actualFile.absolutePath)
-      json.put("golden_file_path", goldenFile.absolutePath)
-      json.put("timestamp", timestampNs)
-      return json
-    }
+    override val type = "changed"
   }
 
   data class Unchanged(
+    @SerializedName("golden_file_path")
     override val goldenFile: File,
+    @SerializedName("timestamp")
     override val timestampNs: Long
   ) : CaptureResult {
+    override val type = "unchanged"
     override val actualFile: File?
       get() = null
     override val compareFile: File?
       get() = null
-
-    override fun toJson(): JSONObject {
-      val json = JSONObject()
-      json.put("type", "unchanged")
-      json.put("golden_file_path", goldenFile.absolutePath)
-      json.put("timestamp", timestampNs)
-      return json
-    }
   }
 
   companion object {
-    fun fromJsonFile(inputPath: String): CaptureResult {
-      val json = JSONObject(FileReader(inputPath).readText())
-      return fromJson(json)
+    fun fromJsonFile(filePath: String): CaptureResult {
+      return gson.fromJson(FileReader(filePath), CaptureResult::class.java)
     }
+  }
 
-    fun fromJson(json: JSONObject): CaptureResult {
-      val type = json.getString("type")
-      val compareFile = json.optString("compare_file_path")?.let { File(it) }
-      val goldenFile = json.optString("golden_file_path")?.let { File(it) }
-      val actualFile = json.optString("actual_file_path")?.let { File(it) }
-      val timestampNs = json.getLong("timestamp")
+  object JsonAdapter : com.google.gson.JsonSerializer<CaptureResult>,
+    com.google.gson.JsonDeserializer<CaptureResult> {
+    override fun serialize(
+      src: CaptureResult,
+      typeOfSrc: java.lang.reflect.Type,
+      context: com.google.gson.JsonSerializationContext
+    ): com.google.gson.JsonElement {
+      val jsonElement = when (src) {
+        is Recorded -> context.serialize(src, Recorded::class.java)
+        is Changed -> context.serialize(src, Changed::class.java)
+        is Unchanged -> context.serialize(src, Unchanged::class.java)
+        is Added -> context.serialize(src, Added::class.java)
+      }
+      return jsonElement
+    }
 
+    override fun deserialize(
+      json: com.google.gson.JsonElement,
+      typeOfT: java.lang.reflect.Type,
+      context: com.google.gson.JsonDeserializationContext
+    ): CaptureResult? {
+      val type = requireNotNull(json.asJsonObject.get("type")?.asString)
       return when (type) {
-        "recorded" -> Recorded(
-          goldenFile = goldenFile!!,
-          timestampNs = timestampNs
-        )
-
-        "changed" -> Changed(
-          compareFile = compareFile!!,
-          goldenFile = goldenFile!!,
-          actualFile = actualFile!!,
-          timestampNs = timestampNs
-        )
-
-        "unchanged" -> Unchanged(
-          goldenFile = goldenFile!!,
-          timestampNs = timestampNs
-        )
-
-        "added" -> Added(
-          compareFile = compareFile!!,
-          actualFile = actualFile!!,
-          timestampNs = timestampNs,
-          goldenFile = goldenFile!!,
-        )
-
+        "recorded" -> context.deserialize(json, Recorded::class.java)
+        "changed" -> context.deserialize(json, Changed::class.java)
+        "unchanged" -> context.deserialize(json, Unchanged::class.java)
+        "added" -> context.deserialize(json, Added::class.java)
         else -> throw IllegalArgumentException("Unknown type $type")
       }
     }
diff --git a/include-build/roborazzi-core/src/commonJvmMain/kotlin/com/github/takahirom/roborazzi/CaptureResults.kt b/include-build/roborazzi-core/src/commonJvmMain/kotlin/com/github/takahirom/roborazzi/CaptureResults.kt
index bb265c53..70c9eb30 100644
--- a/include-build/roborazzi-core/src/commonJvmMain/kotlin/com/github/takahirom/roborazzi/CaptureResults.kt
+++ b/include-build/roborazzi-core/src/commonJvmMain/kotlin/com/github/takahirom/roborazzi/CaptureResults.kt
@@ -1,22 +1,20 @@
 package com.github.takahirom.roborazzi
 
-import org.json.JSONArray
-import org.json.JSONObject
+import com.google.gson.*
+import com.google.gson.annotations.SerializedName
 import java.io.File
+import java.io.FileReader
+import java.lang.reflect.Type
 
 data class CaptureResults(
-  val summary: ResultSummary,
+  @SerializedName("summary")
+  val resultSummary: ResultSummary,
+  @SerializedName("results")
   val captureResults: List<CaptureResult>
 ) {
-  fun toJson(): JSONObject {
-    val json = JSONObject()
-    json.put("summary", summary.toJson())
-    val resultsArray = JSONArray()
-    captureResults.forEach { result ->
-      resultsArray.put(result.toJson())
-    }
-    json.put("results", resultsArray)
-    return json
+
+  fun toJson(): String {
+    return gson.toJson(this)
   }
 
   fun toHtml(reportDirectoryPath: String): String {
@@ -78,7 +76,7 @@ data class CaptureResults(
       }
     }
     return buildString {
-      append(summary.toHtml())
+      append(resultSummary.toHtml())
       append(buildTable("Recorded images", "recorded", recordedImages))
       append(buildTable("Added images", "added", addedImages))
       append(buildTable("Changed images", "changed", changedImages))
@@ -87,26 +85,33 @@ data class CaptureResults(
   }
 
   companion object {
+    val gson: Gson = GsonBuilder()
+      .registerTypeAdapter(File::class.java, object : JsonSerializer<File>, JsonDeserializer<File> {
+        override fun serialize(src: File?, typeOfSrc: Type?, context: JsonSerializationContext?): JsonElement {
+          val absolutePath = src?.absolutePath ?: return JsonNull.INSTANCE
+          return JsonPrimitive(absolutePath)
+        }
+
+        override fun deserialize(json: JsonElement?, typeOfT: Type?, context: JsonDeserializationContext?): File {
+          val path = json?.asString ?: throw JsonParseException("File path is null")
+          return File(path)
+        }
+      })
+      .create()
+
     fun fromJsonFile(inputPath: String): CaptureResults {
-      val fileContents = File(inputPath).readText()
-      val jsonObject = JSONObject(fileContents)
+      val jsonObject = JsonParser.parseString(FileReader(inputPath).readText()).asJsonObject
       return fromJson(jsonObject)
     }
 
-    fun fromJson(jsonObject: JSONObject): CaptureResults {
-      val summary = ResultSummary.fromJson(jsonObject.getJSONObject("summary"))
-      val resultsArray = jsonObject.getJSONArray("results")
-      val captureResults = mutableListOf<CaptureResult>()
-      for (i in 0 until resultsArray.length()) {
-        val resultJson = resultsArray.getJSONObject(i)
-        captureResults.add(CaptureResult.fromJson(resultJson))
-      }
-      return CaptureResults(summary, captureResults)
+    fun fromJson(jsonObject: JsonObject): CaptureResults {
+      // Auto convert using Gson
+      return gson.fromJson(jsonObject, CaptureResults::class.java)
     }
 
     fun from(results: List<CaptureResult>): CaptureResults {
       return CaptureResults(
-        summary = ResultSummary(
+        resultSummary = ResultSummary(
           total = results.size,
           recorded = results.count { it is CaptureResult.Recorded },
           added = results.count { it is CaptureResult.Added },
diff --git a/include-build/roborazzi-core/src/commonJvmMain/kotlin/com/github/takahirom/roborazzi/ResultSummary.kt b/include-build/roborazzi-core/src/commonJvmMain/kotlin/com/github/takahirom/roborazzi/ResultSummary.kt
index 7e1d1bed..0638414c 100644
--- a/include-build/roborazzi-core/src/commonJvmMain/kotlin/com/github/takahirom/roborazzi/ResultSummary.kt
+++ b/include-build/roborazzi-core/src/commonJvmMain/kotlin/com/github/takahirom/roborazzi/ResultSummary.kt
@@ -1,7 +1,5 @@
 package com.github.takahirom.roborazzi
 
-import org.json.JSONObject
-
 data class ResultSummary(
   val total: Int,
   val recorded: Int,
@@ -9,16 +7,6 @@ data class ResultSummary(
   val changed: Int,
   val unchanged: Int
 ) {
-  fun toJson(): JSONObject {
-    val json = JSONObject()
-    json.put("total", total)
-    json.put("recorded", recorded)
-    json.put("added", added)
-    json.put("changed", changed)
-    json.put("unchanged", unchanged)
-    return json
-  }
-
   fun toHtml(): String {
     return """
         <h3>Summary</h3>
@@ -44,21 +32,4 @@ data class ResultSummary(
         </table>
     """.trimIndent()
   }
-
-  companion object {
-    fun fromJson(jsonObject: JSONObject): ResultSummary {
-      val total = jsonObject.getInt("total")
-      val recorded = jsonObject.getInt("recorded")
-      val added = jsonObject.getInt("added")
-      val changed = jsonObject.getInt("changed")
-      val unchanged = jsonObject.getInt("unchanged")
-      return ResultSummary(
-        total = total,
-        recorded = recorded,
-        added = added,
-        changed = changed,
-        unchanged = unchanged
-      )
-    }
-  }
 }
\ No newline at end of file
diff --git a/include-build/roborazzi-core/src/commonJvmMain/kotlin/com/github/takahirom/roborazzi/RoborazziOptions.kt b/include-build/roborazzi-core/src/commonJvmMain/kotlin/com/github/takahirom/roborazzi/RoborazziOptions.kt
index ef75f822..dc232449 100644
--- a/include-build/roborazzi-core/src/commonJvmMain/kotlin/com/github/takahirom/roborazzi/RoborazziOptions.kt
+++ b/include-build/roborazzi-core/src/commonJvmMain/kotlin/com/github/takahirom/roborazzi/RoborazziOptions.kt
@@ -2,6 +2,7 @@ package com.github.takahirom.roborazzi
 
 import com.dropbox.differ.ImageComparator
 import com.dropbox.differ.SimpleImageComparator
+import com.github.takahirom.roborazzi.CaptureResults.Companion.gson
 import java.io.File
 import java.io.FileWriter
 
@@ -241,7 +242,7 @@ data class RoborazziOptions(
         val reportFileName =
           "$absolutePath/${captureResult.timestampNs}_$nameWithoutExtension.json"
 
-        val jsonResult = captureResult.toJson()
+        val jsonResult = gson.toJson(captureResult)
         FileWriter(reportFileName).use { it.write(jsonResult.toString()) }
         debugLog { "JsonResult file($reportFileName) has been written" }
       }
diff --git a/include-build/roborazzi-core/src/jvmTest/kotlin/io/github/takahirom/roborazzi/CaptureResultTest.kt b/include-build/roborazzi-core/src/jvmTest/kotlin/io/github/takahirom/roborazzi/CaptureResultTest.kt
index b552bae7..c055e573 100644
--- a/include-build/roborazzi-core/src/jvmTest/kotlin/io/github/takahirom/roborazzi/CaptureResultTest.kt
+++ b/include-build/roborazzi-core/src/jvmTest/kotlin/io/github/takahirom/roborazzi/CaptureResultTest.kt
@@ -2,8 +2,9 @@ package io.github.takahirom.roborazzi
 
 import com.github.takahirom.roborazzi.CaptureResult
 import com.github.takahirom.roborazzi.CaptureResults
+import com.github.takahirom.roborazzi.CaptureResults.Companion.gson
 import com.github.takahirom.roborazzi.ResultSummary
-import org.json.JSONObject
+import com.google.gson.JsonParser
 import org.junit.Assert.assertEquals
 import org.junit.Test
 import java.io.File
@@ -12,8 +13,8 @@ class CaptureResultTest {
 
   @Test
   fun testJsonSerialization() {
-    val summary = ResultSummary(11, 1, 2, 3, 5)
-    val captureResults = listOf(
+    val expectedSummary = ResultSummary(11, 1, 2, 3, 5)
+    val expectedCaptureResults = listOf(
       CaptureResult.Recorded(
         goldenFile = File("/golden_file"),
         timestampNs = 123456789,
@@ -36,38 +37,43 @@ class CaptureResultTest {
       )
     )
 
-    val compareReportResult = CaptureResults(summary, captureResults)
+    val expectedReportResults = CaptureResults(expectedSummary, expectedCaptureResults)
 
-    val json = compareReportResult.toJson()
-    val jsonSummary = json.getJSONObject("summary")
-    val jsonResults = json.getJSONArray("results")
+    val actualJson = gson.toJsonTree(expectedReportResults).asJsonObject
+    val actualJsonSummary = actualJson.get("summary").asJsonObject
+    val actualJsonResults = actualJson.get("results").asJsonArray
 
     // Test summary
-    assertEquals(summary.total, jsonSummary.getInt("total"))
-    assertEquals(summary.recorded, jsonSummary.getInt("recorded"))
-    assertEquals(summary.added, jsonSummary.getInt("added"))
-    assertEquals(summary.changed, jsonSummary.getInt("changed"))
-    assertEquals(summary.unchanged, jsonSummary.getInt("unchanged"))
+    assertEquals(expectedSummary.total, actualJsonSummary.get("total").asInt)
+    assertEquals(expectedSummary.recorded, actualJsonSummary.get("recorded").asInt)
+    assertEquals(expectedSummary.added, actualJsonSummary.get("added").asInt)
+    assertEquals(expectedSummary.changed, actualJsonSummary.get("changed").asInt)
+    assertEquals(expectedSummary.unchanged, actualJsonSummary.get("unchanged").asInt)
 
     // Test capture results
-    assertEquals(captureResults.size, jsonResults.length())
+    assertEquals(expectedCaptureResults.size, actualJsonResults.size())
 
-    for (i in 0 until jsonResults.length()) {
-      val jsonResult = jsonResults.getJSONObject(i)
-      val captureResult = captureResults[i]
+    for (i in 0 until actualJsonResults.size()) {
+      val actualJsonResult = actualJsonResults.get(i).asJsonObject
+      val expectedCaptureResult = expectedCaptureResults[i]
 
       assertEquals(
-        captureResult.compareFile?.absolutePath, jsonResult.optString("compare_file_path", null)
+        expectedCaptureResult.type,
+        actualJsonResult.get("type")?.asString
+      )
+
+      assertEquals(
+        expectedCaptureResult.compareFile?.absolutePath, actualJsonResult.get("compare_file_path")?.asString
       )
       assertEquals(
-        captureResult.goldenFile?.absolutePath,
-        jsonResult.optString("golden_file_path", null)
+        expectedCaptureResult.goldenFile?.absolutePath,
+        actualJsonResult.get("golden_file_path")?.asString
       )
       assertEquals(
-        captureResult.actualFile?.absolutePath,
-        jsonResult.optString("actual_file_path", null)
+        expectedCaptureResult.actualFile?.absolutePath,
+        actualJsonResult.get("actual_file_path")?.asString
       )
-      assertEquals(captureResult.timestampNs, jsonResult.getLong("timestamp"))
+      assertEquals(expectedCaptureResult.timestampNs, actualJsonResult.get("timestamp").asLong)
     }
   }
 
@@ -86,61 +92,62 @@ class CaptureResultTest {
                 {
                     "type": "recorded",
                     "golden_file_path": "golden_file",
-                    "timestamp": 123456789,
+                    "timestamp": 123456789
                 },
                 {
                     "type": "added",
                     "compare_file_path": "compare_file",
                     "actual_file_path": "actual_file",
-                    "timestamp": 123456789,
+                    "golden_file_path": "golden_file",
+                    "timestamp": 123456789
                 },
                 {
                     "type": "changed",
                     "compare_file_path": "compare_file",
                     "actual_file_path": "actual_file",
                     "golden_file_path": "golden_file",
-                    "timestamp": 123456789,
+                    "timestamp": 123456789
                 },
                 {
                     "type": "unchanged",
                     "golden_file_path": "golden_file",
-                    "timestamp": 123456789,
+                    "timestamp": 123456789
                 }
             ]
         }
         """.trimIndent()
-
-    val compareReportResult = CaptureResults.fromJson(JSONObject(jsonString))
-    val summary = compareReportResult.summary
-    val captureResults = compareReportResult.captureResults
+    val actualJsonObject = JsonParser.parseString(jsonString).asJsonObject
+    val actualCaptureResults= CaptureResults.fromJson(actualJsonObject)
+    val actualSummary = actualCaptureResults.resultSummary
+    val actualCaptureResultList = actualCaptureResults.captureResults
 
     // Test summary
-    assertEquals(11, summary.total)
-    assertEquals(1, summary.recorded)
-    assertEquals(2, summary.added)
-    assertEquals(3, summary.changed)
-    assertEquals(5, summary.unchanged)
+    assertEquals(11, actualSummary.total)
+    assertEquals(1, actualSummary.recorded)
+    assertEquals(2, actualSummary.added)
+    assertEquals(3, actualSummary.changed)
+    assertEquals(5, actualSummary.unchanged)
 
     // Test capture results
-    assertEquals(4, captureResults.size)
-
-    val recordedResult = captureResults[0] as CaptureResult.Recorded
-    assertEquals(File("golden_file"), recordedResult.goldenFile)
-    assertEquals(123456789, recordedResult.timestampNs)
-
-    val addedResult = captureResults[1] as CaptureResult.Added
-    assertEquals(File("compare_file"), addedResult.compareFile)
-    assertEquals(File("actual_file"), addedResult.actualFile)
-    assertEquals(123456789, addedResult.timestampNs)
-
-    val changedResult = captureResults[2] as CaptureResult.Changed
-    assertEquals(File("compare_file"), changedResult.compareFile)
-    assertEquals(File("actual_file"), changedResult.actualFile)
-    assertEquals(File("golden_file"), changedResult.goldenFile)
-    assertEquals(123456789, changedResult.timestampNs)
-
-    val unchangedResult = captureResults[3] as CaptureResult.Unchanged
-    assertEquals(File("golden_file"), unchangedResult.goldenFile)
-    assertEquals(123456789, unchangedResult.timestampNs)
+    assertEquals(4, actualCaptureResultList.size)
+
+    val actualRecordedResult = actualCaptureResultList[0] as CaptureResult.Recorded
+    assertEquals(File("golden_file"), actualRecordedResult.goldenFile)
+    assertEquals(123456789, actualRecordedResult.timestampNs)
+
+    val actualAddedResult = actualCaptureResultList[1] as CaptureResult.Added
+    assertEquals(File("compare_file"), actualAddedResult.compareFile)
+    assertEquals(File("actual_file"), actualAddedResult.actualFile)
+    assertEquals(123456789, actualAddedResult.timestampNs)
+
+    val actualChangedResult = actualCaptureResultList[2] as CaptureResult.Changed
+    assertEquals(File("compare_file"), actualChangedResult.compareFile)
+    assertEquals(File("actual_file"), actualChangedResult.actualFile)
+    assertEquals(File("golden_file"), actualChangedResult.goldenFile)
+    assertEquals(123456789, actualChangedResult.timestampNs)
+
+    val actualUnchangedResult = actualCaptureResultList[3] as CaptureResult.Unchanged
+    assertEquals(File("golden_file"), actualUnchangedResult.goldenFile)
+    assertEquals(123456789, actualUnchangedResult.timestampNs)
   }
 }
diff --git a/include-build/roborazzi-gradle-plugin/build.gradle b/include-build/roborazzi-gradle-plugin/build.gradle
index 34e6aed6..3105dbe6 100644
--- a/include-build/roborazzi-gradle-plugin/build.gradle
+++ b/include-build/roborazzi-gradle-plugin/build.gradle
@@ -24,7 +24,7 @@ dependencies {
     // We don't use junit for plugin
     exclude group: 'junit', module: 'junit'
   }
-  implementation libs.json
+  implementation libs.gson
   integrationTestDepImplementation libs.android.tools.build.gradle
   integrationTestDepImplementation libs.kotlin.gradle.plugin
   integrationTestDepImplementation libs.compose.gradle.plugin
diff --git a/include-build/roborazzi-gradle-plugin/src/integrationTest/java/io/github/takahirom/roborazzi/RoborazziGradleProject.kt b/include-build/roborazzi-gradle-plugin/src/integrationTest/java/io/github/takahirom/roborazzi/RoborazziGradleProject.kt
index 2a3dadd4..7160d8cf 100644
--- a/include-build/roborazzi-gradle-plugin/src/integrationTest/java/io/github/takahirom/roborazzi/RoborazziGradleProject.kt
+++ b/include-build/roborazzi-gradle-plugin/src/integrationTest/java/io/github/takahirom/roborazzi/RoborazziGradleProject.kt
@@ -311,18 +311,18 @@ dependencies {
   ) {
     val recordedFile =
       testProjectDir.root.resolve("app/build/test-results/roborazzi/results-summary.json")
-    val results = CaptureResults.fromJsonFile(recordedFile.absolutePath)
-    assert(results.summary.recorded == recorded) {
-      "Expected count: $recorded, actual count: ${results.summary.recorded} summary:${results.summary}"
+    val resutls = CaptureResults.fromJsonFile(recordedFile.absolutePath)
+    assert(resutls.resultSummary.recorded == recorded) {
+      "Expected count: $recorded, actual count: ${resutls.resultSummary.recorded} summary:${resutls.resultSummary}"
     }
-    assert(results.summary.added == added) {
-      "Expected count: $added, actual count: ${results.summary.added} summary:${results.summary}"
+    assert(resutls.resultSummary.added == added) {
+      "Expected count: $added, actual count: ${resutls.resultSummary.added} summary:${resutls.resultSummary}"
     }
-    assert(results.summary.changed == changed) {
-      "Expected count: $changed, actual count: ${results.summary.changed} summary:${results.summary}"
+    assert(resutls.resultSummary.changed == changed) {
+      "Expected count: $changed, actual count: ${resutls.resultSummary.changed} summary:${resutls.resultSummary}"
     }
-    assert(results.summary.unchanged == unchanged) {
-      "Expected count: $unchanged, actual count: ${results.summary.unchanged} summary:${results.summary}"
+    assert(resutls.resultSummary.unchanged == unchanged) {
+      "Expected count: $unchanged, actual count: ${resutls.resultSummary.unchanged} summary:${resutls.resultSummary}"
     }
   }
 
diff --git a/include-build/roborazzi-gradle-plugin/src/main/java/io/github/takahirom/roborazzi/RoborazziPlugin.kt b/include-build/roborazzi-gradle-plugin/src/main/java/io/github/takahirom/roborazzi/RoborazziPlugin.kt
index 92e45a24..647c1467 100644
--- a/include-build/roborazzi-gradle-plugin/src/main/java/io/github/takahirom/roborazzi/RoborazziPlugin.kt
+++ b/include-build/roborazzi-gradle-plugin/src/main/java/io/github/takahirom/roborazzi/RoborazziPlugin.kt
@@ -6,11 +6,7 @@ import com.android.build.api.variant.LibraryAndroidComponentsExtension
 import com.github.takahirom.roborazzi.CaptureResult
 import com.github.takahirom.roborazzi.CaptureResults
 import com.github.takahirom.roborazzi.RoborazziReportConst
-import org.gradle.api.Action
-import org.gradle.api.DefaultTask
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.Task
+import org.gradle.api.*
 import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.provider.Property
@@ -23,7 +19,7 @@ import org.gradle.api.tasks.testing.Test
 import org.gradle.language.base.plugins.LifecycleBasePlugin.VERIFICATION_GROUP
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
-import java.util.Locale
+import java.util.*
 import javax.inject.Inject
 
 private const val DEFAULT_OUTPUT_DIR = "outputs/roborazzi"
@@ -198,16 +194,16 @@ class RoborazziPlugin : Plugin<Project> {
               }
               t.infoln("Save result to ${resultsSummaryFile.absolutePath} with results:${results.size}")
 
-              val roborazziResult = CaptureResults.from(results)
+              val roborazziResults = CaptureResults.from(results)
 
-              val jsonResult = roborazziResult.toJson()
+              val jsonResult = roborazziResults.toJson()
               resultsSummaryFile.parentFile.mkdirs()
-              resultsSummaryFile.writeText(jsonResult.toString())
+              resultsSummaryFile.writeText(jsonResult)
               reportFile.parentFile.mkdirs()
               reportFile.writeText(
                 RoborazziReportConst.reportHtml.replace(
                   oldValue = "REPORT_TEMPLATE_BODY",
-                  newValue = roborazziResult.toHtml(reportFile.parentFile.absolutePath)
+                  newValue = roborazziResults.toHtml(reportFile.parentFile.absolutePath)
                 )
               )
             }
diff --git a/roborazzi-compose-desktop/build.gradle b/roborazzi-compose-desktop/build.gradle
index 63c1f1cd..8aad831c 100644
--- a/roborazzi-compose-desktop/build.gradle
+++ b/roborazzi-compose-desktop/build.gradle
@@ -21,7 +21,7 @@ kotlin {
       dependencies {
         // Please see settings.gradle
         api "io.github.takahirom.roborazzi:roborazzi-core:$VERSION_NAME"
-        implementation libs.json
+        implementation libs.gson
 
         implementation(compose.runtime)
         implementation(compose.desktop.currentOs)