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

Git Support for JabRef

intermediate
JabRef e.V.•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 →
175h (Medium)

This project aims to improve Git-based collaboration in JabRef by building a reliable synchronization layer for BibTeX files. It treats Git changes as edits from remote collaborators and introduces support for conflict detection, a guided merge UI, and safe synchronization workflows. Key deliverables include a modular GitSyncService, a conflict resolution interface, integration with JabRef’s save flow, and secure credentials management. The result will be a smoother, more collaborative experience for researchers using version control in their bibliography workflows.

javajavafxlatex+3
Student: Wanling
Code
Proposal

Create distribution packages of Unicode Inflection

beginner
Unicode, Inc.•2025Varies90h (Small)

The Unicode Inflection project currently provides its code in source form, which can be a challenge for users and developers who want a simple, ready-to-use solution. The goal of this project is to create automated, cross-platform packaging for the library, making it easier for users to install and use across Linux, macOS, and Windows. I will achieve this by utilizing CMake to streamline the build process, creating CMake-based scripts that can automatically generate compressed source and binary distribution packages for each platform. The final deliverables will include a set of tools to package the library and data files, along with clear documentation on how to build and distribute the packages. This work will improve accessibility for new users, save time for developers, and enhance the overall usability of the Unicode Inflection project.

javac++rust+1
Student: Hussain A.
Code
Proposal

Graph Representation Learning for Fast Detector Simulation

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

High-fidelity detector simulations are critical for accurate analysis in particle physics, but traditional Monte Carlo-based methods are computationally expensive. DeepFalcon introduced a promising approach using Graph Variational Autoencoders (GVAE) that treat particle hits as graph nodes, enabling faster inference while maintaining high accuracy. This implementation used CMS Open Data of boosted top quark jets and considered only the ECAL layer of the detector, achieving a 400× speedup in reconstructing jets compared to traditional simulations. The model architecture employed GraphSAGE layers and mincut pooling, while training used Adam optimizer with a hybrid loss function combining MSE and KL divergence. However, the current approach is limited to single-layer detector responses and doesn't fully capture the correlations between multiple detector components. This project aims to extend DeepFalcon’s GVAE architecture to support multi-layer detector systems, specifically incorporating Tracker, ECAL, and HCAL layers simultaneously. The proposal is structured into two phases: Phase I will focus on enhancing the graph data representation by including all three detector layers and designing optimized connectivity patterns that capture spatial and inter-layer dependencies. Phase II will explore advanced pooling techniques and alternative message-passing strategies to improve latent representation quality and model generalization, while maintaining fast inference speeds. All components will be implemented using Python and relevant machine learning libraries such as PyTorch Geometric. Expected deliverables include a multi-layer GVAE model, benchmark comparisons against existing results, and detailed analysis of the architectural choices. This project contributes toward advancing fast simulation techniques in high-energy physics by enabling more comprehensive and scalable detector modeling.

pythonmachine learningc+++2
Student: Rushil Singha
Code

Agentic AI for Kubernetes Operations on NRP

advanced
UC OSPO•2025Varies350h (Large)

The original proposal for this project focused on building a machine learning service to improve monitoring within the Seam and National Research Platform (NRP) environments. The goal was to analyze Prometheus metrics, detect anomalies proactively, and use NRP’s GPU and managed LLM resources to provide human-readable explanations and root cause analysis through Seam’s portal. This approach aimed to give the Seam/NRP community an intelligent tool for faster troubleshooting and more resilient operations. As the work progressed, and with the rapid growth of agentic AI approaches, the project shifted toward building an Intelligent Kubernetes Management and Observability System, inspired by the INFOGENT design. Rather than focusing solely on anomaly detection, the system was developed as a modular Python framework that integrates Kubernetes operations with large language model–driven explanations. It classifies user input as either an operational command or a documentation query, executes the corresponding action, and returns either the system output or a clear explanation drawn from NRP knowledge. The outcome is a practical, open-source framework that provides both command execution and AI-assisted guidance. It lowers the barrier for researchers working with Kubernetes, helps them understand and troubleshoot workloads more easily, and extends the Seam initiative by showing how agentic AI systems can enhance usability in high-performance computing environments.

pythonc/c++visualization+5
Student: Manish Kamalakar Reddy
Code
Proposal

Support portfolio of solvers in SPF

intermediate
The JPF team•2025Varies175h (Medium)

Java PathFinder (JPF) is an extensible software analysis framework for java bytecode which can be used to check for concurrency defects like deadlocks, and unhandled exceptions like NullPointerExceptions and AssertionErrors. Symbolic PathFinder (SPF) is its extension that enables symbolic execution of java programs. This proposal outlines my plan to contribute to The JPF Team by working on the Support portfolio of solvers in SPF Project during Google Summer of Code 2025. The main goal of this project is to enable the simultaneous invocation of multiple constraint solvers, where execution halts as soon as any solver returns a satisfactory result. This approach is expected to enhance SPF's ability to handle a broader range of constraints. This Project will extend SPF branch sv-comp. The outcome will enhance SPF’s scalability and applicability in symbolic execution tasks.

androidjavadistributed systems+2
Student: Rehan Chalana
Code
Proposal

Resonate Version 3

advanced
AOSSIE•2025Varies350h (Large)

This project aims to enhance both user and contributor experiences for the Resonate App by implementing critical quality-of-life features, improving accessibility, and preparing it for public release. To achieve this, the following deliverables are planned: 1. Make the app fully responsive by replacing fixed dimensions with LayoutBuilder and Flex widgets for a consistent UI across devices. 2. Stabilize the codebase and prioritize deployment of Resonate v1.0.0 to the Play Store and App Store. 3. Implement automated testing in Flutter targeting 90%+ code coverage to prevent regressions and ease PR reviews. 4. Set up CI/CD pipelines to automate deployment on updates to the main branch. 5. Complete the partially implemented Text Chat feature and add in-app notifications. 6. Add Internationalization (i18n) to support multiple languages. 7. Improve the Pair Chat experience by allowing users to select who to chat with from a list. 8. Expand the Search functionality to include Creators and Users, and introduce a "Follow Creator" feature. 9. Add a Friends System to enable one-on-one calls. 10. Introduce TTS and STT features in audio rooms for accessibility to non-verbal users. 11. Add Host Controls using the LiveKit API to allow moderation in rooms. 12. Enable creators to start Live Chapters, which will be recorded and uploaded automatically. 13. Replace current Appwrite search queries with Meilisearch to support scalable and advanced search capabilities. 14. Conclude the project with final testing, merging of features, and deployment of Resonate v2.0.0. This project will ensure Resonate becomes production-ready while staying contributor-friendly and inclusive for all users.

pythonjavascriptswift+8
Student: M4dhav
Code
Proposal

Integration of Open WebUI with OpenVINO Model Server

intermediate
OpenVINO Toolkit•2025Varies175h (Medium)

Open WebUI is a very popular component that provides a user interface to generative models. It supports use cases related to text generation, RAG, image generation, and many more. It also supports integration with remote execution servings compatible with standard APIs like OpenAI for chat completions and image generation. The goal of this project is to integrate Open WebUI with OpenVINO Model Server. It would include instructions for deploying the serving with a set of models and configuring Open WebUI to delegate generation to the serving endpoints.

pythonc++x86+1
Student: Huanli
Code
Proposal

Kennedy Approach porting to Liquid Galaxy

intermediate
Liquid Galaxy project•2025Varies175h (Medium)

This project modernizes the classic Kennedy Approach air traffic control game by rebuilding it as a custom, multi-screen interactive experience on the Liquid Galaxy platform. Rather than emulating the original Commodore 64 version, the game is being ported from scratch, allowing for enhanced features and seamless integration across multiple synchronized displays. The system is designed around a master-slave architecture, where the master node handles game logic and display rendering. The visual output is split and distributed to multiple slave nodes on the network, creating a panoramic and immersive gameplay view across multiple screens using the Liquid Galaxy setup. Players interact with the game using a mobile controller app built in Flutter, which communicates with the master system over a local network. A Node.js backend on the master node manages incoming control commands via WebSockets/Socket.IO, ensuring smooth, real-time interactivity. Optional UI dashboards built in React or Next.js can be used for monitoring system status, visualizing live data, or enabling multiplayer interaction.

javascriptrosgis+14
Student: DEV T GADANI
Code
Proposal

Enhancing Creative Workflows with a Natural Language Interface

intermediate
Python Software Foundation•2025Varies175h (Medium)

This project aims to make Tölvera more accessible to artists and researchers by adding a Natural Language Interface (NLI). Currently, Tölvera's reliance on Python coding presents a barrier for those without programming expertise. This project will refine and substantially extend tv.llm, a functional proof-of-concept NLI module, enabling users to generate and modify Tölvera sketches using natural language commands. The core work of this project involves expanding the NLI's architecture, which utilizes Pydantic for configuration validation and Jinja2 for reliable code generation, to encompass a broader range of Tölvera modules (tv.vera, tv.osc, tv.cv, tv.mp, tv.iml), refining prompt engineering strategies, and improving the command-line interface. Deliverables will include the full release of the tv.llm module integrated as a core Tölvera feature, detailed documentation, and an evaluation report. The goal is to help empower a broader community of users to integrate Tölvera into their creative workflows.

