Google Summer of Code with Kotlin 2026

Getting started

1. Check out the GSoC FAQ and the program announcement.

2. 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 X or Kotlin Bluesky accounts to stay up to date on the latest news and developments.

   • Check out the Kotlin YouTube channel for tutorials, tips, and the latest updates.

3. 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.

How to apply

1. Check out the project ideas and select the one you would like to work on.

2. If you are not familiar with Kotlin, read the introductory info on the Kotlin website.

3. Refer to the GSoC contributor guidelines.

4. 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!

Kotlin Compiler Fuzzer (Kai) [Hard, 350 hrs]

In recent years, fuzzing has become a widely used technique for finding complex bugs in software. The Kotlin compiler is no exception: previous fuzzing efforts resulted in more than 200 deduplicated bugs across different compiler subsystems.

However, the existing fuzzer implementation is now obsolete and cannot be reasonably evolved further. The goal of this project is to build a new Kotlin compiler fuzzer, Kai, from scratch, based on previous experience and modern tools and techniques.

The main goal of this internship is to establish a solid foundation for future development of the fuzzer. The focus areas include:

• Designing a fuzzer architecture that supports pluggability

• Selecting tools for generating, mutating, and processing Kotlin code

• Defining reliable ways to detect compiler failures

• Designing proper workflows for collecting, classifying, and handling discovered issues

As a deliverable, we aim to create a prototype Kotlin compiler fuzzer that is modular and easy to evolve, unlike a monolithic implementation. Finding real compiler bugs would be a great bonus, but it is not the primary goal of this internship.

If you have preliminary questions about the project, contact the mentor at: marat.akhin [at] jetbrains.com

Expected outcomes

A prototype Kotlin compiler fuzzer with a pluggable architecture that supports future evolution.

Skills required (must-have)

• Proficiency in Kotlin or another JVM-based language

• Technical English sufficient for reading relevant papers and documentation

• Basic understanding of compilers

Skills required (nice-to-have)

• Familiarity with fuzzing or other forms of program analysis

• Experience with Kotlin compiler plugins, IDE plugins, or other pluggable systems

• Experience with greenfield developer tooling projects

What you will learn

• Hands-on experience with compiler fuzzing

• How internal developer tooling is designed and built

• How to design and implement pluggable systems

Possible mentor

Marat Akhin, JetBrains

Tasks for applicants

• Task #1
  Describe, at a high level, how you envision the architecture of a Kotlin compiler fuzzer.

• Task #2
  Based on the architecture from Task 1, which components are most important for pluggability, and why?

• Task #3
  Based on the architecture from Task 1, do you see opportunities to use LLMs or AI? If so, where and how?

• Task #4
  How would you test the fuzzer itself? Is back-testing possible? If yes, how?

• Task #5 (Bonus)
  Choose one component from the architecture in Task 1 and describe how it could be implemented in more detail.
  For example, which tools, libraries, or algorithms could be used?

Swift-to-Kotlin interop (PoC) [Hard, 350 hrs]

Modern software projects rarely live in a single language ecosystem. On Apple platforms, Swift is the primary language, while Kotlin is widely used for shared and cross-platform business logic. However, there is currently no straightforward way to import Swift APIs directly into Kotlin.

In this project, you will build on an existing open-source Swift–Java bridge and add Kotlin/Native as a target runtime. This includes designing how Swift APIs are exposed to Kotlin/Native, how calls cross the Swift/Kotlin boundary, and how object lifetimes are managed across runtimes.

The goal is to create a proof of concept for Swift-to-Kotlin/Native interop, document design decisions and trade-offs, and evaluate limitations and future directions.

Expected outcomes

A proof of concept for Swift-to-Kotlin/Native interop, with documented design decisions, trade-offs, limitations, and future directions.

Skills required (must-have)

• Currently pursuing or recently completed a degree in Computer Science or a related field

• Familiarity with Swift

• Interest in programming languages and interoperability

Skills required (nice-to-have)

• Familiarity with Kotlin

Possible mentor

Artem Olkov, JetBrains

Tasks for applicants

• Task #1
  Fork the swift-java repository and extend it with a new target that generates Kotlin sources.

• Task #2 (Optional)
  Extend the previous task by making the generated Kotlin code callable using the existing JNI or FFM runtime.

Tail call support in the Kotlin/Wasm backend [Medium, 90 hrs]

This project focuses on integrating the tail call proposal into the Kotlin/Wasm backend. The intern will design and implement tail call support and evaluate its impact through benchmarking.

Expected outcomes

Design and implementation of tail call support for Kotlin/Wasm, with benchmarks and evaluation.

Skills required (preferred)

General familiarity with interpreters and compilers, and interest in optimization and benchmarking.

Possible mentor

Charlie Zhang, JetBrains

Kotlin Education landscape report [Medium, 175 hrs]

Kotlin is taught and used in educational settings worldwide. This project aims to create a structured, up-to-date overview of where and how Kotlin is taught.

Expected outcomes

• A “Kotlin in Education” report highlighting trends and gaps

• Reusable datasets for internal and public use

• Input for future strategy

Skills required (preferred)

• Research and data analysis skills

• Interest in programming education and developer ecosystems

Possible mentor

Ksenia Shneyveys, JetBrains