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

Papers: Proof of Concept for Backend Isolation in GNOME Papers

advanced
GNOME Foundation•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 →
350h (Large)

GNOME Papers (formerly Evince) currently processes all documents within a single application process, creating significant security and stability risks. A vulnerability or crash in one document can compromise the entire application. This project aims to create a proof-of-concept for backend isolation by implementing a multi-process architecture where each document runs in a separate process. The approach involves researching process isolation models (e.g., WebKit, Chromium), designing an IPC mechanism using D-Bus and shared memory, and implementing basic sandboxing for document processes. Key deliverables include a working prototype demonstrating isolation for at least one document format (e.g., PDF), performance and security analysis, and comprehensive documentation to guide future implementation. This project addresses long-standing limitations blocking features like tabbed interfaces while improving security and stability for GNOME Papers users.

cpythonjavascript+4
Student: Ahmed Fatthi
Code
Proposal

GSoC’25 Proposal: Lunatik HID Framework Implementation

intermediate
LabLua•2025$3k–$6.6k175h (Medium)

This proposal introduces myself and outlines the work I will be doing during the Google Summer of Code 2025. My proposal aims to implement a HID driver framework for Lunatik, a module that provides a way to binding HID devices using Lua script.

luacéuelasticsearch+5
Student: Jieming Zhou
Code
Proposal

HTML5 Article Renderer

advanced
Learning Equality•2025Varies350h (Large)

This project aims to integrate a new resource type, HTML5 articles, into the Kolibri Ecosystem by developing a content renderer capable of displaying HTML5 articles outside of an iframe. Kolibri currently supports sandboxed HTML5 applications that allow arbitrary styling, JavaScript, and HTML within iframes. However, this approach demands advanced technical expertise in HTML and CSS from content creators. The HTML5 Article Renderer will simplify content creation, allowing creators to generate rich text content more easily. For this project, I will contribute to the safe_html5_viewer plugin in the kolibri repository under the mentorship of Samson Akol and Allan Otodi Opeto.

pythonjavascriptdjango+1
Student: Winny Chang
Code
Proposal

ActiveVision: a data and model portal for the study of goal-directed vision

advanced
INCF•2025Varies350h (Large)

This project develops an open portal for goal-directed vision research, integrating eye-tracking datasets and machine learning models with tools for benchmarking and validation. A key focus is vision-language integration, enabling better task-driven attention modeling. This platform will also serve as a prototype for similar data+model initiatives on public hardware platforms, improving reproducibility and accessibility in multimodal AI research.

pythonjavac+++7
Student: Lihong Chen
Code
Proposal

Extend DetectionMetrics: GUI, CI Workflow, and Object Detection

beginner
JdeRobot•2025Varies90h (Small)

DetectionMetrics is a toolkit designed to unify and streamline the evaluation of perception models across different frameworks and datasets. The older version i.e DetectionMetrics v1 provides objective performance metrics such as mean average precision and mean inference time for object detection models. Now DetectionMetrics v2 was introduced in which the previous version was redesigned with an expanded focus on image and LiDAR segmentation. Currently, DetectionMetrics v2 functions as both a Python library and CLI, focusing on the quantitative evaluation of image and LiDAR segmentation models, with plans to expand into object detection. It supports PyTorch and TensorFlow models, along with multiple public datasets. Its modular design allows easy integration of new models and datasets. This project aims to bring back the key functionalities from v1 that were lost while redesigning, build a GUI and set up a CI workflow.

pythonrosgazebo+2
Student: Sakhineti Praveena
Code
Proposal

Improve RDP support for xdg-desktop-portal-luminous

advanced
Waycrate•2025Varies350h (Large)

Xdg-desktop-portal-luminous is a high-performance capture portal for Wayland compositors that supports frame capture and GPU-copy based frame streaming. The goal of this project is to improve support for Remote Desktop Protocol by ensuring more reliable input simulation and screencasting to enable remote desktop applications to work seamlessly on Wayland compositors using our custom portal backends. This will improve adoption and UX; users will no longer need to depend on other portals for this particular use case, and all use cases can be consolidated into a single portal.