pythonmercurialjavascript+3
Student: MClem
Code

Development of Notebook-based PEcAn Workflows

advanced
PEcAn Project•2025Varies350h (Large)

This project aims to develop Quarto notebooks as an accessible yet flexible interface for running PEcAn workflows, bridging the gap between the limited web-based UI and the more advanced API or R script methods. It will create workflow templates that cater to both new and experienced users. To support adoption, the project will also produce a written vignette demonstrating their use.

cpostgresqljavascript+8
Student: Aritra Dey
Code
Proposal

Add support for 3D thermal simulations in PyBaMM

advanced
NumFOCUS•2025Varies350h (Large)

Seeing the current increasing demand of high performance batteries, accurate thermal modelling of battery behaviour is essential. This project extends PyBaMM by adding the capability to simulate battery temperature in three dimensions. It starts by developing 3D meshes (box, cylinder etc) and FEM method. Then we develop a 3D thermal model for batteries, initially assuming a constant heat source. This thermal model is then coupled with existing battery models (like the SPM or DFN) so that the heat generated during battery operation can be simulated. The model will also eventually allow temperature data from the thermal simulation to feed back into the battery model, enabling more realistic, two-way interactions.

pythonjavascriptr+3
Student: Rishab Kumar Jha
Code
Proposal

State-Space Models: Dynamic Factor Models

advanced
NumFOCUS•2025Varies350h (Large)

State-space models (SSMs) provide a flexible framework for modeling dynamic systems where latent states evolve over time. In econometrics, Dynamic Factor Models (DFMs) are widely used to capture the co-movement of multiple time series by assuming that a small number of latent factors drive the observed variables. The PyMC library already includes implemen- tations of SARIMAX, VARMAX, and structural state-space models, along with example notebooks for their usage. This project aims to extend the existing PyMC state-space module by implementing Dynamic Factor Models, aligning with the functionality available in statsmodels. Our implementation will follow a Bayesian approach, leveraging PyMC’s probabilistic programming framework and PyTensor for computation. Additionally, an accompanying example notebook will demonstrate estimation, forecasting, and causal analysis with the new model, ensuring accessibility for users. This enhancement will significantly expand PyMC's capabilities, empowering student, practitioners and researchers in econometrics, macroeconomics, and beyond to model complex time-series data probabilistically.

pythonjavascriptr+3
Student: Andrea Catelli
Code
Proposal

Improving the SweetCam IP camera honeypot

advanced
The Honeynet Project•2025Varies350h (Large)

Problem: IP cameras are frequent targets for cyberattacks due to their widespread use and often weak security. Current honeypots like SweetCam lack comprehensive protocol support and realistic emulation, limiting their effectiveness in detecting and analyzing threats. Solution: This project aims to transform SweetCam into a versatile, multi-protocol honeypot by: 1. Expanding protocol support for RTSP and ONVIF, enabling deeper interaction with attackers. 2. Introducing template-based device emulation using YAML to simulate real-world cameras (e.g., Dahua, Hikvision). 3. Improving usability with Docker enhancements, automated configuration, and a realistic HTTP interface featuring error simulation and multi-language support. Deliverables: 1. A production-ready SweetCam with RTSP/ONVIF support and 5+ device templates. 2. Optimized Docker deployment (multi-stage builds, Compose profiles). 3. Enhanced HTTP interface (login flows, error simulation, i18n). 4. Comprehensive documentation, including setup guides and protocol specifications. Impact: This upgrade will equip researchers and defenders with a powerful tool to study attacker behavior, improve IoT security, and contribute to the broader honeypot ecosystem.

pythonandroidmachine learning+16
Student: c1nk
Code
Proposal

Batch Processing Gateway Integration

advanced
Kubeflow•2025Varies350h (Large)

Jupyter Notebooks provide a powerful, interactive environment widely used by data scientists and ML engineers for exploratory analysis, visualization, and prototyping. However, as the scale and complexity of data workloads grow, running computations locally within notebook pods becomes inefficient and limiting. The Batch Processing Gateway integrates with Kubeflow Spark Operator to manage the full lifecycle of Spark applications in a cloud-native environment. It enables distributed computation at scale and automates job deployment, resource management, and status tracking using Kubernetes Custom Resource Definitions (CRDs). This project proposes integrating Jupyter Notebooks and the Batch Processing Gateway, enabling it to manage the notebook kernel lifecycle of remote Spark kernels as distributed Spark applications. This decouples computation from the notebook pod and scales Spark workloads efficiently in Spark. To achieve this, we will introduce Batch Processing Gateway to manage the lifecycle of Notebook kernels and introduce Jupyter Enterprise Gateway (JEG) for runtime communication to enable Jupyter messaging protocol for notebook cell execution during runtime.

