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

Implement Interface for external data source import into Calc

intermediate
LibreOffice•2021Varies

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)

<p>Currently back end of data provider is implemented and it supports csv,html,xml and base data provider. Many transformations are also available so that user can have a look of data after applied transformation before importing it into calc sheet.The data provider was removed in commit <a href="https://git.libreoffice.org/core/+/24939a5b43b9fe889c3aace027c668666ff61987%5E%21" target="_blank">https://git.libreoffice.org/core/+/24939a5b43b9fe889c3aace027c668666ff61987%5E%21</a> because there were many issues in UI. So the aim is to improve the interface of data providers and solving issues of data transformations to bring back it into production.</p>

pythonandroidjava+2
Student: Tushar Kumar Rai
Code
Proposal

VC-2 decoder Vulkan Implementation

intermediate
FFmpeg•2024Varies175h (Medium)

This projects's aim is to implement the VC-2 decoder for FFmpeg in vulkan. VC-2 is a low-latency video codec that uses wavelet transforms and entropy coding. It can be readily implemented in hardware or software at very high bit rates. It can also be efficiently implmented on GPU hardware. To this, end, an encoder and a decoder must be implemented and tested with the VC-2 conformance software. The encoder requires a wavelet transform, quantization, etropy coding and writing back the result in a proper format and bitstream coding. The decoder, in turn, reuires: bitstream parsing, entropy decoding, dequantization and another wavelet transform.

cgitasm+3
Student: pmozil
Code
Proposal

Compile M_intrinsics, fman, and gtk-fortran packages with LFortran

advanced
Fortran-lang•2026Varies350h (Large)

This proposal aims to improve LFortran by compiling and validating real-world Fortran packages such as M_intrinsics, fman, and gtk-fortran. Instead of focusing on isolated features, it follows a compilation-driven approach to identify and resolve limitations across different stages of the compiler, including parsing, semantic analysis, code generation, and runtime support. Key issues such as incomplete I/O specifier handling, quadruple precision support, and array constructor transformations will be addressed. The project emphasizes iterative development, testing, and validation against reference compilers, with the goal of improving LFortran’s robustness, correctness, and support for complex, real-world applications.

pythonc/c++llvm+3
Student: HarshilShah
Code
Proposal

Move2Kube Simplify plugin architecture of m2k (2024 Term 1)

Intermediate
•Varies175h (Medium)

Move2Kube is a command-line tool for automating creation of Infrastructure as code (IaC) artifacts. The tool has a powerful plugin based transformer architecture where developers can write their own custom transformer plugins to fulfil their re-platforming needs. However, concepts like path mappings etc could be simplified for better adoption. Example - writing a Move2Kube custom transformer needs developers to understand various concepts such as path mappings etc, can we reduce this learning overhead by simplifying the Move2Kube architecture? Expected Outcome: - Come up with a simplified alternative design for plugin architecture for M2K - Migrate existing components to support the new design with backward compatibility (good to have).

TBA
Proposal

Edit-Mesh Mirror Improvements

intermediate
Blender Foundation•2025Varies175h (Medium)

This project addresses Blender’s edit-mode mirror limitations by enhancing its functionality to support multiple axes and operators. It will enable artists to edit symmetrically without relying on workarounds like deleting half the model to apply a mirror modifier which is a method impractical for nearly finished models and incompatible with shape keys, which require actual vertex positions rather than modifier-driven symmetry. I’ll analyze the transformation system, refine the mirroring utilities, and extend support to operators that do not support mirroring. The deliverables include these enhancements, detailed documentation for users and developers, and a set of tests to ensure consistent operation. This will make symmetrical modeling more efficient for artists.

cpythonopengl+3
Student: Tariq
Code
Proposal

Per-Character Text Animation Layer

intermediate
Synfig•2026Varies175h (Medium)

This project introduces native per-character text animation support in Synfig. Currently, text is rendered as a single shape, making effects like staggered animation, typewriter effects, or per-letter transforms difficult without workarounds. The proposed solution decomposes text into glyph-level elements and enables independent animation of position, rotation, scale, color, and opacity for each character. A reusable stagger engine will be implemented to support delayed animations across characters, with a design that can be extended to general group-based animation in the future. The project will deliver new layer types for glyph-based rendering, full integration with Synfig’s animation system, UI support, file format compatibility, and user documentation.

c++gtkgtkmm+2
Student: Yukta
Code
Proposal

Native SVG Import/Export for p5.js via p5.Shape System (custom Project)

