Contribo
ProgramsOrganizationsProjectsProposal StudioResourcesOrbit AIDashboard
Login
Login
Contribov1.0

Your premium companion for discovering, matching, and tracking paid open-source mentorship programs and verified starter issues.

Product

  • Programs Directory
  • Orbit AI
  • User Dashboard

Resources

  • Guides & Resources
  • Proposal Studio

Community

  • GitHub Repository
  • Code of Conduct

Legal

  • Privacy Policy
  • Terms & Conditions
  • Cookie Policy
  • Accessibility Statement

Made with love bySubhranshu Sekhar Dash

© 2026 Contribo. Built for the global open-source community.

PlatformProjects

Explore Projects

Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.

Confused which project to choose or don't know which one you are most suitable to work on?

Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.

Match with Orbit AI
Filters Clear
3883 Projects Found
Sort by

Docusaurus Internationalization & Search Engine v3

Beginner
Meta Open Source•2025Varies

Ready to Apply?

Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.

Start Proposal
Proposal Status
0% ProgressNot Started
Accepted Proposals
3 SimilarView →
Proposal Guide
Tailored DocsOpen →
Checklist & Review
Readiness AuditCheck →
90h (Small)

Upgrade the offline indexing and multi-lingual layout algorithms for high-throughput developer documentation portals.

reacttypescriptjavascript
Sébastien Lorber
Code
Proposal

Rust bindings for libnbd

intermediate
QEMU•2023Varies175h (Medium)

Network Block Device (NBD) is a protocol for exporting block devices, either between processes or across the network. Libnbd is a client library for talking to NBD servers. Currently, this library has bindings in various languages, including C, Golang and Python, but not in Rust. This project aims to make ergonomic Rust bindings for libnbd. The bindings should be automatically generated from the API of libnbd, so they will keep in sync as the library evolves. Apart from the actual bindings, several tests and examples will be created and good documentation will be written.

cassemblykvm+4
Student: Tage Johansson
Code
Proposal

Development of a vhost-user-vsock application and its integration with kata contianers

intermediate
QEMU•2021Varies175h (Medium)

<p>This project aims to realize a vhost-user-vsock application that will leverage the vhost-user protocol to emulate a virtio-vsock device in an external process. It will additionally provide the hybrid vsock over AF_UNIX interface, that was introduced by firecracker. Kata containers rely on virtio-vsock to create a communications channel between the runtime in the host and the agent in the guest. The vhost-user-vsock application, developed during the course of this program, would then be integrated into kata containers, who prefer that devices be emulated in an external userspace process to reduce the attack surface.</p>

cassemblykvm+4
Student: Harshavardhan Unnibhavi
Code
Proposal

Testing & Reliability Engineering for Kiwix Android

advanced
Kiwix•2026Varies350h (Large)

Improving the testing system of the Kiwix Android app to make tests more stable, faster, and reliable. This includes fixing flaky tests, improving CI/CD performance, and ensuring testing reflects real-world usage conditions.

pythonandroidjava+11
Student: atharvyadav22
Code
Proposal

Multi-modal cluttered scene analysis in knowledge intensive scenarios

intermediate
Institute for Artificial Intelligence•2017Varies175h (Medium)

<p>The objective of the project is to improve accuracy of objects' descriptions generated by the RoboSherlock package in difficult environments. Glossy transparent objects can not be properly detected by off-the-shelf RGB-D cameras which use infrared structured light, like Kinect. Or as another example occluded object may be not properly classified or even segmented as one peace. So the goal of this project is to study and implement algorithms which will address such problems.</p>

pythonrosc+++3
Student: Mykola Dolhyi
Code
Proposal

Case classes a la carte with scala.meta

advanced
Scala•2017Varies350h (Large)

<p>case classes are a very useful feature of the scala language, but can be limiting. For example, there is no way to modify the internal representation of a case class, leading to heap usage problems for larger applications that generate hundreds of millions of instances. And this projects aims to make case classes more flexible and optimized, in the same time giving a developer way to turn on/off all the options thus adjusting case classes for his needs.</p>

jvmscalallvm
Student: Vladimir Polushin
Code
Proposal

Optimizing Retrieval-Augmented Generation Pipelines for Accurate and Efficient Q&A Systems

