How We Made Ktor JSON Parsing 66% Faster with 50% Less Memory on KMP

If you are building Kotlin Multiplatform applications, you know that JSON serialization is often one of the main bottlenecks in high-throughput backends and mobile apps—especially regarding CPU cycles and Garbage Collector (GC) pressure.

I’ve been working on Ghost Serializer—a byte-first JSON serializer designed for KMP, and the official HTTP Arena benchmarks just went live showing some wild improvements when integrated with Ktor.

📊 The Proof (HTTP Arena Benchmarks)

Don't take my word for it. Here is the raw comparison of Ktor base vs. Ktor + Ghost under load:

JSON Throughput: Slashed latency to jump from 395k to 658k rps (+66.6% speedup).
Heap Memory Consumption: Plunged from 9.90 GiB to 4.80 GiB (Over 50% memory reduction).
High-Load Complex APIs (API-16): Throughput rose by +22.2% while slashing memory by 35% (from 2.00 GiB down to 1.30 GiB).

🤝 Zero-Risk: Full Coexistence with your current Serializer

You don't need to rewrite your entire project. Ghost can coexist seamlessly with your existing setup (like kotlinx.serialization, Jackson, or Gson).

If Ghost doesn't find its @GhostSerializable annotation on a class, it will return null and let Ktor fallback to your standard serializer. This means you can adopt Ghost incrementally, using it only on your highest-traffic endpoints!

How to set up coexistence in Ktor:

import io.ktor.serialization.kotlinx.json.*
import io.ktor.server.application.*
import io.ktor.server.plugins.contentnegotiation.*
import com.ghost.serialization.ktor.ghost
import kotlinx.serialization.json.Json

fun Application.module() {
    install(ContentNegotiation) {
        // 1. Ghost handles high-performance @GhostSerializable endpoints
        ghost() 
        // 2. Kotlinx.serialization (or Jackson/Gson) handles the rest as fallback
        json(Json { ignoreUnknownKeys = true })
    }
}

How to define your models:

// Processed by GHOST (High Performance)
@GhostSerializable
data class HighTrafficUser(val id: Long, val email: String)

// Processed by Kotlinx.serialization (Standard fallback)
@Serializable
data class StandardSettings(val theme: String, val enabled: Boolean)

What makes Ghost actually different?

Unlike standard serializers that parse raw buffers into intermediate strings/chars and perform standard string matching, Ghost operates at the byte/bit level:

Compile-time Perfect Hash Finder (No String Comparison): During compilation (via KSP2), Ghost's PerfectHashFinder searches for a collision-free multiplier and shift parameter for your class's fields. At runtime, the parser packs the first 4 bytes of the incoming JSON key into a 32-bit integer key and resolves the field index in O(1) with a simple arithmetic instruction:

val hash = ((key * multiplier + size) shr shift) and 1023

It accesses a precalculated dispatch table using this hash, matching fields instantly with zero string allocations, zero string equality checks, and zero loops.

Single CPU Instruction Required-Fields Check: Instead of tracking lists, arrays, or maps of parsed fields, Ghost maps them to a single Long bitmask. Validating that all required fields are present compiles down to a single bitwise CPU register check.
Byte-First Pipelines: It works directly on raw source bytes (ByteArray / Okio / ByteReadChannel). It avoids decoding JSON structures to string representations in the hot path, only decoding final string values when strictly requested.
Thread-Local Reader/Writer Pools: Keeps GC allocation pressure at absolute zero in steady-state operation by reusing pre-allocated pools.

🚀 Help us build a community!

Ghost is open-source and ready for Kotlin Multiplatform (JVM, Android, iOS, and native targets). We are looking for collaborators, feedback, and contributors to push KMP performance to its absolute limits.