intermediate
Processing Foundation•2026Varies175h (Medium)

This project aims to add native SVG import and export capabilities to p5.js through enhancements to the p5.Shape system. Currently, p5.js only supports raster exports which limits professional workflows for artists and educators who require vector outputs. The project will first extend the Shape system by adding ArcSegment and EllipseSegment primitives to enable structured geometry recording. Then an SVG export add-on will be developed using a visitor pattern to convert recorded primitives into clean SVG paths with transform support. Key deliverables include a shape recording API, SVG export via saveSVG(), basic SVG import support, documentation, and tests. This will improve interoperability of p5.js with design tools and vector workflows while maintaining backwards compatibility.

pythonjavascriptandroid+6
Student: vansh kabra
Code

Cineform Decoder Improvements

intermediate
FFmpeg•2018Varies175h (Medium)

<p>The GoPro Cineform codec is a cross-platform intermediate codec designed for editing high-resolution footage. It was original designed for compressed Digital Intermediate workflows for film or television applications using HD or higher resolution media. FFmpeg reverse engineered Cineform decoder currently supports progressive video files with image formats YUV 4:2:2 10-bit, RGB and RGBA 4:4:4 12-bit. This project aims to support more features present in cineform codec, namely Inverse Temporal Transform for p-frames, deinterlacing support, assembly instructions integration into the ffmpeg version, and making it faster by using threading models present in FFmpeg. The result of this project will be that Cineform decoder can be integrated with many tools that use FFmpeg libav.</p>

cgitasm+3
Student: Gagandeep Singh-2
Code
Proposal

Kmesh eBPF unit test (2025 Term 1)

Intermediate
•Varies175h (Medium)

As the community features continue to expand, the number of eBPF programs in the data plane has increased. Due to the inherent limitations of eBPF (third-state encoding, neither user space nor kernel space, running in a kernel virtual machine with a dedicated instruction set), Kmesh implements complex governance logic through features like tail call and map-in-map, which poses challenges for data plane quality protection. eBPF, a recently introduced programmable technology in the kernel, currently has an immature ecosystem. The industry is actively exploring eBPF testing capabilities (e.g., Unit Testing eBPF). This project aims to develop an eBPF UT testing framework in conjunction with the Kmesh project to ensure the quality of the Kmesh data plane. Expected Outcome: 1. Export Kmesh eBPF programs to support UT test case. 2. Export design documentation for eBPF UT tests

TBA
Proposal

Arduino to MicroPython Transcompiler

beginner
Arduino•2020Varies90h (Small)

<p>The Arduino ecosystem has 2700+ libraries written in the ‘Arduino dialect’ of C++. For Micropython to become popular on Arduino it is required that:</p> <ul> <li>A large number of these libraries be ported to MicroPython.</li> <li>This porting must be efficient to do, to avoid time delays and uneccessary effort.</li> </ul> <p>The project idea aims to make a source to source compiler (known as a Transpiler) which can: ‘Translate’ a given example program of a library (in Arduino) to MicroPython automatically.</p> <ul> <li>Highlight any errors and parts of the code that it cannot translate effectively.</li> <li>Be easy to maintain as support for more library code is added down the road.</li> </ul> <p>Currently the project supports automatic transformation of many MicroPython statements, along with helpful messages of suggested libraries to import. It is a constant work in progress and will grow to support more automatic conversions in the future as Arduino's ecosystem matures.</p>

c/c++golangarduino
Student: Ashutosh Pandey
Code
Proposal

Optimize a VLA Model for Embodied Intelligence: OpenVINO Toolkit (Intel) Project #21

advanced
OpenVINO Toolkit•2026Varies350h (Large)

VLA models like unifolm-vla combine a vision-language backbone with a flow matching action head. On Intel iGPU, these models face two major deployment hurdles. First, structural blockers in the model code prevent successful OpenVINO conversion. Second, the iterative denoising loop requires kernel-level optimization to reach the frequencies needed for real-time robotic control. I will resolve four specific export blockers related to Python loops, random number generation, and precision handling. After achieving a successful export, I will implement kernel fusions for AdaLayerNorm and optimize Scaled Dot Product Attention to reduce latency on Arrow Lake and Panther Lake hardware. Project Deliverables: - A working OpenVINO export pipeline for unifolm-vla with all conversion blockers resolved. - Kernel-level optimizations including AdaLayerNorm fusion and SDPA pattern fixes. - A reference project featuring export scripts, quantization configurations, and latency benchmarks. - A detailed profiling report identifying bottlenecks and primitive selection via VTune.