intermediate
Scala Center•2025Varies175h (Medium)

This project aims to bring the power of Retrieval-Augmented Generation (RAG) into the Scala ecosystem by building a robust Scala interface to interact with RAG pipelines. I will design a Scala-compatible wrapper to connect with Python-based components like FAISS and Hugging Face Transformers via gRPC or HTTP APIs. The project will also include developing idiomatic Scala modules for preprocessing, querying, and evaluating textual data, making it easier for Scala developers to integrate RAG into NLP or search applications. By providing seamless interoperability and modular architecture, this will empower the Scala community to build intelligent, language-aware systems more efficiently.

#scala#scala_lang#jvm+7
Student: GOPI TRINADH MADDIKUNTA
Code
Proposal

Doodle Canvas

advanced
Scala Center•2024Varies350h (Large)

Doodle is a Scala library for 2D graphics, animation, data visualization, and creative coding. It supports JVM-based applications, utilizing Java2D for rendering, and for web browsers through SVG support. The library operates on a principle of composition (i.e Retained mode), enabling users to craft visuals by combining various elements. Doodle supports differences between backends through its tagless final architecture. Doodle currently supports retained mode graphics. Retained mode graphics involve representing the image as a data structure, creating a hierarchy of elements where each element relates to others. While this facilitates expressing parts of the image in terms of others, it poses challenges with large numbers of elements, making alignment difficult and memory usage proportional to the number of elements. On the other hand, immediate mode graphics represent the image as a function for drawing it. This method consumes memory proportional to the algorithmic complexity (Kolmogorov complexity) of describing the image. In immediate mode, we can have a single drawing context and can be used for high volume graphics. This enhancement will allow for more interactive experiences, opening up new possibilities for creative expression and application development. Further on, we wish to add advantages of the immediate mode, while retaining the advantages of retained mode. Combining both the methods can be very crucial for the developer willing to involve both the modes in a single method.

#scala#scala_lang#jvm+7
Student: Siddharth Banga
Code
Proposal

VIRTIO_F_IN_ORDER support for virtio devices

advanced
QEMU•2022Varies350h (Large)

VIRTIO_F_IN_ORDER is a new feature presented in VIRTIO 1.1. As mentioned on the project description page, VIRTIO_F_IN_ORDER is a feature that devices and drivers can negotiate when the device uses descriptors in the same order in which they were made available by the driver. This feature can help devices and drivers batch buffers and improve performance. Currently the devices and drivers available in Linux and QEMU do not support the VIRTIO_F_IN_ORDER feature. The only implementation is available in DPDK for the virtio-net driver. I will spend this summer to implement VIRTIO_F_IN_ORDER feature in both Linux and QEMU, and in both split and packed virtqueue layouts. Patches will be sent as soon as possible.

cassemblykvm+4
Student: Zhi Guo
Code
Proposal

Porting of Scalafix ExplicitResultTypes rule to Scala 3

intermediate
Scala Center•2022Varies175h (Medium)

The ExplicitResultTypes rule of the Scalafix linting tool is responsible for inferring and explicitly adding the types for “val”, “var” and “def” members. Currently this rule isn’t available in Scala 3 and this project's goal is to port it to Scala 3 so that the types can be automatically added in a codebase by running scalafix on your local machine, as part of a pre-commit hook or as part of your CICD pipeline, for example via the sbt-scalafix plugin. This feature proposed here will enrich scala developers' experience by completing their codebase automatically with the use of scalafix, hence making the code more readable, explicit, consistent and maintainable in the long term.

#scala#scala_lang#jvm+7
Student: Razvan Vacaru
Code
Proposal

Implementation of Coroutine-­Based Utilities

intermediate
Scala•2016Varies175h (Medium)

<p>Scala Coroutines generalizes subroutines in a clean and composable way, but currently provides little value to the average user who wants to use coroutines at a high level. We propose to build an extras subproject that will include common use­-cases for coroutines­- for example, enumerators, continuations, and async/await.</p>

jvmscalallvm
Student: Jess Smith
Code
Proposal

Source Code Preserving AST

intermediate
Scala•2016Varies175h (Medium)