pythontensorflowkubernetes+5
Student: Fellipe Resende
Code
Proposal

A Diffusion-Based Deep Learning Framework for Denoising Protoplanetary Disk Observations

intermediate
Machine Learning for Science (ML4SCI)•2025Varies175h (Medium)

This project proposes ProtoDiff, a diffusion-based deep learning model designed to denoise astronomical observations of protoplanetary disks from telescopes like ALMA and VLT. Leveraging recent advances in score-based generative modeling, the model will be trained on synthetic disk simulations with realistic noise. ProtoDiff aims to outperform traditional denoising pipelines in both quality and efficiency, enabling cleaner reconstructions of planet-forming environments. The final deliverables will include open-source code, pretrained models, and documentation to support reproducible astrophysical data processing and accelerate research in planet formation studies.

pythonmachine learningc+++2
Student: Chukwunwogor Faithful
Code
Proposal

Building a centralized hub for open-source Greek NLP datasets with GlossAPI

intermediate
Open Technologies Alliance - GFOSS•2025Varies175h (Medium)

This project addresses the lack of accessible, Greek high-quality datasets for training Large Language Models (LLMs). Although robust LLM frameworks are widely available, open-source Greek-specific datasets are severely underrepresented, especially those that captures regional variations and dialects. This project's mission is to integrate Optical Character Recognition (OCR) capabilities into the processing pipeline and expand its dataset resources to support these linguistic nuances.

pythonmysqljava+7
Student: Dimitrios Athanasopoulos
Code
Proposal

Project 11: Support Postgres for Kubeflow Pipelines Backend

intermediate
Kubeflow•2025Varies175h (Medium)

Kubeflow Pipelines (KFP) currently only supports MySQL/MariaDB databases, creating a significant limitation for many organizations that standardize on PostgreSQL. This project aims to implement comprehensive PostgreSQL support across the KFP stack, including the API server, cache server, and ML Metadata components. The solution involves developing database abstraction layers, SQL dialect adapters, and migration tools that enable users to seamlessly deploy KFP with PostgreSQL backends. By providing this integration, the project will greatly expand deployment options for enterprise environments where MySQL is prohibited by policy, benefit organizations leveraging PostgreSQL's superior data warehousing capabilities, and eliminate the need for unsupported workarounds that currently require substantial effort from users. The end result will be a more flexible, enterprise-ready Kubeflow Pipelines platform that meets diverse organizational requirements.

pythontensorflowkubernetes+5
Student: Yunkai Li
Code

Show message if devfile is invalid before creating a workspace

intermediate
GitLab•2025Varies175h (Medium)

Currently, devfile validation only occurs after the user submits the form to create a workspace. This means users only discover invalid devfiles after waiting for form submission. Implement just-in-time (JIT) validation for devfiles in the workspace creation form: When a user selects a devfile from the dropdown, validate it immediately in the background, Display a visual indicator (icon/label) next to the selected devfile showing its validity status, Provide clear, actionable error messages for invalid devfiles before form submission

rubygolanggit+6
Student: Omar Nasser
Code
Proposal

[Deployment Management] Add Notification for expiring Deploy Tokens: E-mail and Webhook

intermediate
GitLab•2025Varies175h (Medium)

This project is a notification system that alerts its users before their deploy tokens expire. Deploy tokens are used to provide secure access to repositories and container registries, independent of a user account. Due to this reason, they are used in CI/CD pipelines, automation scripts, and third-party integrations. Some of these tokens are configured to have an expiry date at the time of creation. Currently, GitLab lacks an automated way to notify users about tokens that are about to expire. This can lead to last-minute troubleshooting and potential downtimes. To address this, we can integrate a notification system that notifies the project owners, group owners and admins at different intervals [14, 7, 1] days through email notifications and webhooks. This will ensure timely renewals of the token and avoid unexpected failures.

rubygolanggit+6
Student: Pratibha Gupta
Code

Robotics Academy: CI & Testing

intermediate
JdeRobot•2025Varies175h (Medium)

The primary goal of this project is to establish an automated testing framework for the Robotics Academy (RA), Robotics Infrastructure (RI), and Robotics Application Manager (RAM) repositories. This framework will include a suite of unit and integration tests to verify functional correctness and ensure that the software remains maintainable and robust. Additionally, the project will focus on creating continuous integration (CI) pipelines, ensuring early detection of issues, and fostering a culture of quality and accountability across the projects.

pythonrosgazebo+2
Student: Abdallah Ibrahim Ismail
Code
Proposal

Latent Neural Signatures in Clinical vs. Neurotypical Dyads: A CEBRA Pipeline

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

This project aims to develop a cutting-edge computational pipeline—"Latent Neural Signatures in Clinical vs. Neurotypical Dyads: A CEBRA Pipeline"—to decode and interpret complex neural dynamics during social interactions. By leveraging the CEBRA (Contrastive Embedding for Behavioral and Neural Analysis) framework, the pipeline will process and analyze time-locked 64-channel EEG data from interacting dyads (e.g., speaker-listener pairs). The goal is to generate robust, low-dimensional latent embeddings that capture key features such as neural synchrony, connectivity, and manifold geometry, ultimately distinguishing between clinical populations (e.g., individuals with Autism Spectrum Disorder) and neurotypical participants. To achieve this, the project will integrate rigorous EEG preprocessing (artifact removal, filtering, epoching, and synchronization) with state-of-the-art contrastive learning methods. The pipeline will be built in a modular fashion, allowing for reproducible, open-source research and facilitating cross-disciplinary collaboration between machine learning experts and neuroscientists. Key deliverables include a fully functional end-to-end pipeline, comprehensive technical documentation and user guides, and detailed analysis reports with visualizations and quantitative metrics. This approach promises not only to enhance our understanding of the neural substrates underlying social communication but also to provide a practical tool for clinical diagnostics and personalized intervention strategies.

pythonmachine learningc+++2
Student: jeffreyhuang1009
Code

Crisis Response Toolkit for Gemma Models

intermediate
Google DeepMind•2025Varies175h (Medium)

This project explores how lightweight Gemma models can be applied in life-critical situations through an open-source Crisis Response Toolkit. The main deliverable, One Minute Agent, is an offline AI assistant designed to provide first-aid guidance during emergencies, bridging the gap before responders arrive and helping improve survival rates. The work also investigates offline deployment, function-calling abilities, and agent workflows to demonstrate how Gemma can support real-time decision-making in crisis scenarios.

pythonjavascripttypescript+2
Student: Rodrigo Sagastegui
Code
Proposal

FreeBSD Power Profiling Tool

advanced
The FreeBSD Project•2025Varies350h (Large)

FreeBSD previously lacked process-level power profiling, relying only on ACPI whole-system statistics. To address this, I built a FreeBSD-native power profiling tool inspired by Linux’s PowerTOP, keeping the design lightweight and integrated with FreeBSD’s user-space libraries. The core of the project was implementing librapl, a library to read Intel/AMD RAPL counters via /dev/cpuctl, and combining it with process data from libkvm. This allowed attributing energy usage from domains such as Package, Cores, and DRAM to individual processes. Special handling for multi-threaded processes ensured accurate per-thread runtime tracking, validated through workloads like OpenSSL (CPU stress) and Firefox (multi-threaded). The prototype currently outputs real-time per-process power usage, providing actionable insights into system energy behavior. Next steps include daemonizing the tool for continuous monitoring, extending support to ARM64 (via AMUs or SCMI) and Intel TPMI, and adding user-friendly visualization. This work establishes the first foundation for granular power profiling on FreeBSD and opens the path for advanced power management features.

c/c++llvmassembly+5
Student: Sai Kasyap Jannabhatla
Code
Proposal

Counting Linear Extensions with Volume Computation and Applications in AI

advanced
GeomScale•2025Varies350h (Large)

This project develops an approximation algorithm for counting the linear extensions of a partial order by estimating the volume of its associated order polytope. Since exact counting is #P-complete, we exploit the fact that the polytope's volume is proportional to the number of linear extensions. Building on the volesti C++ library, the project will implement an optimized exact Hamiltonian Monte Carlo (HMC) sampler with a Gaussian target and a general mass matrix, including efficient boundary oracles for handling polytope constraints. The new HMC-based approach is designed to improve sampling efficiency and scalability, especially in high-dimensional settings, and will be integrated into existing volume estimation algorithms. Deliverables include the new C++ module, enhanced integration with volesti, extensive empirical evaluations against current approximation methods, comprehensive documentation, and reproducible benchmarks.

pythonc++r+2
Student: Sophia Qian
Code
Proposal
Showing 1225 - 1248 of 11996 Projects
5051525354
Proposal
Proposal
Proposal
Proposal
Proposal