KMQTT

1.0.0indexed

Provides an MQTT 3.1.1/5.0 client and broker supporting TCP, TLS, and WebSocket connections. Features include clustering, enhanced authentication, session persistence, and various platform compatibility.

JSJVMNative·davidepianca98/KMQTT

295

Stars

Used by

dependents

—

Health

/ 100

KMQTT

KMQTT is a Kotlin Multiplatform MQTT 3.1.1/5.0 Client and Broker, with the objective of targeting the most possible build targets.

Client features

:x: = To Do
:white_check_mark: = Supported
:heavy_plus_sign: = Work In Progress

Platform	MQTT 3.1.1	MQTT 5.0	TCP	TLS	Websocket
JVM	:white_check_mark:	:white_check_mark:	:white_check_mark:	:white_check_mark:	:white_check_mark:
Windows X64	:white_check_mark:	:white_check_mark:	:white_check_mark:	:white_check_mark:	:white_check_mark:
Linux X64	:white_check_mark:	:white_check_mark:	:white_check_mark:	:white_check_mark:	:white_check_mark:
Linux ARM64	:white_check_mark:	:white_check_mark:	:white_check_mark:

Broker features

:x: = To Do
:white_check_mark: = Supported
:heavy_plus_sign: = Work In Progress

Getting Started with the client

Library

Gradle

If you are getting an error saying that OpenSSL hasn't been found, please copy the correct file from https://github.com/davidepianca98/KMQTT/tree/master/kmqtt-common/src/nativeInterop in your project's main directory.

Kotlin Multiplatform plugin

On the Kotlin Multiplatform plugin you only need to require the dependency on the common source set and the platform specific parts will be automatically imported.

repositories {
    mavenCentral()
}

kotlin {
    jvm()
    mingwX64()
    macosX64()

    sourceSets {
        commonMain {
            dependencies {
                implementation("io.github.davidepianca98:kmqtt-common:1.0.0")
                implementation("io.github.davidepianca98:kmqtt-client:1.0.0")
            }
        }
    }
}

Single platform project

repositories {
    mavenCentral()
}
dependencies {
    implementation("io.github.davidepianca98:kmqtt-common-jvm:1.0.0")
    implementation("io.github.davidepianca98:kmqtt-client-jvm:1.0.0")
}

Replace jvm with js, linuxx64, linuxarm64, mingwx64, macosx64, macosarm64, iosarm64, iosX64, iossimulatorarm64, tvossimulatorarm64, tvosx64, tvosarm64, watchosarm32, watchosarm64, watchosx64, watchossimulatorarm64 based on the desired target.

Quick start code example

This code starts the MQTT client on port 1883 without TLS encryption. You can play with MQTTClient() constructor parameters to set the various settings

fun main() {
    val client = MQTTClient(
        MQTTVersion.MQTT5,
        "test.mosquitto.org",
        1883,
        null
    ) {
        println(it.payload?.toByteArray()?.decodeToString())
    }
    client.subscribe(listOf(Subscription("/randomTopic", SubscriptionOptions(Qos.EXACTLY_ONCE))))
    client.publish(false, Qos.EXACTLY_ONCE, "/randomTopic", "hello".encodeToByteArray().toUByteArray())
    client.run() // Blocking method, use step() if you don't want to block the thread
}

TLS code example

The certificates and key must be in PEM format, and they can be either a path to the PEM file or the actual PEM string. The password can be null if the private key has no protection.

fun main() {
    val client = MQTTClient(
        MQTTVersion.MQTT5,
        "test.mosquitto.org",
        8883,
        TLSClientSettings(
            serverCertificate = "mosquitto.org.crt",
        )
    ) {
        println(it.payload?.toByteArray()?.decodeToString())
    }
    client.subscribe(listOf(Subscription("/randomTopic", SubscriptionOptions(Qos.EXACTLY_ONCE))))
    client.publish(false, Qos.EXACTLY_ONCE, "/randomTopic", "hello".encodeToByteArray().toUByteArray())
    client.run() // Blocking method, use step() if you don't want to block the thread
}

Getting Started with the broker

Executables

You can download the executables for your platform under the release tab

Program Arguments

Library

Gradle

Kotlin Multiplatform plugin

On the Kotlin Multiplatform plugin you only need to require the dependency on the common source set and the platform specific parts will be automatically imported.

repositories {
    mavenCentral()
}

kotlin {
    jvm()
    mingwX64()
    macosX64()
    sourceSets {
        commonMain {
            dependencies {
                implementation("io.github.davidepianca98:kmqtt-common:1.0.0")
                implementation("io.github.davidepianca98:kmqtt-broker:1.0.0")
            }
        }
    }
}

Single platform project

repositories {
    mavenCentral()
}
dependencies {
    implementation("io.github.davidepianca98:kmqtt-common-jvm:1.0.0")
    implementation("io.github.davidepianca98:kmqtt-broker-jvm:1.0.0")
}

Replace jvm with js, linuxx64, linuxarm64, macosarm64, macosx64, mingwx64 based on the desired target.

Quick start code example

This code starts the MQTT broker on port 1883 without TLS encryption. You can play with Broker() constructor parameters to set the various settings

fun main() {
    Broker().listen()
}

TLS code example

The keystore must be in PKCS12 format, the keystore password can be null

fun main() {
    val broker = Broker(
        tlsSettings = TLSSettings(keyStoreFilePath = "keyStore.p12", keyStorePassword = "password"),
        port = 8883
    ).listen()
    broker.listen()
}

Authentication code example

fun main() {
    val broker = Broker(authentication = object : Authentication {
        override fun authenticate(clientId: , username: ?, password: ?):  {
            
             username ==  && password?.toByteArray()?.decodeToString() == 
        }
    })
    broker.listen() 
}

Authorization code example

fun  {
     broker = Broker(authorization =  : Authorization {
         :  {
            
             topicName == 
        }
    })
    broker.listen() 
}

Message interceptor code example

fun main() {
    val broker = Broker(packetInterceptor = object : PacketInterceptor {
        override fun packetReceived(clientId: String, username: ?, password: ?, packet: ) {
             (packet) {
                 MQTTConnect -> println(packet.protocolName)
                 MQTTPublish -> println(packet.topicName)
            }
        }
    })
    broker.listen() 
}

Internal publish code example

fun main() {
    val broker = Broker()
    broker.publish(
        retain = false,
        topicName = "test/",
        qos = Qos.AT_MOST_ONCE,
        properties = MQTTProperties(),
        "testPayload".toByteArray().toUByteArray()
    )
    broker.listen() // Blocking method, use step() if you don't want to block the thread
}

Other advanced functionality

MQTT5 Enhanced Authentication: set the enhancedAuthenticationProviders Broker constructor parameter, implementing the provider interface EnhancedAuthenticationProvider.

Session persistence: set the persistence Broker constructor parameter, implementing Persistence interface.

Bytes metrics: set the bytesMetrics Broker constructor parameter, implementing BytesMetrics interface.

Related libraries

Surfaced from shared tags and platforms — no rankings paid for.

kotlinx.collections.immutable★ 1.4k

KotlinImplements immutable and persistent collection interfaces with efficient, order-preserving options. Offers conversion functions, `+` and `-` operators, and a `mutate` extension for simplified modifications.Shared: kotlin-native

kotlinx-benchmark★ 635

KotlinToolkit for running benchmarks on multiplatform code, offering low noise, reliable results, statistical analysis, and detailed performance reports. Supports various target configurations and custom benchmark profiles.Shared: kotlin-native

uuid★ 578

benasher44Generates thread-safe, RFC4122-compliant UUIDs, compatible with iOS/Mac `NSUUID` and Java `java.util.UUID`. Ensures correctness through extensive testing. Aims to contribute functionality to the standard library.Shared: kotlin-native

redux-kotlin★ 505

reduxkotlinStandard redux implementation fostering an ecosystem of middleware, store enhancers, and dev tools. Offers modular development, supports multiple platforms, and promotes open development and community involvement.Shared: kotlin-native

moko-kswift★ 356

icerockdevGradle plugin generates Swift-friendly APIs from a native framework. Converts sealed classes/interfaces to Swift enums, supports platform class extensions, and allows custom generator creation based on metadata.Shared: kotlin-native

kfswatch★ 135

irgalyMonitors file system changes across multiple directories, emitting events such as create, delete, and modify. Allows observing file events using flows, supports multiple platforms, and provides raw event access for debugging.Shared: kotlin-native

-h	127.0.0.1	Interface address to bind the server to
-p	1883	Server port to listen to
--max-connections	128	The maximum number of TCP connections to support
--key-store	null	The path to the PKCS12 keystore containing the private key and the certificate for TLS, if null TLS is disabled
--key-store-psw	null	The password of the PKCS12 keystore indicated in --key-store, if the keystore has no password set, don't set the option
--wsp	null	The WebSocket port to listen to