<p>The goal of this project is to design a unifying AST which helps preserving source ­code attributes thereby allowing IDEs to use this as a backend to implement necessary refactorings and enhancing developer workflow.</p>

jvmscalallvm
Student: Akhilesh Srikanth
Code
Proposal

CBT IntelliJ IDEA‎ plugin

intermediate
Scala•2017Varies175h (Medium)

<p>Add an <code>IntelliJ IDEA</code>‎ support for the <code>CBT</code> by writing a plugin or extending an exciting <code>Scala</code> plugin.</p>

jvmscalallvm
Student: Ilya Kirillov
Code
Proposal

TCG Plugin: Cache Modelling

advanced
QEMU•2021Varies350h (Large)

<p>Since cache performance is one of the essential metrics that may bottle-neck the overall performance of the system, monitoring it and identifying points of weakness (and resolving them) may drastically improve the performance of the system.</p> <p>In this project, a cache modelling QEMU TCG-plugin is proposed and implemented, with simplicity rather than intricacy in mind, that models the behavior of caches when given the working set proposed by a program, or system-wide working set, report the cache performance, and identify the frequently cache-missing instructions.</p>

cassemblykvm+4
Student: Mahmoud Mandour
Code
Proposal

Complete AMD virtualization emulation

intermediate
QEMU•2021Varies175h (Medium)

<p>QEMU already includes a basic implementation of the virtualization extensions that are found in AMD processors. This implementation, however, is not complete and contains several bugs. The project's primary purpose is to complete the AMD virtualization emulation. The project includes:</p> <ul> <li>Fixing bugs in the implementations, using the kvm-unit-tests suite</li> <li>Adding support for new features such as vGIF or vVMLOAD/vVMSAVE</li> </ul> <p>(<a href="https://wiki.qemu.org/Google_Summer_of_Code_2021#Complete_AMD_virtualization_emulation" target="_blank">https://wiki.qemu.org/Google_Summer_of_Code_2021#Complete_AMD_virtualization_emulation</a>)</p>

cassemblykvm+4
Student: Lara Lazier
Code
Proposal

Fluent library for Files and Processes in Fs2

advanced
Scala Center•2024Varies350h (Large)

FS2 is a key part of the Typelevel ecosystem for streaming I/O operations in Scala, offering powerful APIs that provide a wide range of functionality for different use cases. However, its use in smaller scripts often introduces unnecessary complexity and boilerplate, hindering productivity and accessibility. This project proposes the development of Fs2 OS, a fluid and intuitive library designed to revolutionise the way developers interact with files and processes.

#scala#scala_lang#jvm+7
Student: Gaby
Code
Proposal

Fast Snapshot Load for QEMU

intermediate
QEMU•2026Varies175h (Medium)

QEMU's current snapshot load blocks until all guest RAM is loaded before starting execution. This project implements on-demand snapshot loading using userfaultfd - loading only device state upfront, then serving guest page faults on-demand while a background thread prefetches remaining pages. The design builds on existing postcopy migration and mapped-ram infrastructure. Deliverables include a working fast snapshot load implementation, unit tests in migration-test.c, and complete documentation.

cassemblykvm+4
Student: Aadesehveer Singh
Code
Proposal

Workflows4s : Web UI for Tracking & Debugging

advanced
Scala Center•2025Varies350h (Large)

This project aims to create a dedicated web-based user interface for the workflows4s library to address the current lack of visual debugging tools. By building a full-stack solution with a ScalaJS frontend, the UI will enhance workflow development by allowing developers to visually inspect detailed workflow state at any point in history, clearly see the execution paths taken within a workflow diagram, and easily navigate the workflow's history using a timeline. Ultimately, this visual feedback will make understanding, developing, and debugging complex workflows significantly more accessible and intuitive compared to relying solely on logs.

#scala#scala_lang#jvm+7
Student: Atharva-Kanherkar
Code
Proposal

Implementation of Deep Learning Annotators written in Python into RoboSherlock

intermediate
Institute for Artificial Intelligence•2018$3k–$6.6k175h (Medium)

