This article contains the list of project ideas for Google Summer of Code with Kotlin, and contributor guidelines.
Kotlin resources:
- Kotlin GitHub repository
- Kotlin Slack and the #gsoc Slack channel
If you got any questions, contact us via [email protected]
{type="note"}
-
Check out the GSoC FAQ and the program announcement.
-
Familiarize yourself with the Kotlin language:
- The official Kotlin website is a great place to start.
- Read the official documentation to get a better understanding of the language.
- Take a look at the Kotlin courses on JetBrains Academy or the Android team’s Training options.
- Follow the Kotlin Twitter account to stay up to date on the latest news and developments.
- Check out the Kotlin YouTube channel for tutorials, tips, and the latest updates.
-
Get to know the Kotlin open source community:
- Explore the general Kotlin contribution guidelines.
- Join the Kotlin Slack channel to connect with other developers and get help with any questions you may have.
- Join the #gsoc channel to ask questions and get support from the GSoC team.
Applications are accepted from March 20 to April 4, 2023.
{type="note"}
- Check out the project ideas and select the one you would like to work on.
- If you are not familiar with Kotlin, read the introductory info on the Kotlin website.
- Refer to the GSoC contributor guidelines.
- Apply via the GSoC website.
- We suggest that you write a working code sample relevant to the proposed project. You can also show us any code sample that you are particularly proud of.
- Describe why you are interested in Kotlin and your experience with it.
- If you participate in open source projects, please reference your contribution history.
- If you have a GitHub, Twitter account, blog, or portfolio of technical or scientific publications, please reference them as well.
- Disclose any conflicts with the GSoC timeline due to other commitments, such as exams and vacations.
Thank you! We look forward to reading your applications!
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:
- GitHub – protocolbuffers/protobuf: Protocol Buffers – Google's data interchange format
- GitHub – google/protobuf-gradle-plugin
- Kotlin Multiplatform Gradle Plugin
Skills required (preferred)
- Kotlin
- Objective-C
- C++
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
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
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
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
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
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
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