pythonc++x86+1
Student: MDerazNasr
Code

JAX Chem : JAX-based Deep Learning Library for complex and versatile chemical modelings

advanced
Open Chemistry•2020$6k–$13.2k350h (Large)

<p>In recent years, deep learning has made remarkable progress in the area of NLP and CV with big data. In the area of chemistry, Graph Convolutional Networks, in which compounds and crystals are regarded as graphs, have attracted much attention.Deep learning frameworks for molecules such as DeepChem, Chainer Chemistry, and Deep Graph Library have emerged to more easily exploit these models of deep learning. On the other hand, these frameworks did not support inorganic crystal and the model support was biased towards Graph Convolutional Networks.JAX Chem is a JAX-based deep learning library for complex and diverse chemical modeling. JAX Chem’s motivation is to support not only models of Graph Convolutional Networks, but also Attention-based models like Transformer, and even models for wave functions involving complex physical equations like SchNetOrb or FermiNet. JAX is suitable for such complex modeling because JAX’s API allows you to write models declaratively. In the period of GSoC, I will implement the standard GNN model, the dataset utilities and the GCN model for MaterialInformatics, and the Attention-based model, as the beginning of JAX Chem.</p>

pythonjavascriptopengl+7
Student: Daiki Nishikawa
Code

CIR Combine: Cross-Boundary Analysis for Heterogeneous CUDA/HIP Compilation

advanced
LLVM Compiler Infrastructure•2026Varies350h (Large)

Today, LLVM's offload compilation keeps host and device code strictly separate; they only reunite late in the pipeline when the device binary is embedded into the host object. By that point, cross-boundary reasoning is largely out of reach. CIR Combine introduces a merge-optimize-split stage into ClangIR's compilation pipeline. After both host and device modules are compiled to CIR, a new driver action merges them into a single heterogeneous translation unit, an offload container holding both modules as nested regions. With both sides visible simultaneously, cross-boundary analysis passes can propagate constants from host launch sites into device kernels, eliminate kernels that are never launched, and infer launch dimensionalities that inform device-side optimization. A subsequent split action extracts the transformed modules and feeds them back into their respective backend pipelines. Deliverables: - Working merge/split skeleton integrated into the new offload driver - Cross-boundary constant propagation pass validated on real CUDA/HIP kernels - Compile-time overhead measurements, and the infrastructure that makes further host-device optimizations possible in the future.

cllvmc+++3
Student: David Rivera
Code

Improved Appointments Calendar View

advanced
OpenMRS•2026Varies350h (Large)

This project aims to enhance the existing appointments calendar in OpenMRS by transforming it into a more interactive, flexible, and user-friendly scheduling system. The current implementation provides only a basic monthly view with limited details, which is insufficient for real-world clinical workflows. The proposed solution introduces multi-view support (monthly, weekly, daily), enabling users to visualize schedules at different levels of detail. It will display detailed appointment information such as patient names, time slots, and statuses directly within the calendar. Additionally, navigation-based interactions will be replaced with modal-based views to preserve user context and improve usability. The project also includes support for multiple calendar systems (Gregorian, Islamic, Ethiopic, Persian) to ensure global adaptability. The implementation will follow a modular architecture using React microfrontends, OpenMRS REST APIs, and optimized data-fetching strategies. Deliverables include: Multi-view calendar (monthly, weekly, daily) Detailed appointment rendering Modal-based interaction system Multi-calendar system support Performance optimizations and testing

javahtml5groovy+11
Student: Pratik Debnath
Code
Proposal

OpenRISC Linux Feature Development

advanced
Free and Open Source Silicon Foundation•2025Varies350h (Large)

​​Jump Label Implementation​​ aims to eliminate branch overhead in kernel code by dynamically patching JMP/NOP instructions at runtime using GCC's asm goto feature. This involves defining static branch templates (ARCH_STATIC_BRANCH_ASM for NOP cases and ARCH_STATIC_BRANCH_JUMP_ASM for JMP cases) and implementing core functions (arch_static_branch and arch_static_branch_jump) along with a runtime patching mechanism (arch_jump_label_transform). The key deliverable is near-zero-cost branch decisions, significantly improving performance for frequently checked kernel conditions like tracepoints and debugging checks. ​​Ftrace Implementation​​ provides efficient function tracing (function) and call-graph profiling (function_graph) with minimal overhead. The -pg compiler flag inserts mcount() calls that dynamically redirect to either a no-op stub (when disabled) or a full tracer (when enabled). The implementation includes dynamic redirection in mcount(), the core function tracer (ftrace_trace_function), and the extended function_graph tracer with entry/exit hooks (ftrace_graph_caller and return_to_handler). This enables deep call-stack analysis while maintaining low runtime cost when tracing is inactive, supporting dynamic kernel debugging with minimal performance impact.

