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

Streaming window functions and optimization of RRF queries.

beginner
MariaDB•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 →
90h (Small)

Window functions in MariaDB are currently always materialized into temporary tables before producing any results, even for simple cases, like ranking with a limit. This prevents index usage, enforces unnecessary sorting, and introduces avoidable I/O overhead. For hybrid search queries that combine vector and full-text search using Reciprocal Rank Fusion (RRF), this limitation forces both result sets to be fully computed before any top results can be returned, significantly impacting performance. This project introduces a streaming execution path for window functions, allowing eligible queries to produce rows incrementally without materialization. Building on this, a dedicated execution node for RRF will merge vector and full-text search streams and return top results early, avoiding full computation of either source and significantly improving hybrid search efficiency.

cmysqlmariadb+7
Student: Omar Gamal 10
Code
Proposal

Numba Optimized Implementations for scikit bio Performance Critical Functions

advanced
NumFOCUS•2026Varies350h (Large)

scikit-bio relies on Cython extensions for performance-critical distance and ordination operations, but these cannot accept GPU arrays. This project replaces Cython functions with Numba implementations that match or exceed Cython on CPU via njit parallel and provide GPU execution via cuda jit. The work covers center_distance_matrix, Mantel permutations, PERMANOVA, geomedian, and ordination utilities. I have two open PRs (2429, 2436) adding Array API support, a working Numba prototype benchmarked against Cython, and mentor endorsement to center the proposal around this optimization approach.

pythonjavascriptr+3
Student: AbidKhan
Code
Proposal

Multiplayer, IoT, and Home Assistant support via two MQTT bricks

beginner
International Catrobat Association•2026Varies90h (Small)

Pocket Code currently lacks a scalable way for projects to communicate beyond a single device, which limits its ability to support real-time multiplayer features and IoT use cases. While Bluetooth-based communication exists, it is limited in range and flexibility, and does not support internet-based interaction or integration with modern systems like smart home platforms. This project solves this by adding MQTT-based communication to Pocket Code through simple visual bricks for sending and receiving messages. A shared connection manager handles communication efficiently, with support for secure connections, message routing, and reliability through offline queuing and retries. It also introduces a standard topic structure for IoT integration (e.g., Home Assistant) and enables multiplayer synchronization over Wi-Fi, making Pocket Code a more connected and powerful platform. Key Deliverables: 1. MQTT connection manager with lazy initialization and connection reuse 2. Publish and Receive MQTT bricks integrated into Pocket Code 3. Wildcard topic support and event-driven message handling 4. Offline message queue with automatic retry on reconnect 5. Secure communication using TLS and authentication 6. Standardized MQTT topic conventions for IoT and Home Assistant integration 7. MQTT-based multiplayer synchronization layer 8. Comprehensive automated tests (TDD-based development) This project transforms Pocket Code into a connected programming platform, enabling users to build real-time multiplayer applications and interact with IoT devices using an intuitive visual interface.

javascriptandroidswift+4
Student: Paras_77
Code

Generalized changepoint regression

intermediate
R project for statistical computing•2026Varies175h (Medium)

Changepoint detection is widely used in modern data streams, but current regression based changepoint methods are limited in flexibility. Existing approaches typically assume that when a changepoint occurs, it affects all regression variables at the same time. This makes it difficult to model realistic scenarios where some components remain fixed while others change. This project aims to develop an open source R package implementing recent work on generalised changepoint regression, where users can specify both fixed and changing regression covariates. The approach builds on existing research level code, which will be refactored into a generic framework function capable of handling a range of regression models, including time series settings. The project will deliver a fully functioning R package with user-facing functions and supporting tools such as summary, print and plotting methods, designed to be consistent with existing changepoint packages. It will also include extensive testing, simulation functions for generating data, and clear documentation, with the goal of producing a CRAN ready package. Should time allow adding mixed effects or non-parametric regression models would be included. Overall, this project will provide a flexible and practical tool that addresses a gap in current changepoint methodology and will be useful for applied users.

cc++r+4
Student: Andrea Storey
Code
Proposal

Resonate-V4

advanced
AOSSIE•2026Varies350h (Large)

This project focuses on evolving Resonate into a more interactive, scalable, and maintainable real-time audio platform by introducing both feature-level enhancements and architectural improvements. Key user-facing features include chat-integrated polling, availability status, audio wave animations, interest-based discovery, and a gamified user stats system that provides meaningful reputation signals. These features aim to improve engagement, usability, and community interaction without compromising real-time performance. Alongside feature development, the project emphasizes core architectural modernization, including migrating from GetX to Riverpod, adopting a feature-based MVVM structure, decoupling business logic from UI, and optimizing the Appwrite backend. Additional improvements such as increased test coverage and recorded chapter management ensure long-term reliability and usability. Overall, the project balances product innovation with system scalability, transforming Resonate into a more robust and contributor-friendly platform.

pythonjavascriptswift+8
Student: Mayank4352
Code
Proposal

Increasing PEcAn Modularity - Refactoring the Trait-Meta-analysis-Configuration Pipeline

intermediate
PEcAn Project•2026Varies175h (Medium)

This project aims to refactor the core PEcAn workflow by decoupling heavy computational logic from disk I/O. Currently, data is passed via hidden .RData files, making the system difficult to test and maintain. I will modularize the Trait-Meta-analysis-Configuration chain to allow for in-memory data passing while maintaining data provenance as an opt-in persistence feature. Key deliverables include a "pure" version of get.trait.data.pft(), a standalone design matrix generator, and updated PDA/SDA workflows to support the new modular architecture, ensuring a more transparent and testable pipeline for ecological modeling.

cpostgresqljavascript+8
Student: Om Kapale
Code
Proposal

Agentic Toolkit for AI PC with OpenVINO

intermediate
OpenVINO Toolkit•2026Varies175h (Medium)

OVAT is a modular Python toolkit with a CLI for building and running local AI agents on Intel AIPCs. Uses OVMS as the inference backbone, adds YAML-driven configuration validated with pydantic v2, framework integration with LangChain, LlamaIndex, and OpenAI Agents SDK, MCP tool registration for document search and audio transcription, provider abstraction for swappable LLM/Embedding/Retriever backends, and hardware-aware GPU/NPU device routing. Includes tiered hardware profiles for 8GB and 16GB machines with sample agents. Core patterns validated by OvaSearch, a working C++ RAG engine with P50 6ms retrieval and zero crashes across 100-query stress test.

pythonc++x86+1
Student: Lagmator22
Code
Proposal

Text Improvement

intermediate
Graphite•2026Varies175h (Medium)

The goal of the project is to improve the existing implementation of the text node and extend the text support by adding lorem ipsum placeholder, formatting spans and typographical parameters, text on path, text in option to enforce casing (lower, upper, title) area, hyphenation, font fallbacks, flows between text areas, upper case, lowercase, toggle for ligatures and vertical typing.

machine learningrustvulkan+2
Student: Bunnyy
Code
Proposal

imzML Parser in OpenMS

advanced
OpenMS Inc•2026Varies350h (Large)

Mass spectrometry imaging (MSI) is a powerful analytical technique that enables spatial mapping of molecules within biological tissues. The imzML format is the open standard for storing MSI data, consisting of an XML metadata file and an associated binary data file. OpenMS currently lacks native support for reading and writing this format. The goal of this project is to implement a robust imzML parser in OpenMS, enabling seamless integration of mass spectrometry imaging data into existing OpenMS workflows and applications. The proposed solution already demonstrates the ability to load and parse both continuous and processed imzML formats, including support for large datasets. The implementation has been benchmarked against pyimzML for validation and consistency. This project will further extend the work by integrating with OpenMS Python bindings (currently under development), while identifying potential challenges and outlining strategies and solutions to address them. Tasks: Implement a C++ imzML reader capable of parsing both continuous and processed imzML formats Develop an imzML writer to support exporting imaging data Add support for essential imzML metadata, including spatial coordinates, pixel size, and spectrum-level parameters Integrate the parser with existing OpenMS data structures (e.g., MSExperiment, MSSpectrum) Write comprehensive unit tests and validate functionality against reference imzML datasets Document the implementation and provide clear usage examples.

pythoncythonc+++2
Student: Aditya Sarna
Code
Proposal

ONE-PASS HNSW SEARCH FOR MARIADB VECTOR SEARCH

advanced
MariaDB•2026Varies350h (Large)

MariaDB's HNSW vector index searches the graph layer by layer, isolating each level's connections. This means denser lower-layer edges are invisible until a separate pass reaches them, and the purely flat alternative, which expands all layers unconditionally, wastes distance computations on unproductive regions, degrading performance. Solution: Implement VF-HNSW (Virtually Flattened HNSW), a new search mode for MariaDB's vector search engine. VF-HNSW searches all layers in a single pass with adaptive descent: for each candidate, it expands neighbors from the top layer downward, using sparse upper layers as cheap probes and stopping early when a layer fails to improve on the one above, avoiding expensive dense-layer expansion for candidates in unproductive regions. Deliverables: A vf_hnsw search mode in sql/vector_mhnsw.cc with adaptive descent, including correctness and regression tests. A benchmark report comparing hierarchical, flat, and VF-HNSW across ANN-Benchmarks datasets, with recommended defaults and tradeoff analysis. Per-query status variables expose upper-layer expansions attempted, layers skipped, and distance computations saved.

cmysqlmariadb+7
Student: ZtuyingChan
Code
Proposal

EnergyAPI: An End-to-End API for Energy-Aware Forecasting and Scheduling

advanced
UC OSPO•2026Varies350h (Large)

Electricity grids today serve a far more complex mix of consumers than they were designed for. Data centers, EV charging networks, and industrial facilities participate in demand-response programs, shifting flexible workloads to windows where electricity is cheaper or cleaner. Acting on those signals requires software that collects real-time grid data across multiple regions, forecasts how conditions will evolve over the next several hours, and exposes both through a clean API that developers can query directly. Existing open-source infrastructure for grid signal forecasting covers carbon intensity reasonably well, but critical gaps remain: the data acquisition layer and the API serving layer are not connected, fresh data does not automatically trigger model inference, and signals beyond carbon intensity such as demand, price, generation mix, and grid saturation are not exposed through any unified interface. There is also no interactive frontend that makes regional grid conditions spatially visible. EnergyAPI addresses each of these gaps. The platform is structured across five layers: an automated scheduled data acquisition service pulling from NOAA NOMADS, EIA, and ENTSO-E, an extended relational data model covering all five grid signals, a forecasting pipeline connecting fresh data to existing carbon intensity models while adding SARIMA-based demand forecasting and gradient boosting for price, a Django REST API with a workload scheduling interface that accepts SLOs and returns execution plans, and an interactive web frontend with time-series charts and a choropleth map of EU and US regions.

pythonc/c++visualization+5
Student: Prarthana Patil
Code

Host-Based Pipeline Deployment for the Debezium Platform

intermediate
JBoss Community•2026Varies175h (Medium)

The Debezium Management Platform currently deploys pipelines only to Kubernetes. This project adds host-based deployment support, enabling users to deploy Debezium Server pipelines to bare-metal servers and cloud VMs via SSH and Docker. The implementation integrates into the platform's existing event-driven architecture by adding a new EnvironmentController for host targets, an SSH-based provisioning service that validates and prepares remote hosts, a lightweight agent deployed on each host for managing the Debezium Server lifecycle via REST APIs, and a status polling mechanism for monitoring deployments. Key deliverables include the host registration API, automated provisioning with remediation, the Debezium Host Agent, Docker-based deployment engine, config drift detection, and comprehensive integration tests using Testcontainers.

androidjavaide+12
Student: d1vyanshu-kumar
Code

Automated Workflow

intermediate
Joomla!•2026Varies175h (Medium)

Joomla's workflow system and the scheduled task system currently work independently of each other, and this project aims to connect these tools by creating an Automated Workflow feature that combines both systems, which will enable administrators to configure timed rules directly within the workflow transition configuration, specifying how long after entering a stage an item should automatically be moved to the next stage, supporting both straight workflows and loops. A background scheduled task plugin will then execute these transitions at defined intervals. Deliverables: - A task plugin that executes timed transitions. - A workflow plugin that logs stage entry timestamps. - A UI in the transition edit form and graphical editor. - Per-item scheduled transitions for individual articles. - An execution history and upcoming transitions preview view.

javascripthtmlphp+7
Student: Weno Hans
Code
Proposal

OWASP OpenCRE Module A: Incremental Information Harvesting Pipeline

intermediate
OWASP Foundation•2026Varies175h (Medium)

OpenCRE currently lacks an automated mechanism to continuously monitor upstream security knowledge sources such as OWASP repositories and detect meaningful documentation updates as they occur. Important changes are often introduced incrementally across commits, making manual tracking inefficient and prone to delays. This project proposes an incremental information harvesting pipeline that runs on a scheduled basis using GitHub Actions. The system will monitor configured repositories and detect recent commits using time-based Git queries, filter out non-relevant files through a noise reduction layer, and extract meaningful textual changes from diffs. These changes will be reconstructed into clean, structured artifacts and stored in an append-only raw change bucket for downstream processing. The key deliverables include a configurable repository registry, an incremental diff extraction engine, a noise filtered text parsing pipeline, structured change artifact generation, and a production ready automated workflow with logging, retry handling, and test coverage. The output of this module will serve as a reliable foundation for downstream systems such as RAG based knowledge processing pipelines.

pythonjavascriptjava+10
Student: ParthAggarwal
Code

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

Neural Extraction Framework: Enhancing Knowledge Graph Extraction via Neuro-Symbolic Integration

intermediate
DBpedia•2026Varies175h (Medium)

This project scales the DBpedia Neural Extraction Framework into a production-ready system by integrating a Neuro-Symbolic validation layer. Key innovations include an Axiomatic Consistency Checker to eliminate LLM hallucinations using DBpedia OWL constraints, and a high-throughput Redis-backed architecture capable of indexing the full 50GB Databus dump with sub-millisecond latency. By bridging probabilistic neural extraction with deterministic symbolic reasoning, the framework ensures the generation of high-precision, ontologically valid RDF triples for the DBpedia 2026 release.

javascalardf+7
Student: Nakul156
Code
Proposal

Pitivi Timeline Ruler: Native GTK4/Rust Rewrite

intermediate
GNOME Foundation•2026Varies175h (Medium)

The Pitivi timeline ruler currently relies on a legacy Python implementation using GTK3 and the Cairo drawing model. As Pitivi updates to a modern GTK4 native structure, the CPU-heavy Cairo draw calls are becoming a bottleneck for rendering time markers and frames at varying levels of zoom. This project will rewrite the ruler as a standalone, native GTK4 widget using Rust and ‘gtk-rs’. By moving away from Cairo and utilizing GTK4’s hardware acceleration via ‘GtkSnapshot’ and Render Nodes, the new ruler will be significantly more performant and memory-safe. Following a modular design philosophy, the widget will be built independently with a robust GObject API before being integrated into Pitivi’s existing Python and GStreamer Editing Services (GES) infrastructure using GObject introspection.

cpythonjavascript+4
Student: Michael Calabrese
Code
Proposal

LibreOffice OpenType MATH

intermediate
LibreOffice•2026Varies175h (Medium)

The goal of this project is to support using OpenType math fonts with a MATH table in LibreOffice Math. It will use data from the MATH table to layout math formulas, based on OpenType MATH, TeX, or MathML Core algorithms. For backward compatibility, this new code should only be used for fonts with a MATH table and only for new documents. This project will fix a number of outstanding issues with LibreOffice Math, and allow using more math fonts, which will attract more users, particularly in the scientific and academic community.​

pythonandroidjava+2
Student: Aya Jamal AlSayed
Code
Proposal

Idea #7: Local Note Encryption

intermediate
Joplin•2026Varies175h (Medium)

Joplin’s end-to-end encryption protects notes during sync, but not on the local device. This project adds local note encryption so users can lock sensitive notes behind a vault password while preserving compatibility with sync and existing E2EE. The implementation will use an option-gated save/load flow, on-demand decryption, protection against plaintext leaks through search and revision history, and a lock screen UI for desktop. Guaranteed deliverables are a working desktop implementation, vault password management, sync/backward-compatibility support, and tests for data-safety and conflict handling. Stretch goals include mobile support, resource encryption, and CLI/Data API integration.

reactnode.jsreact native+5
Student: Keshav0479
Code
Proposal

Add Spatio-Temporal Datasets Support to GRASS Data Catalog GUI

intermediate
NumFOCUS•2026Varies175h (Medium)

Currently, the GRASS Data Catalog only queries standard spatial maps and bypasses the temporal database and STDS's entirely. As a result, Space Time Datasets are completely invisible in the catalog interface, forcing users to manage them exclusively via the command line. This project will extend the existing Data Catalog architecture to natively support STDS. A solution will be implemented to show STDS alongside the standard spatial maps, fetching and displaying STRDS, STVDS, and STR3DS objects inside their respective mapset trees. Additionally, the project will enhance Data Catalog functionalities, such as context menus and other operations, to fully recognize, search, and interact with STDS objects in the GRASS GUI. Beyond these GUI integrations, the project will also focus on resolving critical bugs and enhancing the functionality of core temporal tools to improve the overall user workflow.

pythonjavascriptr+3
Student: Saket Kumar Mall
Code
Proposal

UNESCO World Heritage

intermediate
Liquid Galaxy project•2026Varies175h (Medium)

While UNESCO World Heritage Sites connect us to our shared global past, standard maps fail to capture their true scale and cultural significance. To solve this, I am developing an open-source Flutter application that acts as a smart remote control for the Liquid Galaxy multi-screen system, featuring a home screen widget for quick and accessible rig control. The app transforms official datasets into an immersive experience by generating synchronized 3D KML maps and informative visual overlays. It also integrates Gemini AI to power a voice-enabled assistant that answers user queries about heritage sites, narrates engaging historical stories, and automatically "fly to" the Google Earth view to the exact locations being discussed. The final deliverables include the functional mobile app, dynamic 3D visualization along with AI storytelling modules, and comprehensive setup documentation hosted on GitHub.

javascriptrosgis+14
Student: Saumya_Bhattacharya
Code
Proposal

Native Julia ODE, SDE, DAE, DDE, and (S)PDE Solvers

advanced
NumFOCUS•2026Varies350h (Large)

OrdinaryDiffEq.jl contains over 18 IMEX Runge–Kutta implementations that share identical stepping logic but have bespoke per-method perform_step! functions. This creates massive code duplication and makes adding new methods prohibitively expensive. This project builds a unified IMEXTableau{T,T2} infrastructure — one struct holding both explicit and implicit Butcher arrays, one generic perform_step! dispatching on it — so new IMEX methods require only coefficient definitions. The existing KenCarp and Kvaerno families (18 methods) are migrated to this framework, deleting ~3,300 lines of hardcoded code. New Pareschi–Russo methods from issue #2065 are added on top of the infrastructure. The second deliverable extends the multirate solver family. MREEF (Multirate Extrapolated Explicit Euler) is already implemented and approved (PR #3139). This project adds MREIL (linearly implicit variant for stiff fast components) and MIS methods (Schlegel–Knoth scheme used in atmospheric chemistry, issue #1195). Key deliverables: Generic IMEXTableau framework with one perform_step! replacing 18 implementations Migration of KenCarp/Kvaerno family with ~3,300 lines deleted Pareschi–Russo IMEX methods (issue #2065) MREIL: linearly implicit multirate extrapolation MIS methods: Schlegel–Knoth atmospheric chemistry scheme (issue #1195) Convergence tests and SciMLBenchmarks work-precision diagrams for all new methods

pythonjavascriptr+3
Student: HARSH_K
Code
Proposal

PyASL: GUI, preclinical functionalities and batch mode

intermediate
Open Science Initiative for Perfusion Imaging•2026Varies175h (Medium)

In previous roadmaps, we collected code to create PyASL, a Python library to preprocess ASL data (both preclinical and human brain data). PyASL not only enables users to compare different preprocessing pipelines, but its modular structure also allows users to mix and match functionalities from different established pipelines to best suit their needs. To facilitate its usage among non-experts, we aim to develop a GUI for this library and expand its functionalities.

pythongithub
Student: tech0priyanshu
Code
Proposal

FOSSBot Platform: Simulation Enhancements and AI Integration

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

The FOSSBot Platform aims to enhance robotic simulation environments by integrating AI-driven capabilities and improving simulation realism. The project focuses on extending existing open-source robotic simulation tools with advanced features that support experimentation, education, and research in autonomous systems. Emphasis is placed on modularity, extensibility, and reproducibility within open-source ecosystems.

pythonmysqljava+7
Student: jgenc
Code
Proposal
Showing 889 - 912 of 11996 Projects
3637383940
Proposal
Proposal
Proposal
Proposal