Kord is still in an experimental stage, as such we can't guarantee API stability between releases. While we'd love for you to try out our library, we don't recommend you use this in production just yet.

If you have any feedback, we'd love to hear it, hit us up on discord or write up an issue if you have any suggestions!

Kord is a coroutine-based, modularized implementation of the Discord API, written 100% in Kotlin.

Kord was created as an answer to the frustrations of writing Discord bots with other JVM libraries, which either use thread-blocking code or verbose and scope restrictive reactive systems. We believe an API written from the ground up in Kotlin with coroutines can give you the best of both worlds: The conciseness of imperative code with the concurrency of reactive code.

Aside from coroutines, we also wanted to give the user full access to lower level APIs. Sometimes you have to do some unconventional things, and we want to allow you to do those in a safe and supported way.

• Discord Gateway
• Discord Rest API
• High level abstraction + caching
• Discord Voice
• Support for multiple processes #7

Right now Kord should provide a full mapping of the non-voice API. We're currently working on a testing library for easy bot testing against a semi mocked client as well as our own command system to facilitate more complex bot development.

• Dokka docs
• Wiki

Replace {version} with the latest version number on maven central.

For Snapshots replace {version} with {branch}-SNAPSHOT

e.g: 0.7.x-SNAPSHOT

repositories {
    mavenCentral()
    // Kord Snapshots Repository (Optional):
    maven {
        url "https://oss.sonatype.org/content/repositories/snapshots"
    }
}

dependencies {
    implementation("dev.kord:kord-core:{version}")
}

repositories {
    mavenCentral()
    // Kord Snapshots Repository (Optional):
    maven("https://oss.sonatype.org/content/repositories/snapshots")
}

dependencies {
    implementation("dev.kord:kord-core:{version}")
}

<repository>
    <id>snapshots-repo</id>
    <url>https://oss.sonatype.org/content/repositories/snapshots</url>
    <releases>
        <enabled>false</enabled>
    </releases>
    <snapshots>
        <enabled>true</enabled>
    </snapshots>
</repository>

<dependency>
    <groupId>dev.kord</groupId>
    <artifactId>kord-core</artifactId>
    <version>{version}</version>
</dependency>

A higher level API, combining rest and gateway, with additional (optional) caching. Unless you're writing your own abstractions, we'd recommend using this.

suspend fun main() {
    val kord = Kord("your bot token")
    val pingPong = ReactionEmoji.Unicode("\uD83C\uDFD3")

    kord.on<MessageCreateEvent> {
        if (message.content != "!ping") return@on

        val response = message.channel.createMessage("Pong!")
        response.addReaction(pingPong)

        delay(5000)
        message.delete()
        response.delete()
    }

    kord.login {
        @OptIn(PrivilegedIntent::class)
        intents += Intent.MessageContent
    }
}

A low level mapping of Discord's REST API. Requests follow Discord's rate limits.

suspend fun main() {
    val rest = RestClient("your bot token")
    val channelId = Snowflake(605212557522763787)

    rest.channel.createMessage(channelId) {
        content = "Hello Kord!"

        embed {
            color = Color(red = 0, green = 0, blue = 255)
            description = "Hello embed!"
        }
    }
}

A low level mapping of Discord's Gateway, which maintains the connection and rate limits commands.

suspend fun main() {
    val gateway = DefaultGateway()

    gateway.on<MessageCreate> {
        println("${message.author.username}: ${message.content}")
        val words = message.content.split(' ')
        when (words.firstOrNull()) {
            "!close" -> gateway.stop()
            "!detach" -> gateway.detach()
        }
    }

    gateway.start("your bot token") {
        @OptIn(PrivilegedIntent::class)
        intents += Intent.MessageContent
    }
}

A mapping of Discord's Voice Connection, which maintains the connection and handles audio transmission.

If you want to use voice, you need to enable the voice capability, which is only available for Gradle

dependencies {
    implementation("dev.kord", "core", "<version>") {
        capabilities {
            requireCapability("dev.kord:core-voice:<version>")
        }
    }
}

suspend fun main() {
    val kord = Kord("your token")
    val voiceChannel = kord.getChannelOf<VoiceChannel>(id = Snowflake(1))!!

    voiceChannel.connect {
        audioProvider { AudioFrame.fromData(/* your opus encoded audio */) }
    }

    kord.login()
}

We will, there's an issue open to track the features we want/need to make a transition to MPP smooth.

Yes.