pythonjavascriptfpga+11
Student: Chen Miao
Code

Efficient syscall tracing for strace

intermediate
strace•2019Varies175h (Medium)

<p>strace currently adds significant overhead to any application it traces. Even when users are interested in a handful of syscalls, strace will intercept all syscall made by the observed processes, involving several context switches per syscall.</p> <p>Since Linux 3.5, userspace applications can rely on seccomp-bpf to filter the syscalls they want to trace. In that case, the set of monitored syscalls is filtered in the kernel, using cBPF, before any context switch to userspace. strace could leverage seccomp-bpf to avoid tracing syscalls users don't want. The tracing landscape of Linux also drastically evolved in recent years. In particular, user applications can rely on eBPF programs to filter and aggregate data of interest in the kernel, with low overhead.</p> <p>During this Google Summer of Code, I will finish and merge the works started to 1) rely on seccomp-bpf to filter syscalls in kernel space and 2) allow strace to use alternative backends. That second work will come with a tracepoint/BPF proof of concept to ensure strace supports diverse backends, beyond the usual ptrace model.</p>

clinuxshell script+6
Student: Paul Chaignon
Code
Proposal

New gadget for detecting deadlocks (2024 Term 3)

Intermediate
•Varies175h (Medium)

Inspektor Gadget is an eBPF tool and systems inspection framework for Kubernetes, containers and Linux hosts. In this project, you will write a new gadget in BPF and WASM to detect deadlocks in applications. The BPF program will be attached on mutex locks and mutex unlocks functions with uprobes. The WASM program will build a mutex wait directed graph and look for cycles. Then, the gadget will display the stack trace showing the mutex locks causing the deadlock. This project builds upon previous work: - In a previous mentorship project, Inspektor Gadget gained support for uprobes and kernel stack traces (https://www.inspektor-gadget.io/blog/2024/06/supporting-uprobe-based-gadgets-lfx-mentorship-report/). - BCC tools include deadlock.py doing the same: https://github.com/iovisor/bcc/blob/master/tools/deadlock_example.txt and https://github.com/iovisor/bcc/blob/master/tools/deadlock.py However, this project still has challenging issues to resolve: - Inspektor Gadget does not support dumping stack traces from userspace applications yet Expected Outcome: A new gadget detects lock order inversion and prints the stack traces where each mutex was acquired.

TBA
Proposal

Sailing Downstream Mentorship Project

Intermediate
•Varies175h (Medium)

Background: Current flows from RISC-V Sail specification to downstream implementations have manual steps which are time-consuming and can introduce errors.A lack of familiarity with Sail and OCaml presents a barrier to adoption of Sail as the basis for automated downstream implementations: emulators, simulators, compilers, assemblers, disassemblers, instruction stream tools, documentation, etc. Proposal: - Create an accessible Sail backend. - Extract salient information. - Transform it into an accessible database (JSON). - Survey projects dependent on RISC-V ISA for how that dependency is realized. - Utilize JSON to directly and automatically generate downstream source that is currently generated by hand. - Create a React-based interactive RISC-V ISA reference by directly importing the JSON database. Benefits: The backend can serve as a model for creation of additional Sail backends. The JSON database itself may be sufficient for many downstream uses. Creating downstream source shows feasibility, and a process for a fully-automated downstream flow. Additional collaboration with the effort to transform Sail into documentation is warranted. Much of the effort to transform Sail into JSON is complete, but there is still significant effort ahead: - enhanced parsing - enhancing the RISC-V Sail specification itself with more required content Much of the effort in creating an interactive web site is complete, but there is work to support the incorporation, display, and filtering.

TBA
Proposal

Hybrid Quantum-Classical Representation Learning for Dark Matter Substructure Classification

advanced
Machine Learning for Science (ML4SCI)•2026Varies350h (Large)

This proposal presents a plan to develop hybrid quantum-classical models for classifying dark matter substructure from strong gravitational lensing images, as part of the ML4SCI DeepLense project. The classification task involves three classes: no substructure, CDM subhalo substructure, and vortex substructure from axion/fuzzy dark matter. I propose two complementary approaches: Projected Quantum Kernels (PQK), which encode CNN-extracted image features into quantum states and ompute kernel matrices for SVM classification, and Quantum Convolutional Neural Networks (QCNN), which use parameterized quantum circuits as trainable convolutional filters in a hybrid pipeline. Both methods will be benchmarked against classical baselines on the DeepLense Model I/II/III datasets and evaluated under realistic NISQ noise conditions using depolarizing and devicecalibrated noise models, with error mitigation techniques such as ZNE and PEC. Beyond the standard implementations, I also propose using a GPT-2-based autoregressive Transformer to automatically generate task-optimized quantum circuits for both PQK feature maps and QCNN layers, replacing hand-designed circuit templates. Additional experiments include data-efficiency analysis on small training subsets, hybrid kernel fusion combining classical RBF with PQK, and transfer learning evaluation across different dark matter model datasets.

pythonmachine learningc+++2
Student: Jen-Yu Chang
Code

GGUF Reader V2 in OpenVINO GenAI for Direct GGUF Execution via Dynamic Graph Translation

intermediate
OpenVINO Toolkit•2026Varies175h (Medium)

The current GGUF reader in OpenVINO GenAI manually reconstructs model architectures by parsing metadata and building the OpenVINO model layer by layer — requiring explicit C++ implementations for every supported model topology. This project implements GGUFReaderV2, a new GGUF reader that uses dynamic graph translation instead. It leverages llama.cpp APIs to produce a GGML computation graph (ggml_cgraph), passes it through the existing GgmlOvDecoder and ov::frontend::ggml::FrontEnd infrastructure to produce an ov::Model, and integrates the result into OpenVINO GenAI's read_model() pipeline. A working prototype has already been validated with TinyLlama.gguf — successfully capturing 5,141 OpenVINO operations and executing them through the translation pipeline. Key architectural challenges around tensor naming, capture state safety, and test design have been identified and documented. Deliverables: 1. Functional GGUFReaderV2 class with correct RAII resource management and passing math equivalence tests 2. Stable GGML to OpenVINO graph translation with collision-free node mapping 3. Full integration into GenAI's read_model() API with dynamic shape support 4. Regression test suite validating accuracy across quantization formats (Q4_K, Q6_K, Q8_0) and architectures (TinyLlama, Phi-3, Llama-3, Qwen2.5) 5. Comprehensive documentation and developer guide for extending GGML operator support

pythonc++x86+1
Student: KARNAV SHAH
Code

Collect Polyhedral Benchmarks

advanced
Polly Labs•2018Varies350h (Large)

<p>Currently, Polly’s performance is measured on PolyBench benchmark. PolyBench does not cover all of the possible kernels so we may miss out some kernels where a particular transformation does not perform well. This project will help to get new benchmarks for measuring Polly’s performance benefits. The benchmarks will be added to LLVM test suite.</p>

llvmpollyppcg+4
Student: Pankaj Kukreja
Code
Proposal

SIMD for SQL expressions and functions

advanced
MariaDB•2023Varies350h (Large)

Current Mariadb ColumnStore engine doesn’t support vectorized evaluation of SQL functions and expressions. This project want to cover this by adding row/col transformation before the evaluation and evaluate the performance improvement. Furthermore, this project will also try to accomplish a delayed projection into RowGroup, which store data in vertical stored buffers and optimize the transformation part.

cmysqlmariadb+7
Student: Mu He
Code
Proposal

Implement 3MF read/write

intermediate
BRL-CAD•2017Varies175h (Medium)

<h4>Project Goal:</h4> <p>Implement support for the 3MF file format in Slic3r and allow conversion into (AMF, OBJ, STL).</p> <p><strong>3MF</strong> is generally smaller than other comparable 3D formats where transforms and object references are supported.</p> <ul> <li>More about 3MF file format and its specification: <a href="http://3mf.io/" target="_blank">http://3mf.io/</a></li> </ul>

pythonc/c++opengl+6
Student: Ahmed Samir Hamed-1
Code
Proposal

OpenBLAS Mentorship Project

Intermediate
•Varies175h (Medium)

OpenBLAS is an optimized BLAS implementation. Currently, OpenBLAS supports RISC-V Vector 0.7.1 for Xuantie C920. For RISC-V Vector 1.0 version, OpenBLAS team already update Level-1 and Level-2 BLAS kernel from RVV 0.7.1 intrinsic to 1.0 intrinsic. The next work is developing the Level-3 BLAS kernels (e.g. gemm) for RISC-V Vector 1.0.

TBA
Proposal
Showing 1753 - 1776 of 4718 Projects
7273747576
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal