Google Summer of Code with Kotlin 2023
This article contains the list of project ideas for Google Summer of Code with Kotlin 2023.
Project ideas
Kotlin Multiplatform protobufs [Hard, 350 hrs]
Description
Add support for Kotlin/Common protos to protoc with Kotlin/Native (iOS) runtime and Objective-C interop.
Motivation
While protobufs have many platform implementations, there isn't a way to use them in Kotlin Multiplatform projects.
Expected outcomes
Design and build Kotlin Multiplatform Protobuf support, culminating in contributions to:
Skills required (preferred)
Kotlin
Objective-C
C++
Kotlin Compiler error messages [Hard, 350 hrs]
Description
Add improved compiler error messages to the K2 Kotlin compiler: more actionable and detailed information (like Rust has).
Motivation
Rust compiler error messages are often regarded as being by far the most helpful of any compiler. The Kotlin K2 compiler provides a great foundation for better compiler errors in Kotlin but this potential is somewhat untapped.
Expected outcomes
Using StackOverflow and other data sources, uncover common compiler errors which would have significant value to users. Make contributions back to the compiler to improve those error messages.
Skills required (preferred)
Kotlin
Compiler architecture
Kotlin Multiplatform libraries [Easy or Medium, 175 or 350 hrs]
Description
Create and deliver (to Maven Central) Kotlin Multiplatform libraries that are commonly needed. For instance, compression, crypto.
Motivation
Kotlin Multiplatform is still fairly new and could use some additional libraries which are either platform independent (Kotlin/Common) and/or have platform implementations (expect/actual).
Expected outcomes
Design and deliver at least one Kotlin Multiplatform library with a greater priority on JVM/Android and Kotlin/Native (iOS) than other targets (Kotlin/JS).
Skills required (preferred)
Kotlin
Objective-C
Groovy to Kotlin Gradle DSL Converter [Medium, 350 hrs]
Description
The project aims to create a Groovy-to-Kotlin converter with a primary focus on Gradle scripts. We will start from basic use cases, such as when a user wants to paste Groovy-style dependency declarations to a Kotlin script and the IDE automatically converts them. Later, we will start supporting more complex code constructs and conversions of complete files.
Motivation
The Kotlin Gradle DSL is gaining popularity, so much so that it will soon become the default choice for building projects with Gradle. However, many documents and resources about Gradle still refer to Groovy, and pasting Groovy samples into build.gradle.kts requires manual editing. Furthermore, many new features around Gradle will be in Kotlin first, and consequently users will migrate from the Groovy DSL to the Kotlin DSL. The automatic code conversion of a build setup will therefore greatly ease this migration, saving a lot of time.
Expected outcomes
A plugin for IntelliJ IDEA that can convert Groovy code to Kotlin with the main focus on the Gradle DSL.
Skills required (preferred)
Basic knowledge of Gradle
Basic knowledge of parsers and how compilers work in general
Basic knowledge of Kotlin
Eclipse Gradle KTS editing [Medium, 350 hrs]
Description
Improve the experience of editing Gradle Kotlin Scripts (KTS) in Eclipse.
Motivation
IntelliJ IDEA and Android Studio have great support for editing KTS Gradle build scripts, but the Eclipse support is lacking. Ctrl-Click to definition, Code completion, Code error highlighting could all be improved.
Expected outcomes
Make contributions to the Gradle Eclipse plugin that improve the developer experience for editing KTS.
Skills required (preferred)
Kotlin
Gradle
Eclipse platform and plugins
Improve support for parameter forwarding in the Kotlin Plugin for IntelliJ IDEA [Medium, 350 hrs]
Description and motivation
The Kotlin plugin provides Kotlin language support in IntelliJ IDEA and Android Studio. In the scope of this project, you will improve parameter forwarding support for the plugin.
To prefer composition over inheritance is a widely known principle. IntelliJ IDEA provides great support for writing code that uses inheritance (completion and quick-fixes the IDE suggests), but the support for code that uses composition instead of inheritance has yet to be implemented.
The main problem of working with code that heavily uses composition is parameter forwarding. In particular:
The IDE doesn't suggest completing parameter declarations that can be forwarded as arguments to other functions that currently use default arguments.
The IDE doesn't rename the chain of forwarded parameters.
The IDE doesn't provide any quick-fixes that fill in all the required arguments with parameters that can be forwarded.
One notable example where such support would be greatly appreciated is Jetpack Compose. Android’s modern tool kit for building UI, Jetpack Compose heavily uses function composition and parameter forwarding. It quickly becomes tedious to work with @Composable functions because they have a lot of parameters. For example, androidx.compose.material.TextField has 19 parameters.
Expected outcomes
Improved parameter and argument completion suggestions in IntelliJ IDEA.
Implemented IDE quick-fixes that suggest filling in all the required arguments with parameters with the same names and types.
The Rename refactoring renames the chain of forwarded parameters.
All other IDE improvements around parameter forwarding and functions that have a lot of parameters.
Skills required (preferred)
Knowledge of Kotlin and Java
Ability to navigate in a large codebase
Enhance the kotlinx-benchmark library API and user experience [Easy, 175 hrs]
Description
kotlinx-benchmark is an open-source library for benchmarking multiplatform code written in Kotlin. It has a barebones skeleton but lacks quality-of-life features, such as fine-grained benchmark configuration (like time units, modes), feature parity between JVM and Kotlin/Native benchmarking, a command-line API, and modern Gradle support. Its documentation, integration tests, and examples are also lagging.
Motivation
The library has already been implemented, but it is sometimes difficult to use correctly and confuses some users. Improving the library’s user experience would greatly help the Kotlin community.
Expected outcomes
The library has clear documentation with usage examples.
The library API is simple and easy to use.
Options for benchmarking Kotlin/JVM code are also available for benchmarking code on other platforms.
Skills required (preferred)
Kotlin
Gradle internals
Parallel stacks for Kotlin Coroutines in the debugger [Hard, 350 hrs]
Description
Implement Parallel Stacks view for Kotlin coroutines to improve the coroutine debugging experience.
Motivation
Currently, support for coroutines debugging is very limited in IntelliJ IDEA. The Kotlin debugger has the Coroutines Panel that allows a user to view all of the coroutines and their states, but it's not very helpful when debugging an application with lots of coroutines in it. The JetBrains Rider has the Parallel Stacks feature that allows a user to inspect threads and their stack traces in a graph view, which could be a great way of inspecting coroutines.
Expected outcomes
Using the Kotlin coroutines debugger API, develop the IntelliJ IDEA plugin which would add the parallel stacks view for coroutines to the debugger. Find ways to improve the graph representation of coroutines.
Skills required (preferred)
Kotlin
Kotlin coroutines
IntelliJ IDEA plugin development