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

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

advanced
OpenVINO Toolkit•2026Varies

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 →
350h (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
Proposal

Add KraftKit Support for Hyperlight

intermediate
Unikraft•2026Varies175h (Medium)

This project adds Hyperlight as a new VMM backend in KraftKit, enabling Unikraft unikernels to run with `kraft run --plat hyperlight`. The work will introduce platform registration and a new Hyperlight driver in the machine layer, then implement the full machine lifecycle: create, start, stop, delete, inspect, list, logs, and watch. It will start with a minimal boot path for a basic kernel, then extend to networking and storage support where possible. By the end of the project, KraftKit will have first-class Hyperlight support, and users will be able to manage Hyperlight machines through the standard CLI workflow.

cpythonxen+3
Student: Jaidev Singh
Code
Proposal

Update Payment Hub EE dependencies

beginner
The Mifos Initiative•2026$1.5k–$3.3k90h (Small)

The Mifos Payment Hub EE (PH-EE) is a massive ecosystem with about 42 Java repositories that run the open-source DPI payment infrastructure. But there’s a problem: over the years, these components have drifted apart. We have a mix of everything: Java 8 to 17, Spring Boot 2.1 to 3.2, and the old javax.* namespace. This mess makes the platform hard to maintain, full of security risks (CVEs), and prone to dependency hell where one tiny conflict can break the whole stack. My goal for this GSoC is to fix this once and for all. I will lead a systematic migration to a modern, unified baseline: Java 21, Spring Boot 3.4, Apache Camel 4, and Jakarta EE 10. To be sure that everything is perfect, the project introduces a three-level test framework: a BOM verification step (classpath purity check that fails on any javax.* artifact), WireMock + Cucumber integration tests for behavioral equivalence validation, and an end-to-end smoke test via Mifos Gazelle against a live k3s deployment. A platform BOM and a connector starter template standardize dependency governance and build configuration across all components, so the unified baseline remains enforceable after GSoC ends.

mysqljavascriptandroid+5
Student: RinalduzziGiulio
Code
Proposal

PerceptionMetrics: GUI extension and support for standard datasets and models

advanced
JdeRobot•2026$6k–$13.2k350h (Large)

Perception metrics is a unified toolkit for evaluating perception models across datasets and frameworks. Its foundation was built through prior GSoC efforts designed to unify and formalized in a stable release published in Sensors. This platform was recently modernized to support LiDAR, images segmentation, and object detection. This proposal focuses on scaling PerceptionMetrics from off-road focused workflows to industry-standard benchmarking. The core objectives are: • Integrate and prioritize standard image and Lidar datasets. • Extend GUI support to segmentation visualization (image and Lidar). • Deliver comprehensive tutorials/documentations for practical usage. • Strengthen reliability through expanded tests and CI-friendly validation.

pythonrosgazebo+2
Student: Tejas Stanley
Code

Physics Informed Neural Network Diffusion Equation (PINNDE)

intermediate
Machine Learning for Science (ML4SCI)•2026$3k–$6.6k175h (Medium)

Generating simulations of calorimeter showers of interacting particles are a crucial step in analyzing the results of large scale experiments at LHC. Traditionally very accurate simulations are produced using pipeline like GEANT4. This simulation step is currently a computational bottleneck and it is forecast to overwhelm the computing budget of the LHC experiments in the near future. The goal of this project is to build upon the fast and accurate sampler (PINNDE) developed in my GSOC 2025 project and use it to generate high-fidelity simulations of calorimeter showers. This pipeline consists of two distinct steps, namely building an accurate autoencoder capable to compressing the particle shower data onto a low-dimensional latent space and a diffusion model trained to generate samples from this low-dimensional latent space. In this project I will be implementing different auto encoders motivated by the physics and geometric constraints of the calorimeter experiments and use the Physics informed neural network trained to approximate the reverse time ODE of the diffusion model to generate samples of the calorimeter showers. The final deliverable will be bench marking this fast-sampler for calorimeter showers against the other solutions submitted to the Fast Calorimeter Simulation Challenge 2022.

pythonmachine learningc+++2
Student: Sijil
Code

Extend FLOSS to use the rendering techniques pioneered by QUANTUMSTRAND

intermediate
FLARE•2026Varies175h (Medium)

This project enhances FLOSS by integrating QUANTUMSTRAND’s context-aware rendering to make malware string analysis faster and more actionable. Instead of overwhelming analysts with raw strings, the improved tool will use structural context, tagging (e.g., libraries, APIs, expert rules), and prevalence to highlight important information while muting noise.

pythonida-proGhidra+1
Student: vee1e
Code
Proposal

LMS Toolkit Functionality for Moodle

intermediate
UC OSPO•2026Varies175h (Medium)

The Edulinq LMS Toolkit provides a set of tools and a Python interface to interact with Learning Management Systems (LMSs) such as Moodle, Canvas, and Blackboard in one convenient place. It defines many different CLI tools, all of which are currently supported for Canvas. However, only a few of these functions are currently supported for Moodle. I am interested in developing the functionality for most or all of the remaining CLI tools the LMS Toolkit defines so the entire suite of tools is accessible for Moodle.

pythonc/c++visualization+5
Student: j.d.kelman95
Code
Proposal

COSMIC Desktop Print Dialog

intermediate
The Linux Foundation•2026Varies175h (Medium)

Build a production-ready CPDB-based print dialog for COSMIC and integrate it with xdg-desktop-portal-cosmic (PreparePrint + Print) so desktop and sandboxed apps can print through a native COSMIC UX. The project also defines an async event-driven backend model in cpdb-rs (aligned with zbus and libcosmic/iced) to bridge async CPDB callbacks cleanly into libcosmic/iced state updates, with handling for printer discovery, options, translations, job submission, and failure scenarios.

cpythonmysql+7
Student: Ayush Chauhan (bakayu)
Code
Proposal

Message-Based Flight Software Architecture for CubeSats

advanced
Open Technologies Alliance - GFOSS•2026Varies350h (Large)

This project bridges the gap between complex frameworks and basic, non-standard code. I will develop a modular, message-based flight software for the Open-Source CubeSat FlatSat Testbed using FreeRTOS. The goal is to create a 'sweet spot' firmware: accessible for students to learn, yet compliant with professional aerospace standards. By implementing a publish-subscribe 'Software Bus,' the system ensures that hardware drivers and mission logic are decoupled and interchangeable. This results in a scalable, flexible architecture that can evolve alongside the CubeSat hardware. Deliverables: Message Dispatcher: A thread-safe Software Bus for modular communication. Hardware HAL: Thread-safe STM32 drivers for the FlatSat sensor suite. Standards Core: PUS-compliant Telemetry, Telecommand, and Error Handling (FDIR). Testing: Unit testing and documentation of end result

pythonmysqljava+7
Student: Ada Roufogali
Code

Qualified Name Lookup for swift-syntax

intermediate
Swift•2026Varies175h (Medium)

I propose reimplementing the compiler’s qualified name lookup in the Swift-only "swift-syntax" package. I will add a new API to the SwiftLexicalLookup module that accepts a declaration group, such as a type, and returns its members —commonly properties and functions. Lifting this API into the higher-level SwiftSyntax package exposes essential semantic information, enabling build tools that perform more intricate code transformations and offer more precise diagnostics. The library will find a declaration group's members through the package's SyntaxVisitor API and optionally cache results in a new SymbolTable type. I will deliver the updated SwiftLexicalLookup library with helpful docstrings and comments, extensive unit testing, and unqualified-lookup integration, along with two dedicated documentation articles.

llvmc++cmake+5
Student: Filip Sakellariou
Code
Proposal

Implementing Coarray Support in LFortran

intermediate
Fortran-lang•2026Varies175h (Medium)

This project aims to implement full coarray support in the LFortran compiler, enabling native parallel programming capabilities based on the Partitioned Global Address Space (PGAS) model defined in the Fortran 2008/2018 standards. Currently, while LFortran’s parser supports coarray syntax, the feature is not implemented beyond basic stubs, preventing execution of even minimal coarray programs. The project will bridge this gap by extending LFortran’s Abstract Semantic Representation (ASR) to model coarrays, implementing semantic analysis for coarray constructs, and introducing a dedicated coarray runtime library. A key component is an ASR-to-ASR lowering pass that translates high-level coarray operations (such as coindexed access, synchronization, and collective intrinsics) into runtime calls. This design follows LFortran’s existing OpenMP architecture, ensuring backend-agnostic support across LLVM, C, and other targets. The implementation will proceed in two phases: first, establishing a fully functional single-image mode with correct semantics and runtime integration; second, enabling multi-image execution using an MPI-based runtime backend. By the end of the project, LFortran will be capable of compiling and executing coarray programs in both single-node and distributed environments. This work lays the foundation for supporting real-world coarray-based HPC applications and positions LFortran as a leading LLVM-based Fortran compiler with modern parallel programming support.

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

Filling the gaps within the IOOS quality control schema for ocean glider data.

intermediate
IOOS•2026$3k–$6.6k175h (Medium)

I propose a development period of 5 stages to gauge community needs, assess the toolbox, and potentially augment it with additional tests or functions. The first stage is to become more familiar with the glider community and identify what already exists, learning as much as possible prior to making any improvements. The 2nd stage is to address the “Group 1” tests as outlined in GSoC proposal #102 on Github, which are essential to many glider operations and basic data functionality for any following uses. Next, stage 3 will address” Group 2” or “strongly recommended” tests which are significant for data hygiene and identifying problems that likely arise from the sensors themselves, rather than real phenomena. Stage 4 addresses “Group 3” or “suggested” tests, which help anchor the data in reality by testing known oceanographic trends. Finally, stage 5 of this project will seek to expand the toolbox from any discovered shortcomings and synthesize the project into an easily digestible conclusion.

pythonocean sciencejava+3
Student: Aaron Mau
Code

Cognitive Ecosystem: Unified Agent Coordination, Observability, and Intelligence for MoFA

advanced
MoFA Org•2026Varies350h (Large)

MoFA agents currently operate as "black boxes" in isolation—they lack shared memory, structured handoff protocols, and cross-agent coordination. When a multi-agent swarm fails, there is no single distributed trace to follow and no system-wide intelligence to explain why. This proposal transforms MoFA from a collection of individual agents into a "Cognitive Ecosystem" by implementing a symbiotic coordination-and-observability layer. Building on the OTLP+Prometheus pipeline with a 336x performance gain and the core coordination traits I designed (PR #997), this project delivers: (1) An AgentHub Coordination layer featuring InMemoryVectorStore for semantic memory and ChannelHandoffProtocol for reliable task delegation; (2) A zero-copy EventRecord Bridge using tokio::broadcast to fan out state mutations; (3) An Observatory Intelligence Engine featuring a petgraph-powered Knowledge Graph for live topology mapping and a Z-Score Statistical Anomaly Detector for identifying rogue agent behavior (token burn, latency spikes). The result is a production-grade "Nervous System" for MoFA where every agent interaction is first-class, observable, and governed. Key metrics include: Zero-drop event propagation at 4000 EPS, <50ms graph query latency, 80%+ unit test coverage, and a full W3C TraceContext implementation for cross-agent waterfall visualization.

pythonrust
Student: Ashum9
Code
Proposal

C++ Acceleration and Modern Architectures for {torchvision} in R

advanced
R project for statistical computing•2026Varies350h (Large)

The {torchvision} library in mlverse is already near-feature-parity with the PyTorch library, but certain performance optimisation and state-of-the-art computer vision model support gaps need to be bridged. This project aims to bridge the performance optimisation and state-of-the-art computer vision model support gaps in the current mlverse library. The performance optimisation objective is to improve the performance of the library by moving computationally intensive functions, e.g., region proposal networks and non-maximum suppression, from R to C++. This will allow for seamless integration with libtorch, providing production-grade speed and performance for detection and segmentation tasks. The state-of-the-art computer vision model objective is to improve the library by adding YOLO, RT-DETR, and SAM models, among others, into the torchvision library. This will be achieved by providing end-to-end documentation of the models, e.g., using the R documentation system, roxygen. This project will result in improved performance by providing an R interface for performance-critical functions using Rcpp, as well as improved state-of-the-art computer vision models by adding YOLO, RT-DETR, and SAM models, among others, into the torchvision library. This will improve the performance, usability, and adoption of R as a deep learning library for computer vision tasks, making mlverse a competitive alternative

cc++r+4
Student: Derrick Richard
Code

VLC macOS interface redesign

intermediate
VideoLAN•2026$3k–$6.6k175h (Medium)

The VideoLAN UI has been updated many times in the last years, now targeting 4.0 as the next major release. Previous GSoC projects have started updating the interface since 2012. With successive projects in 2017, 2018, and 2021. I want to build on their work, and keep refining the MacOS interface. This project consists of ironing out details and bugs that work toward the 4.0 milestone. I am basing myself off the issues open on Gitlab, but I am open to follow the direction the mentors find fit.

copenglc+++10
Student: Joseane Silva
Code
Proposal

Reimplement udmabuf to FreeBSD

intermediate
The FreeBSD Project•2026Varies175h (Medium)

This project aims to implement the udmabuf (User DMA Buffer) driver on FreeBSD, a crucial mechanism for zero-copy memory sharing between userspace applications and kernel subsystems. The absence of udmabuf currently limits FreeBSD's capability to efficiently support modern graphics and virtualization stacks, particularly preventing tools like QEMU from utilizing virtio-gpu with blob resources. The proposed solution involves developing a loadable kernel module that acts as a dma_buf exporter, deeply integrating with FreeBSD's virtual memory subsystem and extending the linuxkpi compatibility layer. Key deliverables include a fully functional udmabuf module implementing the complete set of dma_buf_ops, necessary linuxkpi API extensions for DRM compatibility, end-to-end integration patches for QEMU, and comprehensive ATF test cases accompanied by thorough documentation.

c/c++llvmassembly+5
Student: Zishun Yi
Code
Proposal

Idea 7: Local Encrypted Vault for Notes & Notebooks

intermediate
Joplin•2026Varies175h (Medium)

Problem: Joplin’s End-to-End Encryption (E2EE) secures data during sync, but notes remain in plaintext within the local SQLite database. This leaves sensitive data vulnerable to local filesystem access on shared, corporate, or unlocked devices. Solution: This project implements a Local Encrypted Vault using a "Body-Prefix Polymorphism" strategy. Instead of fragile database schema migrations, notes are locked via AES-256-GCM, and the ciphertext is stored directly in the native body field (e.g., JOPLIN_CIPHER:AF82D...). This architecture natively supports Joplin’s Stacked E2EE sync, prevents double-encryption bugs, and utilizes Just-In-Time (JIT) RAM decryption to ensure maximum security.

reactnode.jsreact native+5
Student: Akshaj Rawat
Code
Proposal

Interactive Sync Conflict Resolution for Joplin Desktop and Mobile

intermediate
Joplin•2026Varies175h (Medium)

Joplin's offline-first design is one of its best features, but it comes with a real cost when the same note is edited on two devices before either syncs, Joplin has no way to merge the changes. It saves one version as a conflict note and leaves the user to manually figure out what to keep. For long notes on mobile, most people just give up and pick whichever version looks more complete, which means changes get silently lost. This project adds an interactive conflict resolution UI to Joplin desktop and mobile. When a conflict note is opened, instead of seeing a raw copy with no context, the user gets a clear section-by-section view of exactly what each side changed. Non-conflicting changes like additions and deletions can be resolved in one click. Genuine conflicts where both sides changed the same part give the user full context to pick one side or edit manually. A Keep both option preserves both versions for users who want that. The same shared diff module powers both platforms so the behaviour is always identical. The core deliverables are a platform-independent diff module using node-diff3, a minimal addition to the sync pipeline to store a base snapshot for three-way merging, and a conflict resolution React component for desktop and React Native component for mobile. The implementation also handles edge cases including notes synced before the feature was deployed falling back to two-way diff, stale remote data being detected and reset on open, and second conflicts on the same note being handled gracefully. No existing conflict behaviour changes and sync is never blocked at any point.

reactnode.jsreact native+5
Student: Sriram Varun Kumar
Code

A Benchmarking Framework for Geometric Random Walks

advanced
GeomScale•2026Varies350h (Large)

Sampling from high-dimensional convex polytopes is a fundamental problem with applications in statistics, machine learning, optimization, and systems biology. Modern libraries such as VolEsti provide a rich collection of geometric random walk algorithms; however, there is currently no unified, extensible, and reproducible framework for benchmarking these methods in practice. In my recent MSc thesis, I conducted a large-scale empirical comparison of state-of-the art sampling algorithms across multiple software ecosystems. This work revealed a clear gap: while many algorithms exist, there is no standardized way to evaluate them under consistent configurations, geometries, and diagnostics. The goal of this project is to design and implement a complete benchmarking suite for VolEsti, enabling systematic, reproducible, and extensible evaluation of geometric random walks. The framework will support configurable experiments, advanced diagnostics, and integration with Python tools for visualization and analysis. Ultimately, we aim to implement a research-grade benchmarking platform where any algorithm can be evaluated quickly and thoroughly and every new suggested algorithm can be easily compared to existing methods.

pythonc++r+2
Student: Chrthegreat
Code
Proposal

Enhancing openSUSE Git Workflow

intermediate
openSUSE Project•2026Varies175h (Medium)

The goal of this project is to improve the obs-status-service tool to provide a better visualization and explore other integrations. This tool is a go application that provides some visualization from build results as SVG images. During this project we will work on improving and extending the generated SVG, improving the UX with new styles and making it dynamic with javascript. The second part of the project is to implement a new bot for Gitea that provides useful build information directly in pull requests. Additionally, if time permits, we will explore the implementation of an AI-powered integration to assist with pull requests that fail to build, utilizing Log Detective (https://www.logdetective.com/).

pythonlinuxjavascript+11
Student: mmarhin
Code
Proposal

Make closures.osm.ch Production Ready

intermediate
OpenStreetMap•2026$3k–$6.6k175h (Medium)

closures.osm.ch is a community-driven platform for reporting temporary road closures in real-time, built during GSoC 2025. It is not yet production-ready: the Valhalla routing integration is architecturally backwards (the frontend pushes coordinates to Valhalla rather than Valhalla pulling closure data), government data feeds are unsupported, and several features needed for real-world adoption remain incomplete. This project closes that gap across three pillars: (1) replacing the prototype routing integration with a correct architecture — a closure_sync sidecar service that feeds Valhalla's native live traffic tiles infrastructure, with a backend-served exclude_polygons endpoint as an immediate stepping-stone; (2) implementing CIFS and DATEX II importers to ingest authoritative government road closure data with attribution and deduplication; and (3) completing the remaining loose ends — a Mapbox Vector Tile overlay of active closures with Redis caching, and UI internationalisation via Transifex. Deliverables: self-hosted Valhalla instance, POST /api/v1/routing/closure-aware endpoint, frontend cleanup, CIFS and DATEX II importers with shared base class, GET /api/v1/tiles/{z}/{x}/{y}.mvt endpoint, and i18n wiring with English and German initial translations.

javascriptjavaopengl+10
Student: Venetis Charalampidis
Code
Proposal

Recover from GPU Resets

intermediate
GNOME Foundation•2026Varies175h (Medium)

Mutter is the Wayland display server and compositor library powering GNOME Shell. Currently, an unexpected GPU reset causes the compositor to freeze as the EGL context becomes defunct and all allocated GPU memory is lost. This project aims to implement a robust recovery mechanism by leveraging the `GL_EXT_robustness` extension to detect resets, re-create the EGL context, and re-upload all GPU resources, including client textures, glyph caches, background image, etc. This work will ensure system resilience and prevent session-ending freezes, allowing the compositor to resume rendering seamlessly after hardware-level failures.

cpythonjavascript+4
Student: Toluwaleke Ogundipe
Code
Proposal

istSOS Metadata Connector for Data Spaces and STAC

beginner
OSGeo (Open Source Geospatial Foundation)•2026Varies90h (Small)

A fundamental gap in the OGC SensorThings API ecosystem is addressed by this project: istSOS4 can serve rich sensor data, but it is difficult to find that data outside of its own API. This project aims to create a lightweight metadata connector that extracts data from istSOS4, transforms it into DCAT-AP 3.0 and SpatioTemporal Asset Catalog(STAC) formats, and exposes it through simple REST endpoints (/stac, /dcat). As a result, istSOS4 deployments are searchable, interoperable, and simple to integrate with contemporary data platforms and geospatial tools thanks to a plug-and-play service.

pythonjavascriptc/c+++4
Student: Vishmayraj
Code
Proposal

DuckDB Backend for Martin TileServer

intermediate
OpenStreetMap•2026Varies175h (Medium)

This project aims to provide first-class DuckDB support for Martin TileServer. DuckDB, with its spatial extension and native ST_AsMVT and and ST_AsMVTGeo functions, enables efficient vector tile serving directly from analytical file-based datasets such as GeoParquet. With PostGIS, this is not possible since it’s a transactional database and not suitable for reading analytical columnar datasets. Martin currently has support for PostGIS tables and views as well as file formats such as MBTiles and PMTiles to build and server vector tiles. This project will extend Martin’s architecture to DuckDB and provide support for persistent DuckDB databases with spatial tables as well as local and remote GeoParquet files.

javascriptjavaopengl+10
Student: ManbhavSugla
Code
Proposal
Showing 985 - 1008 of 11996 Projects
4041424344
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal