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

Improve the UI and visual design of the Zulip web app

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

The Zulip web application is being redesigned but there are several UI inconsistencies in various parts of the web app. After seeing the redesign-label issues, I understood that the modals, sidebars, icons, and interactive visual features are not all developed with an integrated look. This makes an inconsistent user experience with elements such as modal inputs being unstandardized, Icons and symbols lacking visual consistency across the web app components, and elements within the sidebar having improper alignment, scroll animation, and elements such as link styles, color logic, and interactions. The goal of this project is to standardize and improve these UI elements in a structured way. I will work on redesign-labeled issues along with UI tasks, improving design pattern consistency, improving CSS structure, and managing elements with modern UI standards. With careful testing and taking mentor feedback to ensure accuracy, have discussions on future design provided in Figma.

pythonjavascriptdjango+5
Student: Yogesh-Shivaji365
Code
Proposal

Improve configuration compatibility with OpenSSH

intermediate
libssh•2026Varies175h (Medium)

The SSH client obtains its configuration either from command line arguments or from configuration files such as ~/.ssh/config and /etc/ssh/ssh_config. These files are parsed by the SSH client implementation (for example OpenSSH or clients built on top of libssh) and the parsed options are applied to the session configuration. Libssh follows a parsing architecture that slightly differs from OpenSSH. As a result, configuration files may be interpreted differently by the two implementations. Additionally, OpenSSH usually tends to be one-step ahead in introducing new configuration options, and libssh is having a hard time catching up with them. In such cases, libssh should ideally ignore unsupported options gracefully rather than misinterpreting them or causing unexpected behavior. Due to these differences, the same configuration file can produce different parsing results between OpenSSH and libssh. Since OpenSSH is the most widely used SSH implementation, such divergences may cause inconvenience for users and reduce configuration compatibility. This project focuses on building a differential fuzzer that compares how OpenSSH and libssh parse SSH configuration files. The fuzzer will mutate configuration inputs and identify cases where the two implementations behave differently. Based on the discovered divergences, libssh’s configuration parser will be refined to align its behavior more closely with OpenSSH. Finally, regression tests will be introduced for the discovered issues to ensure that future changes do not reintroduce the same bugs.

csshci+2
Student: Nikhil Venkatesan
Code
Proposal

Archival and Restore Feature for SW360

intermediate
SW360•2026Varies175h (Medium)

SW360 instances running for years accumulate thousands of stale projects, components, and releases that slow down searches, waste disk space, and clutter the UI. Currently, the only cleanup option is permanent deletion with no undo. This project adds a reversible archival workflow. Admins select entities, export them as self-contained TAR.GZ bundles with all metadata and attachments, then remove them from the live database. A CouchDB registry tracks what was archived and by whom. To restore, admins upload the archive, preview contents with conflict detection, and selectively re-insert entities. Deliverables: archival.thrift service definition, backend Maven module with archive and restore logic, REST API endpoints, a frontend admin page with entity selection, registry table, and multi-step restore flow, plus unit and E2E tests."

javareactcouchdb+1
Student: Taanvi Khevaria
Code
Proposal

Translator Feedback Loop for Joomla (Inspired by RLHF)

intermediate
Joomla!•2026Varies175h (Medium)

This project introduces a native Translator Feedback Loop for Joomla (Inspired by Reinforcement Learning from Human Feedback "RLHF") to improve machine translations over time. This project will work by capturing human corrections and injecting them into future LLM prompts via a decoupled RAG architecture, the system aims to ensure consistent, community-standard terminology for all the supported languags. The Final deliverable is a extension package including a specialized translator dashboard, background task scheduler and AI framework integration.

javascripthtmlphp+7
Student: Krishna Gandhi
Code
Proposal

Mifos Gazelle - OpenSPP integration

advanced
The Mifos Initiative•2026Varies350h (Large)

Right now, Mifos Gazelle automatically deploys core components like Payment Hub EE and MifosX. My project will integrate OpenSPP (Open Source Protection Platform) as a new, first-class deployment module inside Gazelle. Instead of just deploying the pods, I will build a fully reproducible end-to-end demo. This will prove that a social welfare program defined in OpenSPP can seamlessly execute payments through the Gazelle infrastructure. I will update the Bash and Python orchestration scripts, add fail-fast dependency checks, and optimize the resource limits for demo environments. Deliverables include: Integrated deployment logic for OpenSPP within the Gazelle CLI. A working end-to-end demo scenario (OpenSPP + Payment Hub EE + MifosX + vNext). Infrastructure optimization and clear runbooks for future maintainers.

mysqljavascriptandroid+5
Student: Ismael--Sallami
Code
Proposal

Group Representation Theory and Character Tables

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

This proposal aims to implement algorithms character tables computation algorithms for SymPy. Fourteen years ago in 2012, Aleksandar Makelov's GSoC project regarding group theory envisioned the feature of computing character tables in SymPy, and this GSoC project in 2026 is planning to fulfill this long-standing goal.

pythonc++numpy+1
Student: ForeverHaibara
Code
Proposal

data.table

advanced
R project for statistical computing•2026$6k–$13.2k350h (Large)

The proposal includes detailed information about me (such as my qualifications and other relevant details), project details, my approach to the project, the timeline, and other essential aspects. project details: This project focuses on enhancing the functionality and performance of the widely-used R package, data.table, by prioritizing low-level C programming improvements and advanced performance benchmarking. The primary objective is to optimize the core functionality of data.table by implementing efficient C-level changes, ensuring faster data manipulation and analysis. I have previously been selected for Google Summer of Code 2025 with the same organization and worked on the same data.table project, which helped me gain a strong understanding of the codebase, architecture, and contribution workflow. This experience allows me to start contributing immediately and focus on high-impact improvements. I am approaching GSoC 2026 with stronger motivation, deeper technical insight, and a clear goal of making more substantial contributions. Performance benchmarking will be a key focus, utilizing tools like atime to rigorously test and validate improvements, ensuring reliability and scalability for diverse use cases. While the main emphasis is on performance optimization and functionality enhancements, the project will also include supplementary work on expanding documentation through concise vignettes or whitepapers to provide insights into the technical improvements made. This initiative aims to deliver a more robust and high-performing data.table package, empowering data analysts and statisticians with faster and more reliable tools for their workflows.

cc++r+4
Student: Vinit Thakur
Code
Proposal

KeepSecret: UX Improvements and Feature Additions

intermediate
KDE Community•2026Varies175h (Medium)

KeepSecret is a modern password manager built using Qt/QML and Kirigami, but there are still a few areas that need improvements. For example, the sidebar currently appears even for users with a single wallet, which isn’t necessary. Features like import/export are missing, there’s no built-in password generator, and copied passwords stay in the clipboard without being cleared. Keyboard navigation is also incomplete, and there are some build warnings that is unresolved. This proposal addresses all these areas: completing the sidebar-hiding feature with correct page navigation, resolving outstanding build warnings, implementing import and export functionality, adding a password generator, improving keyboard-only navigation, implementing clipboard auto-clear after copying a password, and adding a close button for the entry detail panel.

c/c++qtqml+6
Student: Roshani Kumari
Code
Proposal

Make Wayang More Datalake-Friendly

advanced
Apache Software Foundation•2026Varies350h (Large)

Apache Wayang currently supports batch engines (Spark, Flink) and OLTP databases via JDBC, but lacks integration with modern data lake engines — Trino, BigQuery, Dremio, and AWS Athena — where most analytical workloads now run. This project integrates these engines into Wayang's optimizer and executor through a shared JDBC Template abstraction layer, so each new engine inherits common infrastructure (connection management, SQL assembly, channel conversions) and only overrides engine-specific behavior. The deliverables are: (1) platform, executor, and plugin implementations for Trino, BigQuery, Dremio, and Athena; (2) operator mappings that translate Wayang logical operators (filter, projection, aggregate, join) into engine-native SQL; (3) per-engine cost models calibrated via TPC-H benchmarks so the optimizer can score data lake engines against Spark/Postgres alternatives; (4) end-to-end demo pipelines and contributor documentation. The approach has already been verified with working Trino, BigQuery, and Dremio demonstrations for table scan, filter, and projection operators.

pythonjavascriptjava+7
Student: Jun Wang
Code
Proposal

Generic MinimumLinuxBoot for RTL Simulations

intermediate
Free and Open Source Silicon Foundation•2026Varies175h (Medium)

Booting Linux in OpenPiton's Verilator RTL simulation takes days. This project builds a checkpoint/restore pipeline: boot Linux in QEMU (minutes), extract machine state, convert it to OpenPiton's `mem.image` format, and resume execution in RTL simulation with Linux already running.

pythonjavascriptfpga+11
Student: Xuhai Chang
Code
Proposal

Benchmarking and Performance Evaluation of Inference Routing Extensions in kgateway

beginner
CNCF•2026Varies90h (Small)

kgateway routes AI inference traffic to self-hosted model servers. It picks the best server using EPP scoring — based on KV cache usage, queue depth, and LoRA affinity. That scoring costs more than simple round-robin routing, but there's no data on how much latency it actually adds or what a normal regression looks like for this setup. This project adds the benchmarking layer kgateway is missing. I'll build a reproducible test environment using the upstream GIE methodology, run scenarios comparing agentgateway with inference extension against a plain Kubernetes Service, set up a two-tier CI pipeline (mock server for regular runs, real Azure GPU for releases), store results in Azure Blob, and add regression detection that blocks CI when p99 latency crosses a stored threshold. The regression detection piece was what was missing from the issue discussion.

gorustkubernetes+3
Student: Abhay1906
Code

Optimizing and Evaluating CXL in the Memory Hierarchy through OCEAN

advanced
UC OSPO•2026Varies350h (Large)

CXL is an interconnect which uses memory disaggregation to overcome the memory bandwidth bottleneck from most workloads. OCEAN, one such CXL emulator built on-top of QEMU, has support for modern CXL3.0 features and supports multi-host communication is one emulator which has the potential to enable CXL-based studies. The infrastructure and studies performed by OCEAN are relatively new and limited. This project seeks to mature OCEAN's infrastructure by improving documentation, improving the accessibility and ease of setting up OCEAN, and improving the capturing of HW counter metrics which will later be used to asses how CXL can be integrated and used within the memory hierarchy to enable performance gains on HPC-class workloads.

pythonc/c++visualization+5
Student: wmadsmit
Code
Proposal

On-line, Stream/Update Functionality for Regression

intermediate
German Center for Open Source AI•2026Varies175h (Medium)

skpro's probabilistic regressors have limited online/streaming support: only 3 of 20+ regressors implement update(), few meta-strategies exist, and there is no model persistence. This project adds: 1) native _update() for regressors with incremental APIs (NGBoostRegressor, BayesianLinearRegressor, BaggingRegressor) 2) composable meta-strategies (OnlineSlidingWindow, OnlineBatchMixture, OnlineExponentialForgetting) usable with any regressor 3) update() propagation through Pipeline and TransformedTargetRegressor 4) save()/load() ported from sktime's serialization pattern

pythonpytorchscikit-learn
Student: Chaitany Patel
Code
Proposal

Automated Release Pipeline for Music Blocks

intermediate
Sugar Labs•2026Varies175h (Medium)

Music Blocks currently relies on a manual and irregular release process, which leads to deployment delays, higher risk of human error, and limited visibility into application health. This project aims to modernize the release workflow by introducing a fully automated, reliable, and auditable CI/CD pipeline. The solution will involve designing and implementing automated deployment workflows integrated with existing CI, enabling seamless releases from the main branch. Key improvements include semantic versioning and automated changelog generation, Docker-based builds published to GitHub Container Registry, and a multi-environment setup with staging and production. The pipeline will incorporate preview deployments, approval gates, and pre/post-deployment validation to ensure safe and consistent releases. Additionally, rollback mechanisms, monitoring, and deployment notifications will be added to improve reliability and observability. The final deliverables will include a complete CI/CD pipeline, containerized deployment setup, automated versioning and changelog system, staging and production environments with deployment workflows, rollback and validation mechanisms, monitoring and alerting integration, and comprehensive documentation with runbooks and troubleshooting guides.

pythonjavascriptgtk++10
Student: Sonal Gaud
Code
Proposal

Building the Core DeFi Protocols, educational chain and enhancing the ecosystem

beginner
AOSSIE•2026Varies90h (Small)

Over the summer, I'll be shipping Windmill (a cheap, auction-based DEX), Karma (an oracle run entirely by its users), OrbOracle (custom on-chain price feeds), and MiniChain (a hands-on Python curriculum). My goal is to make decentralized trading significantly cheaper and safer, while using the new MiniChain platform to actually teach beginners how blockchains work.

pythonjavascriptswift+8
Student: Siddhantcookie
Code
Proposal

Translating R Filters to AWK Streams

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

R's standard file reading functions must ingest data into memory before any filtering can occur, creating a hard memory ceiling for large datasets. AWK evaluates records one line at a time, filtering data before it ever enters R's memory space. The awkreader package bridges these two worlds, letting R users express filter conditions in familiar R syntax while AWK handles the heavy lifting at the shell level. The existing codebase is ~80% complete for Mac/Unix. This project completes and delivers the full production-ready CRAN package by: (1) completing and verifying the full translation engine: mapping R filter expressions including comparisons, logical operators, %in%, grepl(), and is.na() to correct AWK syntax across all platforms. (2) auditing and restoring Mac/Unix correctness. (3) achieving full Windows/PC compatibility via robust shell quoting and Rtools detection. (4) formalizing the package with roxygen2 docs, a cross-platform CI test harness with regression locking, and CRAN submission, enabling R users to filter datasets on standard hardware without memory constraints.

cc++r+4
Student: Akshat Maurya
Code
Proposal

Quantum Resource Analysis and Benchmarking

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

Frameworks like PennyLane and Qiskit handle circuit construction and simulation well but provide almost no tools for measuring the quantum resources a circuit uses. No unified library exists to assess profiling entanglement, magic, or Bell nonlocality. I propose a PennyLane-based library computing four resource classes through a single resource_profile() API: entanglement (Meyer–Wallach, Von Neumann entropy, concurrence), magic (Stabilizer Rényi Entropy), mana (discrete Wigner negativity for qudits), and Bell nonlocality (CHSH values). Since PennyLane QNodes are differentiable, the measures inherit gradient access for tracking resource shifts during training. I also propose benchmarking across QAOA for MaxCut, Quantum Phase Estimation, VQE for molecular ground states (H₂, LiH), and quantum autoencoders for BSM event detection following Duffy et al. (arXiv:2407.07961). The study would record resource trajectories per epoch and test whether the resource decrease Duffy et al. observed generalizes, via Spearman correlations and Mann–Kendall trend tests. This project grows out of my prior work. My Quantum Encoding Atlas library (DOI: 10.5281/zenodo.18780936) benchmarks 16 encodings across PennyLane, Qiskit, and Cirq, and my 12 QMLHEP15 evaluation tasks span quantum circuits, GNNs, equivariant QNNs, RL for PQC optimization, and contrastive learning. Running those benchmarks I identified SRE as a missing diagnostic, which inspired me towards this project. Deliverables: 1. Python package on PyPI with entanglement, magic, mana, and nonlocality modules. 2. Circuit profiler for epoch-level resource tracking. 3. Benchmarking dataset for all four algorithms. 4. Resource–performance correlation analysis. 5. API docs and Jupyter notebook tutorials. 6. Two blog posts per ML4SCI requirements. Stretch: tensor network SRE approximations beyond 10 qubits and integration with Knipfer et al.'s agent-based VQC design (arXiv:2602.19387).