cc++rust+2
Student: nicolo-mn
Code
Proposal

Creating PyApothesis for Kinetic Monte Carlo Simulations

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

The Ziff–Gulari–Barshad (ZGB) model describes how CO and O₂ molecules adsorb and react on a metal surface represented as a square lattice. CO occupies a single site, while O₂ dissociates into two oxygen atoms placed on adjacent sites. When a CO and an O atom meet, they form CO₂, which leaves the surface and frees up space. As the CO partial pressure (yCO) changes, the surface transitions from oxygen-poisoned (no CO₂ production) to reactive (CO₂ formation) and eventually to CO-poisoned. Apothesis is a kinetic Monte Carlo simulator that models these surface reactions with high precision. Building on the ZGB model and the Apothesis simulator, PyApothesis provides a clean, Python-first workflow for running, analyzing, and sharing Kinetic Monte Carlo experiments. From a single script you can change simulation parameters (temperature, pressure, lattice size, seed), define custom adsorption/reaction/desorption processes, and run reproducible simulations — then immediately visualize results with publication-ready plots. PyApothesis includes time-series coverage plots, stacked-area composition views, process-rate and event-count analyses, spatial coverage maps and profiles, and real-time playback of the lattice (color-coded by species) to inspect microscopic behavior as it unfolds. It automatically produces a comprehensive analysis report (plots, logs, and statistical summaries) so users don’t have to dig through raw files, and it exposes hooks to incorporate lightweight ML models for surrogate predictions, parameter scans, or pattern detection directly from Python. Altogether, PyApothesis turns complex surface-kinetics simulations into an interactive, interpretable, and reproducible toolkit ideal for both researchers and students.

pythonmysqljava+7
Student: Om Swastik
Code

Friendly p5.js Reference Translation Tasks

intermediate
Processing Foundation•2025Varies175h (Medium)

This project will build friendly automation tooling to support community translation of the p5.js reference documentation (including p5.js core and p5.sound). The p5.js reference (API documentation) is authored in English via JSDoc comments in the source code, and the website currently offers documentation in five languages (English plus Spanish, Simplified Chinese, Korean, and Hindi)​ . As p5.js evolves, keeping these translations up-to-date is challenging. The goal is to create GitHub Actions and workflows that do not automate translation itself (which requires human nuance​) but instead assist volunteer translators. These tools will automatically track changes in the English “source” docs, flag or open tasks for updates in other languages, suggest new translation needs (for newly added APIs), and streamline communication with translation contributors.

pythonjavascriptandroid+6
Student: Divyansh013
Code
Proposal

VouchMe & TNT: Enhancing VouchMe Features and Revamping TNT (Trust Network Tokens)

intermediate
AOSSIE•2025Varies175h (Medium)

My proposal aims to enhance VouchMe, a blockchain-based testimonial platform, and revamp the UI of TNT (Trust Network Tokens), an ERC721 token system for verifiable trust relationships, to create a robust decentralized trust ecosystem. For VouchMe, I will improve user experience and security by integrating user profiles with Decentralized Identity (DID), enabling direct testimonial sharing via Waku, adding one-click social media sharing, and implementing a burn function to allow users to remove testimonials. Additionally, I will integrate comprehensive smart contract tests to ensure security and reliability. For TNT, I will redesign the landing page and create user-friendly interfaces for creating, managing, and viewing TNTs, ensuring a clear and seamless experience. The deliverables include a fully functional VouchMe with these enhanced features: profiles, DID, Waku-based sharing, and shareable testimonial cards, along with a polished TNT UI for improved usability and accessibility.

pythonjavascriptswift+8
Student: Kanishk Sogani
Code

Improving Core Clang-Doc Functionality

intermediate
LLVM Compiler Infrastructure•2025Varies175h (Medium)

Clang-Doc leverages Clang’s robust tooling and rich symbol information in the AST to generate documentation. It is lacking in some essential functionality such as not supporting some fundamental C++ language constructs, not supporting Doxygen comment commands used in Clang's source code, and not being able to render Markdown. These are essential features in modern documentation tools that should be addressed for Clang-Doc's core feature set.

cllvmc+++3
Student: Erick Velez
Code
Proposal

Developing Karton, the KDE Virtual Machine Manager

intermediate
KDE Community•2025Varies175h (Medium)

The KDE Community will benefit greatly from a native Qt Quick/Kirigami virtual machine manager. Currently, KDE users must use GTK-based VMMs such as virt-manager or GNOME Boxes. Karton, the KDE Virtual Machine Manager, will be able to better integrate with Plasma and can align with the goals of KDE. This project will use the libvirt API rather than the QEMU CLI, which abstracts away some of the low-level implementation details and potentially allow for the app to be cross-platform. A custom graphical viewer will need to be implemented using the SPICE protocol. Registering mouse and keyboard input callbacks should also allow users to interact with virtual machines. Virtual machines created with Karton should be fully customizable through libvirt's domain XML file format. Karton should also have the feature to create snapshots in order to load previous and save states of the virtual machine. Overall, the ultimate goal is to create a polished virtual machine manager that is able to replace our available alternatives.

c/c++qtqml+6
Student: Derek Lin
Code
Proposal

Enhanced Interactive Pipeline Development Environment for JupyterLab

intermediate
Apache Software Foundation•2025Varies175h (Medium)

The BeamVision extension revolutionizes interactive pipeline development in JupyterLab by transforming fragmented notebook visualizations into an integrated workspace, as envisioned in the original design document. At its core lies a dynamic side panel that fundamentally reimagines how users inspect Apache Beam pipelines - consolidating previously scattered visualizations while preserving the documented backward compatibility requirements. This architectural shift directly addresses the project's stated pain points of vertical space consumption and redundant JavaScript code by implementing the described collapsible interface and centralized rendering system. The solution carefully balances innovation with technical constraints through a hybrid approach combining kernel-side HTML generation for reliability with frontend D3.js rendering for interactivity, both explicitly prioritized in the project's technical specifications. Beyond basic visualization, the implementation delivers on the documented cluster management capabilities, providing seamless Flink/Dataproc integration exactly as outlined in the side panel use cases. Every component maintains strict adherence to the original vision - from the multi-tab comparison interface described in the design workflow to the incremental data loading strategy for large datasets. By systematically executing the documented requirements without introducing unsupported features, BeamVision transforms the proposal's vision of "better UX when exploring pipeline states" into a production-ready reality while laying foundations for future extensibility through the approved plugin architecture. The result is a purpose-built environment that finally unlocks Apache Beam's full potential within JupyterLab, precisely as the project architects intended.

pythonjavascriptjava+7
Student: Canyu Chen
Code

Highly Granular Quantization for CICADA

advanced
CERN-HSF•2025$6k–$13.2k350h (Large)

The CICADA (Calorimeter Image Convolutional Anomaly Detection Algorithm) project aims to detect anomalous physics signatures without bias from theoretical models in proton–proton collisions at the Compact Muon Solenoid (CMS) experiment at the Large Hadron Collider. CICADA identifies anomalies in low-level calorimeter trigger data using a convolutional autoencoder, whose behavior is transferred to compact student models via knowledge distillation. Careful model design and quantization ensure sub-200 ns inference times on Field Programmable Gate Arrays (FPGAs). CICADA currently uses a distilled neural network model with layer-wise quantization to meet the strict sub-200ns latency required for the CMS Level-1 Trigger (L1T), trained using QKeras (a now-deprecated library for quantization-aware training). This GSoC project aims to enhance CICADA by integrating highly granular quantization (HGQ) techniques, which allow automatic, per-weight and per-bias quantization, providing finer control over model precision and resource usage. This project involves developing a HGQ version of the CICADA distilled model and evaluating its performance and resource consumption when deployed on a FPGA, while contributing to the open-source CICADA, HGQ2 and hls4ml frameworks as needed. Notably, the HGQ2 library is also compatible with JAX, opening the door for future integration with modern, hardware-friendly ML ecosystems. These contributions will benefit the broader fast machine learning community focused on deploying ML models in low-latency, resource-constrained environments.

pythonc/c++machine learning+6
Student: Abhishikth Mallampalli
Code
Proposal

Build a Modern, Compiler-Integrated Kotlin Language Server

advanced
Kotlin Foundation•2025$6k–$13.2k350h (Large)

This project aims to build a high-performance, build-system agnostic Kotlin Language Server using the Kotlin Analysis API. The goal is to replace the unmaintained and inefficient open-source LSP with a modern implementation that supports the full LSP 3.17 spec, works across editors like VSCode and Neovim, and delivers IDE-grade language features like diagnostics, completions, and navigation without depending on kotlinc. By the end of GSoC, this project will provide Kotlin developers with a powerful alternative for writing and maintaining code outside JetBrains tooling.

gradlekotlinjvm+3
Student: Hemram
Code
Proposal

Introduce ext_image_capture_source_v1 protocol support in Wayshot and improve security features

intermediate
Waycrate•2025Varies175h (Medium)

This project aims to enhance Wayshot by implementing the newly standardized ext_image_capture_source_v1 Wayland protocol, which provides a standardized method for display and window capture, replacing the current dependency on the non-standard wlr-screencopy protocol. I will develop a new backend that fully utilizes this official protocol while maintaining the existing wlr backend for backwards compatibility, enabling native top-level window capture capabilities and improving user experience. The implementation will include a security notification system utilizing D-Bus to alert users which applications were captured by Wayshot clients, enhancing transparency and user privacy. Additionally, I will integrate the standardized protocol with xdg-desktop-portal-luminous to enable WebRTC streaming capabilities, The deliverables of this project are: a complete solution that includes the new backend, backwards compatibility, security notifications, WebRTC streaming support, and comprehensive documentation.

cc++rust+2
Student: Rishik Y
Code

Reduce computations in JOINs by using Bloom-filter-based pre-joins

advanced
MariaDB•2025Varies350h (Large)

Implement an efficient Bloom Filter to reduce JOIN's computations. Idea is to apply Bloom filter on columns to filter the data as much as possible, and then feed the data to JOIN. This will significantly reduce the amount of memory taken by JOIN operation and increase its performance.

cmysqlmariadb+7
Student: Akhmad Oripov
Code
Proposal

Implementation of Standard Data Structures and Algorithms

intermediate
Pharo Consortium•2025Varies175h (Medium)

Pharo currently lacks robust, well-designed implementations of fundamental data structures, with existing collections being weakly supported and inconsistently designed. This project addresses this gap by developing a comprehensive library of essential data structures including Buffers, Linked lists, Stacks, Queues, Heap and various types of Trees (like Binary Search Trees, AVL, Red-Black & Tries) . The implementation will deliver a flexible, extensible framework with consistent APIs, thorough documentation, and comprehensive Test coverage. The result will be a production-ready collection of data structures that follow object-oriented principles, enhance developer productivity, and integrate seamlessly with the Pharo environment, enabling more efficient and maintainable code for the entire Pharo community.

smalltalkroassalpolymath+7
Student: Alok Pathak
Code
Proposal

Expanding OSS-Fuzz Integration Across KDE Libraries

intermediate
KDE Community•2025Varies175h (Medium)

Fuzzing is an automated testing technique that feeds random or unexpected inputs to programs to find bugs and security issues. OSS-Fuzz is a SaaS by Google that continuously runs fuzzers against open source projects to catch these issues early. This project aims to expand OSS-Fuzz integration across more KDE libraries, focusing on those that handle external inputs like file parsers and thumbnail generators, which are prone to parsing and memory bugs. By identifying high-priority targets, writing and setting up dedicated fuzzers, the goal is to catch potential vulnerabilities early and improve the security and stability of the KDE ecosystem.

c/c++qtqml+6
Student: Azhar Momin
Code
Proposal

Generate Problem Editorials Using AI

intermediate
omegaUp•2025Varies175h (Medium)

This project aims to increase editorial coverage to 70-80% by automating creation with AI. Admins can generate editorials in bulk from the problem list, while authors can trigger generation during problem creation. The system validates editorials by testing solutions and automatically fixes issues found during validation.

pythonmysqlphp+2
Student: Samman Sarkar
Code
Proposal

Enhancing Connection Pool Management and Visualization for Apache Seata’s AT/XA Transaction Modes

advanced
Apache Software Foundation•2025Varies350h (Large)

This project aims to enhance connection pool management in Apache Seata’s AT/XA transaction modes by introducing a unified, user-friendly monitoring and configuration system. Currently, Seata lacks a visual and configurable interface for observing and managing internal connection pools, which are essential for maintaining performance and stability in distributed transaction processing. This project addresses that gap by developing a new console dashboard that displays real-time connection pool metrics (such as active, idle, and total connections) and provides controls for adjusting parameters like minimum/maximum connections, timeouts, and keep-alive durations. The solution will include front-end Vue components, back-end Spring Boot APIs, and a service layer to handle the core business logic. It will also include thorough unit and integration testing to ensure reliability and correctness. Deliverables include: 1. A real-time dashboard for connection pool monitoring 2. A dynamic console interface for configuration management 3. Backend REST APIs and business logic for pool metrics and settings 4. User and developer documentation 5. Comprehensive unit and integration tests

pythonjavascriptjava+7
Student: Oscar Cheng
Code

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

OWASP Contribution Hub Development

beginner
OWASP Foundation•2025Varies90h (Small)

The Contribution Hub will be a platform that helps newcomers find mentors for open source projects. The system will let users log in with GitHub, create profiles showing their skills, and get matched with the right mentors based on what they know and want to learn. Contributors will see a dashboard with project suggestions and issues that match their skill level. They'll also be able to track their progress and see how they're improving. For beginners, the platform will highlight easy-to-start issues and group similar tasks together for hackathons. The system will help solve common problems new contributors face by providing guidance, recommending tasks they can handle, and connecting them with experienced mentors who can help them grow. Regular feedback from both mentors and contributors will help make the platform better over time.

pythonjavascriptjava+10
Student: __RajGupta
Code
Proposal

Kotlin Multiplatform App Template Framework

intermediate
The Mifos Initiative•2025Varies175h (Medium)

I propose to enhance the Mifos Initiative's Kotlin Multiplatform (KMP) Multi-Module Project Generator to streamline cross-platform application development and make it more valuable for developers. My plan is to create a customizable Material Design 3 component layer for a consistent UI across platforms, implement a unified configuration system, and enhance GitHub Actions workflows for comprehensive CI/CD. I'll develop pre-built infrastructure components (networking, database, storage), streamline dependency management with Gradle plugins, improve the sync directories system, add a type-safe API client with Ktorfit, and automate library publishing to Maven Central. With my experience in Kotlin (3+ years) and Kotlin Multiplatform (2+ years), plus my extensive contributions to Mifos projects, I have the technical foundation to implement these enhancements successfully. I've created a detailed 15-week implementation plan with clear deliverables for each stage. These improvements will transform the KMP Project Generator into a more powerful and user-friendly tool, benefiting both the Mifos ecosystem and the broader KMP community by reducing development time and ensuring best practices across platforms.

mysqljavascriptandroid+5
Student: Sk Niyaj Ali
Code
Proposal

[Project 20] Build an AI Agent for KnowledgeSpace using Retrieval-Augmented Generation (RAG)

advanced
INCF•2025Varies350h (Large)

This project builds an AI-powered agent for KnowledgeSpace using Retrieval-Augmented Generation (RAG) to deliver precise, context-aware, and scientifically accurate answers. It combines Elasticsearch results with vector search (e.g., Vertex AI Vector Search) through an agentic system implemented in LangGraph, which orchestrates tool calls and fuses evidence for high-quality responses. The backend is a FastAPI service deployed on Google Cloud Platform with Vertex AI, and the frontend is a responsive React application. An automated update script regularly ingests new datasets and refreshes indices/embeddings to keep answers current. Together, these components streamline how neuroscientists explore and use complex neuroscience data.

pythonjavac+++7
Student: Swastik R
Code
Proposal
Showing 1249 - 1272 of 11996 Projects
5152535455
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal