A high-performance cross-platform code highlighting library developed based on Kotlin Multiplatform (KMP) and Compose Multiplatform. It supports consistent rendering effects on Android, iOS, Desktop (JVM), and Web (Wasm/JS) platforms.

中文版本

• Multi-platform Consistency: Uses Compose Multiplatform for consistent code highlighting on Android, iOS, Desktop (JVM), and Web (Wasm/JS).
• 28+ Programming Languages: Built-in support for Kotlin, Java, Swift, Python, JavaScript, TypeScript, Ruby, PHP, Dart, Scala, Go, Rust, C, C++, R, SQL, JSON, YAML, TOML, Dockerfile, Bash, Lua, Haskell, Elixir, XML, HTML, CSS, Diff, and more.
• Incremental Highlighting: AST-based incremental parsing and highlighting for efficient updates in streaming scenarios (e.g., AI chat, real-time editing).
• Rich Themes: 4 built-in themes including One Dark Pro, GitHub Light, Dracula Pro, and Solarized Light, with custom theme support.
• Code Block Components: Complete code block rendering with line numbers, configurable start lines, highlighted lines, diff mode, copy button, language label, collapsible/expandable, and streaming cursor animation.
• Custom Lexer Support: Extensible lexer API for adding support for additional programming languages.
• Token Click Interaction: Click callback for individual code tokens for interactive features.
• Light/Dark Themes: Built-in light and dark themes with explicit selection and custom theme support.

Add to your gradle/libs.versions.toml:

[versions]
codehigh = "2.0.0"

[libraries]
codehigh-render = { module = "io.github.zusrsoft:codehighlight-render", version.ref = "codehigh" }
codehigh-parser = { module = "io.github.zusrsoft:codehighlight-parser", version.ref = "codehigh" }

Then add it in your module's build.gradle.kts:

dependencies {
    implementation(libs.codehigh.render)
    implementation(libs.codehigh.parser)
}

If you do not use Version Catalog, you can add the dependency directly:

dependencies {
    implementation("io.github.zusrsoft:codehighlight-render:2.0.0")
    implementation("io.github.zusrsoft:codehighlight-parser:2.0.0")
}

Use codehighlight-parser directly when you only need tokenization, language registration, or incremental parsing without Compose rendering.

In a Compose Multiplatform project, you can use the CodeBlock component directly:

import com.hrm.codehigh.renderer.CodeBlock
import com.hrm.codehigh.theme.OneDarkProTheme

@Composable
fun MyScreen() {
    CodeBlock(
        code = """
            fun main() {
                println("Hello, CodeHigh!")
            }
        """.trimIndent(),
        language = "kotlin",
        theme = OneDarkProTheme,
        showLineNumbers = true,
        showCopyButton = true
    )
}

For inline code within text, the default style follows a single InlineCodeStyle contract: light themes use a #F6F8FA background with a #D0D7DE 1dp border, dark themes use a #30363D background with a #3D444D 1dp border, and text keeps the theme plain color. The border is part of the component style contract, so rendering and measurement stay aligned as long as you reuse the same style.

import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.runtime.remember
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.hrm.codehigh.renderer.InlineCode
import com.hrm.codehigh.renderer.InlineCodeDefaults

@Composable
fun MyText() {
    val baseStyle = InlineCodeDefaults.style()
    val customInlineCodeStyle = remember(baseStyle) {
        baseStyle.copy(
            textStyle = baseStyle.textStyle.copy(fontSize = 14.sp),
            contentPadding = PaddingValues(horizontal = 8.dp, vertical = 3.dp),
        )
    }

    InlineCode(text = "README.md")
    InlineCode(text = "notes", style = customInlineCodeStyle)
}

When you need to pre-occupy space or adjust layout, use the measurement API with the exact same InlineCodeStyle that you pass to InlineCode. The measured size already includes the style's padding and border, so you can reuse it directly for placeholders or constrained layout slots. measureInlineCodeSize returns an InlineCodeSize holding raw widthPx/heightPx values; convert them to Dp with size.width(density) / size.height(density):

import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.runtime.remember
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.text.rememberTextMeasurer
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.hrm.codehigh.renderer.InlineCodeDefaults
import com.hrm.codehigh.renderer.measureInlineCodeSize
import com.hrm.codehigh.theme.OneDarkProTheme

@Composable
fun MeasureExample() {
    val density = LocalDensity.current
    val textMeasurer = rememberTextMeasurer()
    val inlineCodeStyle = remember {
        val baseStyle = InlineCodeDefaults.style(OneDarkProTheme)
        baseStyle.copy(
            textStyle = baseStyle.textStyle.copy(fontSize = 14.sp),
            contentPadding = PaddingValues(horizontal = 8.dp, vertical = 3.dp),
        )
    }

    val size = remember(inlineCodeStyle) {
        measureInlineCodeSize(
            text = "README.md",
            language = "kotlin",
            style = inlineCodeStyle,
            density = density,
            textMeasurer = textMeasurer,
        )
    }

    Box(
        Modifier
            .width(size.width(density))
            .height(size.height(density))
    )
}

Avoid wrapping InlineCode in an extra outer border unless you also account for that added decoration in your own layout. The built-in measurement API only guarantees consistency for the style contract declared in InlineCodeStyle.

For streaming scenarios (e.g., AI chatbots), enable the isStreaming flag to show a blinking cursor animation at the end:

import com.hrm.codehigh.renderer.CodeBlock

@Composable
fun StreamingCode() {
    var code by remember { mutableStateOf("") }
    
    CodeBlock(
        code = code,
        language = "python",
        isStreaming = true // Shows blinking cursor at the end
    )
}

For long code blocks, use maxVisibleLines to make them collapsible (defaults to 500 lines; pass null for no limit):

CodeBlock(
    code = longCode,
    language = "java",
    maxVisibleLines = 20 // Collapse after 20 lines
)

You can create custom themes by implementing the CodeTheme interface:

import androidx.compose.ui.graphics.Color
import com.hrm.codehigh.ast.TokenType
import com.hrm.codehigh.theme.CodeTheme

object MyCustomTheme : CodeTheme {
    override val background = Color(0xFF1E1E1E)
    override val isDark = true
    
    override fun colorFor(type: TokenType): Color {
        return when (type) {
            TokenType.KEYWORD -> Color(0xFF569CD6)
            TokenType.STRING -> Color(0xFFCE9178)
            TokenType.COMMENT -> Color(0xFF6A9955)
            TokenType.NUMBER -> Color(0xFFB5CEA8)
            // ... other token types
            else -> Color(0xFFD4D4D4)
        }
    }
}

Use CompositionLocal to provide a theme globally:

import com.hrm.codehigh.theme.LocalCodeTheme
import com.hrm.codehigh.theme.GithubLightTheme

@Composable
fun App() {
    CompositionLocalProvider(LocalCodeTheme provides GithubLightTheme) {
        // All CodeBlocks in this scope will use GithubLightTheme
        CodeBlock(code = "...", language = "kotlin")
    }
}

You can register custom lexers for additional languages:

import com.hrm.codehigh.lexer.LanguageRegistry
import com.hrm.codehigh.lexer.Lexer

// Register your custom lexer
LanguageRegistry.register("my-language", MyCustomLexer)
LanguageRegistry.registerAlias("ml", "my-language") // Add alias

// Use it in CodeBlock
CodeBlock(
    code = myCode,
    language = "my-language" // Or "ml" via alias
)

• :codehighlight-parser: Parser SDK module, containing tokens, lexers, language registration, and incremental parsing.
• :codehighlight-render: Compose render SDK module, containing renderer components, themes, and parser integration.
• :codehighlight-preview: Preview components and sample datasets.
• :composeApp: Cross-platform Demo application.
• :androidApp: Android Demo application.
• :iosApp: iOS application entry module.

• Android: ./gradlew :androidApp:assembleDebug
• Desktop: ./gradlew :composeApp:run
• Web (Wasm): ./gradlew :composeApp:wasmJsBrowserDevelopmentRun
• iOS: Open iosApp/iosApp.xcworkspace in Xcode to run.

# Library modules (JVM)
./gradlew :codehighlight-parser:jvmTest :codehighlight-render:jvmTest :codehighlight-preview:jvmTest

# Demo application (tests currently empty, reserved)
./gradlew :composeApp:jvmTest

For a detailed list of supported features, please refer to: HIGHLIGHTER_COVERAGE_ANALYSIS.md

• Dual lexer tracks: both the legacy hand-written lexers and the newer declarative lexers exist side by side; consolidation is planned for a future release.
• Non-lazy rendering: CodeBlock internally renders lines in a regular Column rather than a LazyColumn. The default maxVisibleLines = 500 cap plus the collapse control bound the cost; full lazy rendering is left for a dedicated follow-up.

• Markdown — A dedicated Kotlin Multiplatform Markdown parsing and rendering library by the same author. If you need Markdown parsing or rendering, use it alongside codehigh.
• LaTeX — A Kotlin Multiplatform LaTeX parsing and rendering library by the same author. If you need both code highlighting and LaTeX rendering in your project, check it out!

This project is licensed under the MIT License - see the LICENSE file for details.