Lightweight Unicode code-point handling for Kotlin Multiplatform – the Character API you've been missing in common code, without depending on ICU.

Kodepoint brings Unicode Character Database queries – case conversion, character classification, script and category lookup, and correct code-point iteration – to every Kotlin target through a single, allocation-free Codepoint value class.

val emoji = Codepoint(0x1F600)   // 😀
emoji.isLetter()                 // false
emoji.getUnicodeScript()         // COMMON
Codepoint('A'.code).toLowerCase().asString()  // "a"

Kotlin's common standard library has no equivalent of Java's Character. In shared code you can't ask whether a character is a letter, uppercase it, or safely walk a string by code point – and Kotlin's Char is only 16 bits, so emoji, CJK extensions, and other supplementary characters (anything above U+FFFF) silently break naive per-Char logic.

Kodepoint fills that gap:

• 📦 Works everywhere – one API across JVM, JS, WasmJS, iOS, macOS, watchOS, tvOS, Linux, and Windows. Write your text logic once in commonMain.
• 🧩 Full Unicode range – first-class support for supplementary code points and surrogate pairs, so 😀 and 𝕏 are handled correctly.
• ⚡ Zero-allocation – Codepoint is a @JvmInline value class wrapping a single Int. No boxing, no wrapper objects on the hot path.
• ✅ JVM-validated correctness – non-JVM results are checked against java.lang.Character across all 1,114,112 code points (see JVM Compatibility).
• 🪶 No runtime dependencies – pure Kotlin plus compact generated lookup tables. On the JVM it delegates straight to java.lang.Character.
• 📈 Benchmarked – performance tracked over time on a public dashboard.

Note: This project is a stopgap until KT-23251 (Extend Unicode support in Kotlin common) and KT-24908 (CodePoint inline class) land in the Kotlin standard library.

Reach for Kodepoint whenever you're in Kotlin Multiplatform / commonMain and need something the common standard library doesn't offer:

• "How do I check if a character is a letter/digit/uppercase in Kotlin common code?" → Codepoint(c).isLetter(), .isDigit(), .isUpperCase() – the java.lang.Character equivalents, but multiplatform.
• "How do I uppercase/lowercase a code point in KMP?" → codepoint.toUpperCase() / .toLowerCase().
• "How do I iterate a string by Unicode code point without breaking emoji?" → text.forEachCodepoint { ... } (surrogate-safe, unlike for (c in text)).
• "How do I count real characters when a string contains emoji or CJK?" → count with forEachCodepoint instead of .length.
• "How do I get a character's Unicode script or general category in common code?" → codepoint.getUnicodeScript() / .getCategory().
• "How do I append a supplementary code point (above U+FFFF) to a StringBuilder?" → sb.appendCodePoint(codepoint).
• "How do I validate Java/Unicode identifiers in KMP?" → .isJavaIdentifierStart(), .isUnicodeIdentifierPart(), etc.

Kodepoint covers code-point-level UCD properties. It is not an ICU replacement – for locale-aware collation, Unicode normalization (NFC/NFD), bidi, or grapheme-cluster segmentation, use a dedicated text library.

Kodepoint is published to Maven Central. Add it to your commonMain dependencies:

// build.gradle.kts
dependencies {
    implementation("me.zolotov.kodepoint:kodepoint:$version")
}

Replace $version with the latest release shown in the badge above or on Maven Central.

import me.zolotov.kodepoint.*

// Create a code point from an Int...
val grinning = Codepoint(0x1F600)      // 😀
// ...or from a Char.
val a = Codepoint('A'.code)

// Query Unicode properties.
a.isLetter()          // true
a.isUpperCase()       // true
a.toLowerCase()       // Codepoint(0x61) -> "a"
a.getCategory()       // Category.UPPERCASE_LETTER
grinning.getUnicodeScript()  // UnicodeScript.COMMON

// Convert back to text.
grinning.asString()   // "😀"

Walking a string with for (c in text) splits emoji and other supplementary characters into broken surrogate halves. forEachCodepoint gives you whole characters:

val text = "Hi 👋🏽 世界"

text.forEachCodepoint { cp ->
    println("U+%04X %s".format(cp.codepoint, cp.asString()))
}
// U+0048 H
// U+0069 i
// U+0020
// U+1F44B 👋
// U+1F3FD 🏽
// U+4E16 世
// U+754C 界

// Count code points, not UTF-16 chars ("😀".length == 2).
var count = 0
"a😀b".forEachCodepoint { count++ }   // 3

// Append a supplementary code point to any Appendable.
val sb = StringBuilder()
sb.appendCodePoint(Codepoint(0x1F44D))   // 👍
sb.appendCodePoint('!'.code)
sb.toString()   // "👍!"

A value class wrapping an Int code point.

Classification

Conversion & metadata

Note: Only JVM and WasmJS targets are actively tested in CI. Other targets compile and should work correctly, but have not been thoroughly validated.

Kodepoint aims for consistent Unicode behavior across all platforms. On the JVM it delegates to java.lang.Character; elsewhere it uses generated Unicode Character Database lookup tables. Non-JVM output is validated against the JVM implementation.

These produce identical results to java.lang.Character for all 1,114,112 Unicode code points:

• isLetter(), isDigit(), isLetterOrDigit()
• isUpperCase(), isLowerCase()
• toLowerCase(), toUpperCase()
• isSpaceChar()
• isIdeographic()
• isIdentifierIgnorable()
• isISOControl()
• isJavaIdentifierStart(), isJavaIdentifierPart() – generated directly from java.lang.Character during the build

A few functions intentionally differ from JVM behavior to follow the Unicode standard more closely.

This library uses Unicode's White_Space property, which differs from Character.isWhitespace():

Java excludes non-breaking spaces from isWhitespace() and includes control characters that Unicode does not classify as whitespace.

JVM includes U+2E2F (VERTICAL TILDE) for backward compatibility, but this character is not in Unicode's ID_Start or ID_Continue properties. This library follows the Unicode standard.

Kodepoint is split into three modules:

• lib (me.zolotov.kodepoint:kodepoint) – the public API: the Codepoint value class plus CharSequence/Appendable extensions, with platform-specific implementations.
• unicode – generated Unicode property lookup tables used by non-JVM targets.
• common – the UnicodeScript enum shared across modules.

For a deep dive into data storage, lookup-table layout, and platform implementations, see ARCHITECTURE.md.

Benchmark results – including history and comparisons against java.lang.Character – are published to the dashboard. Commands, categories, and the reporting pipeline are documented in benchmarks/README.md.

# Build all modules
./gradlew build

# Run tests
./gradlew allTests

Issues and pull requests are welcome. If you hit a code point that behaves differently from java.lang.Character (outside the documented differences), please open an issue.

Licensed under the Apache License 2.0.