pythonmachine learningc+++2
Student: ashutoshm1771
Code

Cognitive Compute Mesh: A Unified Inference Federation & Production RAG Pipeline for MoFA

advanced
MoFA Org•2026Varies350h (Large)

The current MoFA architecture tightly couples agents to a single inference backend (e.g., OpenAI, Ollama), making switching providers, handling failures, or optimizing cost and latency difficult without modifying agent code. This project introduces the Cognitive Compute Mesh (CCM): a distributed inference layer implemented as a new mofa-gateway crate that transparently sits behind the LLMCapability interface. Instead of acting as a central gateway, CCM enables a mesh architecture, where every node (local, cloud, or edge) participates in both computation and routing. The system is built around three core components: - A typed Inference Request Protocol (IRP) that standardizes communication across all providers - An intelligent routing layer that dynamically selects backends based on latency, cost, capability, and health - A production-grade RAG pipeline with hybrid retrieval (dense + BM25), reranking, and caching CCM ensures that agents become backend-agnostic, enabling seamless failover, cost optimization, and hybrid local-cloud execution without code changes. Deliverables: - mofa-gateway crate implementing LLMPlugin - Backend SDK for integrating new inference providers - Support for OpenAI, Anthropic, Ollama, and OminiX-MLX - Distributed routing with circuit breakers and health tracking - Full RAG pipeline with vector storage support - Documentation, benchmarks, and demo showing backend-agnostic agents This project aims to establish a protocol-level abstraction for AI inference, similar to how HTTP abstracted networking enabling “write once, run anywhere” for AI agents.

pythonrust
Student: Aayank13
Code
Proposal

Refactor Command Processing / CQRS Sub-system

intermediate
The Mifos Initiative•2026Varies175h (Medium)

Apache Fineract’s current command processing system relies on a centralized service and untyped JSON payloads, which limits type safety and causes errors to surface only at runtime. In a financial system, such issues can disrupt critical operations and reduce reliability. This project proposes to migrate selected modules to the new CQRS-based fineract-command architecture, which introduces typed commands, structured handler dispatch, and extensible processing hooks. The migration will cover the full request lifecycle—from REST APIs to business logic—while strictly preserving backward compatibility through unchanged integration tests. Key deliverables include migrating open and unassigned modules to the new architecture, introducing type-safe DTOs with validation, replacing legacy JAX-RS endpoints with Spring Web MVC controllers, integrating the CommandPipeline with typed handlers, removing obsolete legacy components, and producing a comprehensive migration guide to enable future contributions.

mysqljavascriptandroid+5
Student: Aditi Nikam
Code
Proposal

Minimal MCP Server Generator for Rocket.Chat

intermediate
rocket.chat•2026Varies175h (Medium)

This project builds a Gemini CLI extension that solves MCP's context bloat problem for Rocket.Chat developers. Current MCP servers expose an entire platform's API surface, meaning every agent session wastes tokens on hundreds of tool definitions the project will never use. The Minimal MCP Server Generator lets developers describe their use case in plain English and produces a production-ready MCP server covering only the endpoints they actually need. The generator goes beyond raw API wrappers by composing multi-step workflow tools: declarative step graphs that chain API calls, AI reasoning, conditional branching, and data transforms into single high-level operations. It supports two compilation targets: a standalone webhook + REST server that runs anywhere, and an Apps-Engine bridged mode for realtime event interception. The key deliverables include: a Gemini CLI extension with endpoint discovery, schema lookup, and project generation tools; a six-pass workflow validation pipeline that catches and self-corrects LLM mistakes before codegen; additive tool generation that adds new tools to existing servers without overwriting; protocol-level test generation via MCP Inspector; runtime hardening with endpoint allow-lists; and a PlatformProvider abstraction with a Mattermost dry-run proving the generator's portability beyond Rocket.Chat. This approach reduces token costs, fits within free-tier limits, and makes MCP-based Rocket.Chat development accessible to any workspace regardless of plan.

javascriptwebrtcmeteor.js+18
Student: Sezal Lagwal
Code
Proposal

Parallel tetrahedral remeshing using TBB

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

Iteratively reshaping the cells of a 3D mesh to improve quality for simulations like finite element analysis — is computationally expensive: large meshes can take hours on a single CPU core. CGAL provides a widely used implementation, and GSoC 2025 built the infrastructure to run it in parallel, achieving a ~28% speedup on large meshes. Two problems remained: threads spent most of their time waiting to access the mesh rather than doing useful work, and the parallel version produced lower mesh quality than the sequential one. The 2025 code also never made it into the official CGAL repository. This project fixes both problems and introduces a new scheduling strategy: instead of rigidly applying all splits, then all collapses, then all flips, then all smooths, a unified priority queue ranks every candidate operation by its estimated quality improvement and always applies the most beneficial one first. This has the potential to reach the same final quality in fewer operations and has not previously been applied to tetrahedral remeshing.

githubc++git+4
Student: Iason Manolas
Code
Proposal

Sequence similarity networks for the visualisation and exploration of MGnify Proteins

beginner
Genome Assembly and Annotation•2026Varies90h (Small)

My proposal is to develop a scalable computational pipeline to construct, annotate, and visualise Sequence Similarity Networks (SSNs) for a representative subset of approximately 10 million MGnify proteins. The pipeline will take FASTA files as input and utilise MMseqs2 to efficiently compute all-against-all pairwise sequence similarities. It will then use the Python library NetworkX to construct the mathematical graphs, integrating biological metadata, such as the biome-of-origin, directly into the node attributes to enable contextual environmental exploration. To ensure scalability and avoid memory bottlenecks, the pipeline will leverage NetworkX's backend dispatching architecture to route computationally heavy operations to high-performance GPU libraries like cuGraph. Finally, the graph data will be exported into simple tabular formats compatible with large-scale visualisation platforms like Cytoscape and Cosmograph. The deliverables of this project will include the core Python/Bash SSN generation pipeline, a MGnify metadata annotator, a graph exporter utility, a fully rendered 10-million node reference dataset, and comprehensive documentation alongside an integration test suite.

pythonmysqljavascript+4
Student: Szabolcs Vidám
Code

Add generate_series() support to contrib.postgres

intermediate
Django Software Foundation•2026Varies175h (Medium)

PostgreSQL’s `generate_series()` is powerful for reports and time‑series work, but Django currently lacks a first‑class `ORM API` for it. I will add native support in `django.contrib.postgres` by extending the `ORM` to treat set‑returning functions as table sources using `set_returning`, a new `Relation` abstraction, and `RelationCol` references, implemented via `CROSS JOIN LATERAL`. The result will let developers use `.annotate()`, `.filter()`, `.order_by()`, `.count()`, and `.aggregate()` with generated series without raw SQL. Deliverables include the API surface, type inference for `date/time` series, and a robust test suite covering edge cases, joins, and large sequences.

pythondjango
Student: p-r-a-v-i-n
Code
Proposal

Testing & Reliability Engineering for Kiwix Android

advanced
Kiwix•2026Varies350h (Large)

Improving the testing system of the Kiwix Android app to make tests more stable, faster, and reliable. This includes fixing flaky tests, improving CI/CD performance, and ensuring testing reflects real-world usage conditions.

pythonandroidjava+11
Student: atharvyadav22
Code
Proposal
Showing 169 - 192 of 11996 Projects
678910
Proposal
Proposal
Proposal