<p>In GSoC, I propose to introduce deep learning annotators in RoboSherlock for more various task. Because many deep learning frameworks and repositories are written in Python, I first improve RoboSherlock system to be able to run annotators written in Python. Then, I implement annotators using deep learning such as object detection, semantic segmentation, instance segmentation and so on into RoboSherlock system. As the final result of the project, the real robot execute a manipulation task with the deep-learning annotators. The main contributions of my proposal will be as belows:</p> <ul> <li>Improve Robosherlock to execute annotators written in Python</li> <li>Introduce several useful deep-learning annotators in Robosherlock</li> <li>Implement the new annotators in daily-life task with real robot</li> </ul>

pythonrosc+++3
Student: Shingo Kitagawa
Code

Breaking the Thread Barrier: Boosting I/O Performance with io_uring and FS2

advanced
Scala Center•2023Varies350h (Large)

The current state of the asynchronous I/O on the JVM involves using separate selector threads to manage I/O events through system functions like epoll or kqueue. Although frameworks like Netty and NIO2 make this approach seem reasonable, the use of separate event loop threads is not without cost. In high-RPS services, these threads can compete for CPU time with worker threads executing application tasks, leading to resource contention and potentially significant performance loss. In contrast, Cats Effect offers a different threading model, integrating I/O and application tasks into a single runtime system, reducing contention an enhancing overall efficiency. io_uring, the key component of this project, offers two major advantages: (1) it enables all supported syscalls to become asynchronous from the application’s perspective, allowing for multiple syscalls to be initiated in parallel without blocking the calling thread, and (2) it uses a pair of ring buffers for syscall submission and completion events that are shared between the application and the kernel, dramatically reducing the overhead of calling from userspace into kernelspace. When integrated with Cats Effect, io_uring can significantly improve the efficiency of syscalls, requiring fewer calls into kernelspace during the worker loop. This proposal brings two key innovations together: a new threading model and a new I/O API. By integrating Cats Effects and FS2 with io_uring, we aim to develop an alternative solution to minimize the inefficiencies found in the traditional model, offering a more efficient and performant solution for I/O-intensive applications.

#scala#scala_lang#jvm+7
Student: Antonio Jimenez
Code

AMD IOMMU interrupt remapping and other improvements

intermediate
QEMU•2016Varies175h (Medium)

<p>This project aims to get the current AMD IOMMU patches merged into Qemu as well as introduce interrupt remapping support to the current AMD IOMMU implementation. Interrupt remapping is a feature implemented on Intel and AMD iommus that allows interrupts from peripheral devices to be intercepted, validated and posted to the specific CPU cores based on the information stored in the in the relevant data structures programmed by System Software.</p>

cassemblykvm+4
Student: asla
Code
Proposal

Out-of-process RDP server for QEMU

intermediate
QEMU•2023Varies175h (Medium)

QEMU is able to export its display over D-Bus. We can create a server that uses the provided API to export the display over the network. There is already an experimental VNC server, but RDP is more popular and would provide more features and better efficiency.

cassemblykvm+4
Student: Mihnea Buzatu
Code
Proposal

Asynchronous request handling for virtiofsd

advanced
QEMU•2025Varies350h (Large)

Virtio-fs is a shared file system that lets virtual machines access a directory tree on the host. Virtiofsd is the user-level host daemon that communicates with the guest VMs and performs I/O operations on the shared directory tree. Currently, virtiofsd processes FUSE-based I/O requests in a mostly sequential manner. Even though it uses a thread pool, concurrency is limited by the number of available threads. This project aims to enable truly asynchronous I/O request handling in virtiofsd by leveraging io_uring. The deliverables will include a complete patch implementing asynchronous I/O handling, along with a performance evaluation of the resulting system.

cassemblykvm+4
Student: Kaisei Hishida
Code
Proposal

Flexible Fast Parser Combinators

beginner
Scala•2016Varies90h (Small)

<p>The FarstParse library is a simple replacement for the original Scala Parser Combinators. It uses the same ideas and implements the same functionality with the only few main operators, but nevertheless provides much more wide support for logging and great performance. But now it can handle only Char/String parsers. And this project aims at the development of architecture for parsers of arbitrary classes and streaming data.</p>

jvmscalallvm
Student: vovapolu
Code
Proposal
Showing 865 - 888 of 3883 Projects
3536373839
Proposal
Proposal