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
4718 Projects Found
Sort by

Activity Masking in rav1e

intermediate
Mozilla•2019Varies

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 →
175h (Medium)

<h3>Adaptive Quantization based on an activity mask.</h3> <p>The human eye is more tolerant towards errors in areas of high activity and is quick to find out errors in areas of lower activity. To leverage this psychovisual characteristic, quantization can be made adaptive based on the activity mask. Activity masking will be implemented in two phases:</p> <ol> <li>Biasing the RDO based on the activity at a specific region.</li> <li>Varying the quantizer offsets across segments based on activity.</li> </ol> <h3>Optimizing the quantization algorithm using Trellis Quantization:</h3> <p>Using Trellis Quantization passing the activity measurements as the weights to the trellis. The output of this Activity masked Trellis is used for quantization. This helps the quantization perform better in PSNR metrics while increasing perceptual image quality significantly. This is a feature that has proved to perform better in the case of x264 and is expected to yield similar results at rav1e too.</p>

pythonjavascriptc+++8
Student: Shreevari SP
Code
Proposal

Adding new Machine Learning Models and Operations

intermediate
Python Software Foundation•2020Varies175h (Medium)

<p>The aim of the project is to facilitate NLP tasks in DFFML by adding support for two of the most popular NLP libraries: HuggingFace Transformers and spaCy.</p>

pythonmercurialjavascript+3
Student: Himanshu Mani Tripathi
Code
Proposal

OpenVINO Profiling using VTune & GTPin

advanced
OpenVINO Toolkit•2026Varies350h (Large)

The existing GPU profiling workflow in OpenVino, through benchmark_app connects kernels to the model layers (primitives) and reports their execution times. However, this level of abstraction is too coarse to identify kernel instruction level insights. Intel GTPin, on the other hand, provides instruction level GPU kernel metrics like clock cycle counts, but is unable to directly map such metrics to specific inference or layers. This project aims to build a GTPin-centered profiling capability within OpenVINO to identify hotspot kernels and analyze their execution characteristics. The approach involves integrating controlled GTPin profiling into the inference flow, developing a custom GTPin tool for collecting kernel-level metrics, and progressively interpreting these metrics using signals from OpenVINO performance counters, and kernel metadata. The expected deliverable is a GTPin-based profiling workflow integrated into OpenVINO, capable of identifying bottleneck kernels, providing insight into their behavior, and offering indicative optimization directions, with validation using tools such as VTune.

pythonc++x86+1
Student: Jayakaran
Code
Proposal

Add infrastructure to handle the "Drop" trait

beginner
GNU Compiler Collection (GCC)•2026Varies90h (Small)

gccrs still lacks support for Rust’s Drop trait, which is a core part of Rust’s resource management model. Without it, values that require cleanup cannot be handled correctly at scope exit, which makes gccrs incomplete with respect to important Rust semantics. This project proposes an incremental implementation of Drop support in gccrs, starting from a narrow and testable subset rather than attempting full drop elaboration at once. The first stage focuses on scope-exit destructor insertion for simple non-generic local variables using existing backend cleanup machinery. From there, the implementation will be extended to support multiple locals, correct reverse drop order (LIFO), and, if feasible, initial nested-scope cleanup. More advanced cases such as moved values, temporaries, partially initialized values, and generic Drop will be treated as later-stage or stretch work. The main deliverables are: an initial implementation of scope-exit Drop support for a restricted subset of local variables, support for correct LIFO drop ordering, regression tests covering the supported behavior, and documentation describing the implementation approach, supported subset, and current limitations.

cc++openmp+3
Student: Janet Chien
Code
Proposal

Keploy Typescript/Javascript SDK

intermediate
Keploy•2023Varies175h (Medium)

My goal is to enhance the Keploy Typescript SDK's versatility and accommodate a wider range of developers and use cases. I aim to make it more flexible, allowing for easier future integration of additional technologies/databases by creating reusable code blocks. Major deliverables: 1. Add support for Httpclients in TypeScript 2. Add support for popular SQL databases using Sequelize 3. Add support for MongoDB database 4. Add support for cloud storage services 5. Add support for Redis and Elasticsearch 6. Sample Project: Include a sample application that will contain all the above integrations in the Sample-Typescript repo for seamless testing of each implementation.

javagolangnode+4
Student: Hermione Dadheech
Code
Proposal

Scribe-Data: Refactor into a Multi-Purpose Wikidata Language Pack CLI Tool

intermediate
Wikimedia Foundation•2024Varies175h (Medium)

The goal of this project is to transform the Scribe-Data tool into a versatile, multi-purpose Command Line Interface (CLI) tool. This tool will enable direct access to language data from Wikidata through command-line commands, supporting a broader range of languages and word types.

javascripthtmlphp+7
Student: mhmohona
Code
Proposal

Camera and Gimbal enhancements

intermediate
ArduPilot•2023Varies175h (Medium)

This project aims to fix camera and gimbals related issues in ArduPilot, upgrading currently supported messages and adding support for new mavlink messages. Some new and exciting features are also introduced, those are: 1. Pointing gimbal at circle-centre, 2. Gimbal Following another vehicle, 3. Time based triggering of image capture, 4. Start/Stop Video recording when arm/disarm, 5. Camera logging with mount specific messages, 6. GIMBAL_MANAGER_SET_ATTITUDE support, 7. Transferring support of mount poi (point of interest) from lua to c++, 8. Support for specifying which gimbal each camera is associated with, 9. Fixing other bugs in gimbals and cameras (specifically SiYi Zr10)

pythonrosc+++8
Student: Asif Khan
Code
Proposal

Extend lttoolbox to have the power of HFST

advanced
Apertium•2018Varies350h (Large)

<p>The aim of this project is to implement the support for morphographemics and weights in the lttoolbox transducer. The proposal focuses on extending lttoolbox to perform the complex morphological transformations and weight based analyses currently done in HFST and writing a module that translates the current HFST format to the new lttoolbox format.</p>

pythonc++xml+4
Student: Abinash Senapati
Code
Proposal

Fully Porting NuttX to the Raspberry Pi 4B

intermediate
Apache Software Foundation•2026Varies175h (Medium)

This proposal aims to complete major porting work of the NuttX RTOS to the Raspberry Pi 4B in order to vastly improve its stability and support. The goal is to attract new users with a flagship hobbyist device, showcase NuttX's ability to scale to large, 64-bit SoCs and also break NuttX into new markets with a more powerful platform (high RAM size, 64-bit architecture & 4-core SoC for applications like robotics). The milestones/deliverables for this project are: - Stabilization of existing support (I2C, EMMC, HDMI quirks) - SMP support - Full UART interface support (PL011) - Networking support (Ethernet OR WiFi) - Audio output - User demos (DOOM, LVGL dashboard, telnet)

pythonjavascriptjava+7
Student: Matteo Golin
Code
Proposal

Enhance the feature set of the Flutter Badge Magic Application

beginner
FOSSASIA•2025Varies90h (Small)

Project Summary : The goal of this project is to take Badge Magic to the next level by adding more creative and interactive features for users. Right now, the app supports basic text rendering, but there’s a lot of potential to make it more fun, flexible, and powerful. The plan is to introduce multi-font and multi-colour text support, allow users to create and store custom animations, and even play simple games like Snake and Pong directly on their LED badges. Along with that, I’ll work on improving how the app adapts to different badge sizes, add more control through advanced badge settings, and automate the deployment process across all platforms supported by Flutter. What I’ll deliver: Support for different fonts, colours, gradients, and per-character styling, Storage slots for saving and editing custom animations, Interactive mini-games are playable on the badge, Advanced configuration options (e.g., Bluetooth toggle, brightness), Cross-platform support (Windows, Linux, macOS, Web) with an improved UI, Proper testing and documentation to ensure everything works smoothly. By the end of the project, Badge Magic will be more customizable, more interactive, and ready to support a wider range of devices and users.

pythonjavascriptandroid+7
Student: Samruddhi Rahegaonkar
Code

Generation of 'async-shifted' version of high-order functions

intermediate
Scala Center•2023Varies175h (Medium)

This proposal aims to solve the issue of using high-order functions with asynchronous functions when there is no platform support of continuations and without implementation of two variants of HOFs (synchronous and asynchronous). The plan is to add basic functionality of auto generation of CPS transformed HOFs in the dotty-cps-async compiler plugin.

#scala#scala_lang#jvm+7
Student: Olena Kravchenko
Code
Proposal

JSON Dataset Reader - TensorFlow I/O

intermediate
TensorFlow•2019Varies175h (Medium)

<p>TensorFlow is one of the most popular machine learning frameworks and is widely used in fields beyond machine learning and data science. The architecture of TensorFlow has been elegantly designed such that it is possible to be extended in big data, medical imaging, and physical sciences. Supporting different format of data is the necessary step for communities beyond machine learning to adopt TensorFlow, as data is always as the entry point or edge node of the TensorFlow’s graph. Importing data with different formats natively in TensorFlow allows users to build their systems or applications without the need of additional conversion infrastructure.</p> <p>TensorFlow I/O focuses on providing various data format supports for TensorFlow, and many data formats are already supported, like Apache Kafka stream-processing, Amazon Kinesis data streams and also LMDB format and MNIST format, etc. However, the generic JSON format hasn’t been supported yet. It is quite necessary to support JSON format since JSON files are widely used in machine learning and data science.</p> <p>I will be working on providing JSON support in the TensorFlow I/O so that it will be possible to read JSON files into Tensorflow.</p>

pythonc/c++machine learning+8
Student: Jiacheng Xu
Code
Proposal

Characterizing and implementing missing vector operations in the volk-gnsssdr library

advanced
GNSS-SDR•2025Varies350h (Large)

Currently, certain essential signal-processing functions, called kernels here, in volk-gnssdr, the Vector-Optimized Library of Kernels for GNSS-SDR, are not completely optimized. This project hopes to diagnose performance-limiting kernels, implement missing SIMD/vector optimizations for both ARM (NEON) and RISC-V architectures (vector, or V, extension), then benchmark and validate the kernels’ continued functionalities.

c/c++c++11c++14+7
Student: Marcus Alagar
Code
Proposal

Half precision in LLVM libc

advanced
LLVM Compiler Infrastructure•2024$6k–$13.2k350h (Large)

This proposal is based on the open LLVM project with the same title, from Tue Ly and Joseph Huber. See https://discourse.llvm.org/t/libc-gsoc-2024-half-precision-in-llvm-libc/77027. The IEEE 754 binary16 format (also known as “half precision”) has most recently gained popularity in machine learning, which often does not require higher precision, and can benefit from increased performance when using smaller data types. It has been standardized as the _Float16 type in the drafts of the C23 standard. This project aims to implement support for this new floating-point data type and the associated variants of the C library’s math functions, in LLVM’s libc. Deliverables: 1. Add support for usage of the new type in generated headers through the float16 alias on supported compilers, compiler versions, and architectures. 2. Add generic implementations of the C23 half precision basic math operations for supported architectures. 3. Add possible specialized, higher-performance implementations of the C23 half precision basic math operations for individual supported architectures using hardware instructions and compiler builtins. 4. Add generic implementations of C23 half precision higher math functions for supported architectures. (Not all higher math functions can be implemented in the amount of time we have.)

cllvmc+++3
Student: OverMighty
Code
Proposal

coala language server

advanced
coala•2018Varies350h (Large)

<p>coala as a linting and code fixing tool can be far more useful when its power can be directly leveraged from within the code editor. Since all the major IDE's and code editors are now starting to support the standard Microsoft Language Server protocol it is now possible to expose coala's capabilities via the one said protocol and support a wide range of code editors. This proposal outlines the project where I intend to build one such server loosely based upon the proof of concept implementation built for vs-code. It should see noticeable performance improvements, feature upgrades to support actions such as didChange, didSave etc, customization of bears from within the LSP, support for all languages coala supports and be a fully standards confirming general language server.</p>

pythondjangopython 3+7
Student: ksdme
Code
Proposal

AsynAPI: Conference Website Maintainence

intermediate
AsyncAPI•2024Varies175h (Medium)

The project lies under Postman and AsyncAPI, which is an open-source organisation that is developing an ecosystem around Event Driven Architecture of API's. Essentially transforming the way we interact with API's and giving a new look to the standard REST API that is the industry standard. To support this they have various project under their belt. To promote these and spread awareness about them and the dev's to interact with each other. AsyncAPI plans on the AsyncAPI Conf on Tour 2024, which will utilise this project.

javascriptjavago+2
Student: Ashmit Jagtap
Code
Proposal

Boost.Math: FFT Utilities

advanced
Boost C++ Libraries•2021Varies350h (Large)

<p>We propose the implementation of Fast Fourier Transform (FFT) capabilities inside the Boost.Math library. This project answers the need for a C++ library of this sort, and the lack of FFT within Boost.Math. Our main goal is to design a modern C++ template interface for FFT that supports multiple types that satisfy the Ring Axioms and specialized routines for complex numbers, which constitute the most used cases.</p>

c++c++11c++14+3
Student: Eduardo Quintana Miranda
Code
Proposal

Optimizing Casanovo for Real Time De Novo Peptide Sequencing

intermediate
OpenMS Inc•2026Varies175h (Medium)

Casanovo is a transformer-based de novo peptide sequencer that is too slow for real-time instrument use. I will profile the new non-autoregressive pipeline, apply CUDA graphs, mixed precision, and FlashAttention-2 to reduce per-spectrum latency, then train lightweight student models via knowledge distillation to reach the 20-100 Hz real-time target required by modern mass spectrometers.

pythoncythonc+++2
Student: Gaurav SRC
Code
Proposal

Compiling Julia to WebAssembly

advanced
NumFOCUS•2018Varies350h (Large)

<p>This project would bring the mathematical prowess of Julia to the web with the near native performance of WebAssembly. The expected outcome of this project would be in compiling numerical kernels such as GCD and Matrix Multiplication, facilitating the compilation of BLAS-style libraries. In the long term this project could be used to: compile full Julia libraries, with support for running their automated tests; and the ability to bootstrap the compiler, which would enable actual Julia code to be used locally in the browser.</p>

pythonjavascriptr+3
Student: Sean Innes
Code
Proposal

TensorMap

advanced
C2SI•2026Varies350h (Large)

This project transforms TensorMap into a complete neural network design studio by introducing a data driven layer registry, expanding support to 15 layer types, enabling real time training visualization, model export in industry standard formats, post training interpretability tools and automated hyperparameter tuning. The system will improve scalability, usability and developer productivity while allowing users to design, train, analyze and optimize models visually.

pythonjavago+2
Student: kartikeygupta
Code
Proposal

Updating Application Libraries (Redis and Nginx)

advanced
Unikraft•2026Varies350h (Large)

The Unikraft ports for popular applications like Redis and Nginx are currently outdated and fail to compile with the latest kernel core. This project solves this problem by updating the application glue code and implementing missing system calls in the ukposix compatibility layer. The main deliverables are fully working, stable, and benchmarked unikernel versions of Redis and Nginx. This work will also improve the overall POSIX support in Unikraft, making it easier to port other applications in the future.

cpythonxen+3
Student: Radu Andrei
Code
Proposal

Extending kubearmor-cli-tool filtering options

Intermediate
•Varies175h (Medium)

KubeArmor is Cloud Native Runtime Security Enforcement System that restricts the behavior (such as process execution, file access, and networking operation) of containers and nodes at the system level using Linux Kernel LSMs (Linux Security Modules) and eBPF. KubeArmor cli-tool (aka karmor) connects to the kubearmor-relay service to provide command-line telemetry/observability. Karmor cli options could be extended to support various other parameters as described in the given issue.

TBA
Proposal

RISC-V as a First-Class Citizen in KernelCI Mentorship Project

Intermediate
•Varies175h (Medium)

This mentorship project aims to elevate RISC-V to a first-class architecture within the KernelCI project, aligning its support and testing capabilities with those of more established architectures. KernelCI is a community-driven, open-source testing infrastructure focused on ensuring the quality and long-term stability of the Linux kernel. This project will focus on bridging gaps in RISC-V integration, creating a replicable CI pipeline, and enabling consistent, comprehensive testing for RISC-V in KernelCI.

TBA
Proposal

Refactoring and optimizing model construction for the explicit engine

advanced
PRISM Model Checker•2016Varies350h (Large)

<p>During the project the current model construction will be analysed in regard to performance(i.e. reachability of multiple initial states, scalability and comprehensiveness(adding support for other types of models, i.e. PTAs). Depending on the analysis, it is decided which changes in the current approach enhance the functionality/ performance/ scalability and together with the supervisor a feature list can be defined. Then the implementation of the features is conducted and additionally efficient transformation to a sparse model and full import/export of the explicit model is implemented.</p>

javac++
Student: Maximilian Probst
Code
Proposal
Showing 1825 - 1848 of 4718 Projects
7576777879
Proposal