DEV Community: The AX code

Building Beautiful Forms with Kotlin Multiplatform: Introducing Multiplat

The AX code — Wed, 22 Apr 2026 16:41:41 +0000

Building Beautiful Forms with Kotlin Multiplatform: Introducing Multiplat

In the fast-paced world of mobile development, the ability to share code between Android and iOS is no longer just a "nice-to-have"—it's a competitive necessity. Kotlin Multiplatform (KMP) has revolutionized how we share business logic, but sharing UI and complex interaction patterns like forms has often remained a fragmented challenge.

Enter Multiplat, the successor to the ComposeForms library. It’s designed to make building forms across platforms not just efficient, but enjoyable.

The Problem: The Fragmented Form Fatigue

Every developer knows the pain of building forms. You have to handle:

State Management: Keeping track of input values across orientation changes and platform cycles.
Validation Logic: Validating email formats, required fields, and custom rules—often writing the same logic twice for Android and iOS.
UI Consistency: Ensuring a "Password" field looks and behaves similarly on both platforms while respecting native design cues.
Boilerplate: Managing focuses, keyboard actions, and error states manually.

When you multiply this by two platforms, you get "Fragmented Form Fatigue."

The Solution: Write Once, Render Everywhere

Multiplat leverages Compose Multiplatform to provide a unified, type-safe DSL for form construction. With Multiplat, you define your form structure, validation rules, and styling in a single commonMain codebase.

Why Multiplat?

🚀 100% Shared Logic & UI: No more platform-specific UI code for forms. One source of truth for everything.
📝 Type-Safe DSL: A readable, Kotlin-first way to declare forms. It feels like writing a config file, but with the power of full-blown Kotlin.
✅ Built-in Validation: A powerful, extensible validation engine that catches errors as they happen.
🎨 Material 3 Driven: Built on modern design standards, ensuring your forms look premium out of the box.

See it in Action

Defining a form with Multiplat is remarkably simple:

val contactForm = remember {
    form {
        section("Contact Information") {
            text("full_name") {
                label = "Full Name"
                placeholder = "John Doe"
                required("Name is essential")
            }
            email("email_address") {
                label = "Email"
                required("Email is required")
                regex("^(.+)@(.+)$".toRegex(), "Invalid email format")
            }
        }

        section("Message") {
            longText("message") {
                label = "Your Message"
                maxLines = 5
            }
        }

        submitButton("Send Message")
    }
}

Rendering is even easier:

RenderForm(
    form = contactForm,
    context = rememberFormContext(contactForm)
)

Use Cases: From Simple to Sophisticated

Multiplat isn't just for login screens. Its modular architecture supports a wide range of scenarios:

User Onboarding: Multi-step registration flows with complex validation.
E-commerce: Checkout forms with dynamic address validation.
Professional Tools: Data entry forms for inventory management or field research.
Surveys: Quickly iterate on feedback forms without touching platform-specific code.

The Future of Multiplat

As the successor to ComposeForms, Multiplat is built for the modern KMP ecosystem. We are committed to expanding the library with:

More Field Types: Date pickers, file uploaders, and more.
Advanced Layouts: Grid-based forms and adaptive layouts for tablets.
Deeper Platform Integration: Leveraging native auto-fill and keyboard features seamlessly.

Join the Journey

Building cross-platform apps shouldn't mean compromising on the developer experience or user interface. Multiplat is here to bridge that gap.

Check out the Multiplat GitHub Repository to get started, contribute, or provide feedback. Let's make form development beautiful.

Automating C Bindings in Kotlin Multiplatform

The AX code — Wed, 22 Apr 2026 00:28:37 +0000

Bridging the Gap: Automating C Bindings in Kotlin Multiplatform

Integrating native C/C++ code into a Kotlin Multiplatform (KMP) project often feels like paying a "native tax." You have to maintain multiple glue layers: JNI for Android and JVM, CInterop for iOS and Native, and often redundant build logic in CMake and Gradle.

What if you could maintain a single C source directory and have the bindings generated for you automatically?

Introducing CBindingKMP — a library designed to automate the bridge between your performance-critical C code and your KMP applications.

The Problem: The "Native Tax"

When you decide to use C in a KMP project, you typically face three distinct challenges:

Android & JVM: You must write manual JNI wrappers (C functions with long, brittle names like Java_com_example_GeneratedNativeKt_add_1numbersJNI) and use CMake to build shared libraries.
iOS & Native: You need to configure .def files and use Kotlin/Native's CInterop tool.
Synchronization: Every time you change a C function signature, you have to manually update the JNI wrapper, the Kotlin external fun declaration, and the CInterop headers.

This redundancy is a breeding ground for bugs and maintenance headaches.

The Solution: CBindingKMP

CBindingKMP turns your C headers into a Single Source of Truth. By pointing our Gradle plugin to your headers, it automatically:

Parses your C function declarations.
Generates JNI-compliant C wrappers for Android and JVM.
Generates Kotlin external fun declarations that map directly to the JNI wrappers.
Wires everything into the Gradle build cycle.

How It Works: Under the Hood

The architecture is designed to be seamless. Here's how the automation flow looks:

graph TD
    subgraph "Source"
        C["C Headers (.h)"]
        Impl["C Implementation (.c)"]
    end

    subgraph "JNI Generator Plugin"
        Task["generateJni Task"]
        Parser["Regex Parser"]
        GenC["jni_gen_bridge.c"]
        GenK["GeneratedNative.kt"]
    end

    subgraph "Compilation"
        CMake["CMake (Android/JVM)"]
        CInterop["cinterop (iOS/Native)"]
    end

    subgraph "Final Artifacts"
        Lib["Shared Library (.so / .dylib)"]
        Klib["Kotlin Library (.klib)"]
    end

    C --> Task
    Task --> Parser
    Parser --> GenC
    Parser --> GenK
    Impl --> CMake
    GenC --> CMake
    C --> CInterop
    CMake --> Lib
    CInterop --> Klib
    GenK --> Klib

Type Mapping

We handle the heavy lifting of type conversion between C, JNI, and Kotlin types:

C Type	JNI Type	Kotlin Type
`int`	`jint`	`Int`
`float`	`jfloat`	`Float`
`double`	`jdouble`	`Double`
`void`	`void`	`Unit`

Quick Start: From C to Kotlin in 3 Steps

1. Define your C function

Create a simple header in native/c/mylib.h:

int add_numbers(int a, int b);

2. Build the project

Run the Gradle assemble task. The plugin will automatically parse the header and generate the bridge.

./gradlew :shared:assemble

3. Call from Kotlin

The generated bindings are ready to use immediately:

import com.abyxcz.cbindingkmp.shared.generated.add_numbersJNI

val result = add_numbersJNI(10, 20)
println("Result from C: $result")

Why Use CBindingKMP?

🚀 Zero Glue Code: Stop writing JNI boilerplate.
🛠 Unified Source: One directory for all platforms.
📱 Full Platform Support: Android, iOS, JVM, and Native.
⚙️ Gradle Integrated: Fits right into your existing workflow.

If you're building performance-intensive apps—think image processing, cryptography, or edge AI—CBindingKMP lets you focus on the logic, not the plumbing.

Check out the project on GitHub and let us know what you think!