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

Building an API Client for OBA Servers

intermediate
Open Transit Software Foundation•2024Varies

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)

Summary: The OBA project aims to develop official OneBusAway REST API client libraries in TypeScript and Python, enhancing accessibility and user experience for developers interacting with OneBusAway servers. These libraries will support all REST API methods, handle diverse data types, include comprehensive tests, and provide helpful examples for new users. About Me: I am Ahmed Hossam, a senior information technology student with a passion for technology and problem-solving. With experience in backend engineering and competitive programming, I am excited to contribute to the OBA project and make a positive impact. Investigations: I have familiarized myself with OneBusAway endpoints, built a beta version of the TypeScript package, and experimented with different structures for scalability and maintainability. Detailed Design: The API client follows a modular structure, with each endpoint encapsulated within its own module. It employs a combination of factory and dependency injection patterns and includes a base class for foundational HTTP request functionality. Implementation Plan: I will collaborate closely with mentors to understand API client requirements and plan implementation details. Error handling and unit testing will be prioritized, followed by thorough testing and the publishing of final packages. Proposal Timeline: The timeline spans 14 weeks, beginning with communication and research in the first three weeks, followed by official coding in TypeScript. Python implementation will commence in week 9, with completion and finalization in week 14. Why Me: I find joy in making OBA APIs accessible to everyone and am dedicated to contributing positively to the project. My experience in API development, along with continuous learning, makes me well-suited for this role.

androidjavagolang+2
Student: Ahmed Hossam
Code
Proposal

Robotics Academy: improvement of autonomous driving exercises

intermediate
JdeRobot•2022Varies175h (Medium)

Goal:- a)Creation of several realistic car models with Ackermann control some of them including a 3D LIDAR. b)Improved Realistic and Lightweight Environments for Autonomous Driving Exercises in RoboticsAcademy. c)Migration of Existing Autonomous Driving Exercises into ROS2 at RoboticsAcademy. Plan:- The detailed plan is included in the proposal, this is my plan of action before the official coding period starts. Before May 20: ● Study of the Car Sensor plugins and their implementation in ROS2. ● Explore the new Ignition Gazebo 11 simulator. ● Explore Sensors, Noise modules, command-line tools, and custom plugins in the Ignition Gazebo 11 simulator. ● To familiarize myself completely with RoboticsAcademy’s functionality and architecture. ● Study of Ackermann control and its implementation. ● Explore ROS2’s Architecture and Communication channels required for RoboticsAcademy Exercises. May 20 - June 12(Before the official coding time): ● To do self coding with Autonomous Driving Exercises to improve my further understanding. ● During this period I will remain in constant touch with my mentor and the JdeRobot community. I will remain active on Mailing lists to discuss and finalize the modifications that need to be on existing car models and the design of new models or environments. ● Thus with the help of my mentor, I will become absolutely clear about my future goals, the final exercise implementations that need to be done as well as the approach that I will follow to convert current exercises to support ROS2. Deliverables:- ●Several realistic car models with Ackermann control some of them including a 3D LIDAR. ●Improved Realistic and Lightweight Environments for Autonomous Driving Exercises in RoboticsAcademy. ●Migration of Existing Autonomous Driving Exercises into ROS2 at RoboticsAcademy.

pythonrosgazebo+2
Student: Akshay Narisetti
Code
Proposal

Integration of Automated Model Testing and Parameter Fitting Tools for Neuroscience Applications.

beginner
INCF•2023Varies90h (Small)

Biologically detailed models are essential tools in neuroscience, and automated methods are frequently used to build and validate such models based on experimental data. The open-source parameter optimization software Neuroptimus was developed to enable easy application of advanced parameter optimization methods, such as evolutionary algorithms and swarm intelligence, to various problems in neuronal modeling. Neuroptimus includes a graphical user interface, and works on various platforms, including PCs and supercomputers. While Neuroptimus uses various built-in cost functions and the eFEL feature extraction library to compare model behavior to experimental data, it severely limits the range of neuronal behaviors that can be targeted by optimization. However, the popular model-testing framework SciUnit allows for the implementation of tests that quantitatively evaluate arbitrary model behaviors. Therefore, the goal of this project is to extend Neuroptimus to use HippoUnit, an open-source neuronal test suite based on SciUnit, to evaluate model performance during optimization. This project aims to develop a seamless integration between HippoUnit and Neuroptimus, enabling the construction of detailed biophysical models of hippocampal neurons. The new Neuroptimus-HippoUnit integration will allow the optimization of a broader range of neuronal behaviors, which can ultimately lead to improved biophysical models of hippocampal neurons. Deliverables: 1- Implementation of an interface between HippoUnit and the new version of Neuroptimus to enable the optimization of a broader range of neuronal behaviors. 2- Extend the current supported tests to include all HippoUnit tests. 3- Integrate the HippoUnit with the Neuroptimus’s GUI so that users can run optimizations directly from the interface.

pythonjavac+++7
Student: Eslam Khaled Korany
Code

A Node Based Filter Editor for Inkscape

beginner
Inkscape•2024Varies90h (Small)

Inkscape's current Filter Editor limits the user experience for creating Filters significantly, due to it's non-intuitive nature, and poor structing. Filters can be a great tool in any artist's inventory, due to the endless scope of effects they are capable of creating. However, the current Editor does a poor job at inviting artists to utilise the complete power of Filters. To solve this problem, I plan on replacing the current Filter Editor with A Node-Based one, since such a Node based workflow seems like the most natural one, for working with filters. The proposed Node - based Filter Editor promises to have the following deliverables: 1. An intuitive, easy to pick up, node based filter editor, with intuitive, user-friendly controls with a full-fledged editing workflow containing: a) essential features for navigation and canvas operations such as scrolling, zooming, panning, etc., relevant contextual menus, etc. b) Intuitive node operations such as selections, an easy system to make connections between nodes with clean and well planned user interfaces. c) Support for all Filters and Filter Primitives, along with widgets aimed at being easy to understand, which allow editing the properties of the Filter Primitives d) Ability to save and load the state of the editor, when closing and re-opening, or automatically creating a suitable layout for arranging the nodes, in a clean manner. 2. Creating template classes which can be used in future to implement functionalities requiring similar workflows. 3. Documentation and video series to further help users understand the editor and learn about it's various features, along with providing insight into the power of Filters.

pythonc++css+6
Student: Ravi Arora
Code
Proposal

Ask VEPai. Trained chatbot interface for Ensembl VEP web

intermediate
Genome Assembly and Annotation•2026Varies175h (Medium)

Ensembl VEP's web interface offers dozens of configuration options for variant annotation, overwhelming new users and generating recurring helpdesk queries. Ask VEPai is a locally-hosted, open-source AI assistant that translates natural-language descriptions into recommended VEP configurations with justifications. The system uses Retrieval-Augmented Generation (RAG) grounded in a curated knowledge base, with a deterministic constraint checker that catches species violations and option conflicts the model misses. Beyond the project brief's scope of option labelling, training data, and a prototype model, this proposal adds four components: (1) the constraint checker, empirically validated across three model sizes, (2) a quantitative evaluation framework with leave-one-out methodology and multi-run statistical replication, (3) a structured JSON schema mapping recommendations directly to VEP web form sections for "click to apply" integration, and (4) an interpretability layer where every recommendation includes a source citation traceable to the knowledge base. A working demo validated across Qwen 2.5 3B/7B/14B shows +19–30% Enable F1 from the knowledge base, with all code and results published. Core deliverables: expanded KB (~55 options), 15–20 gold-standard examples, RAG pipeline, constraint checker, JSON schema, evaluation report, and documentation. My availability (~400 hours) supports extending to a 350-hour Large project, adding QLoRA fine-tuning, attribution testing, FastAPI wrapper, and VEP output explainer.

pythonmysqljavascript+4
Student: UninterpretableEvolvingBlackBox
Code

Cloud-Native O-RAN Mentorship Project

Intermediate
•Varies175h (Medium)

5G/6G wireless networks based on O-RAN architecture will have O-RAN Network Functions (NFs) deployed on the O-cloud infrastructure. The cloud infrastructure and the NF orchestration is managed by the SMO using the O-RAN O2 interface. Open-source projects such as O-RAN SC, ONAP, Nephio, OAI are actively engaged in developing open-source software for O-RAN networks, in alignment with guidance from the O-RAN Open-Source Focus Group. Building on the progress of open-source implementation of O-RAN NFs, the open-source community is now focusing on implementation of cloud-native O-RAN NF (e.g., O-CU, O-DU) as well as the SMO functionality to manage them via the O2 interface. There is an opportunity to set up an implementation in a university testbed to participate in the open-source projects, and enable research in cloud-native O-RAN (e.g., methods of monitoring the energy consumption of the cloud infrastructure and the NFs) In this project the student will leverage open-source code and - implement an example O-cloud infrastructure hosting one or more O-RAN NF(s) (e.g. O-CU, O-DU) at Rutgers University WINLAB (https://winlab.rutgers.edu/) - develop a setup and tutorial to enable multiple users to replicate the cloud-native open-source implementation and contribute to open source - study and develop open-source software to support management/data collection of the infrastructure and NFs from the SMO, using energy consumption as an example

TBA
Proposal

Automatic Identification And Classification of Contract Data Types with NLP

intermediate
Accord Project•2021Varies175h (Medium)

<p>Mapping between the natural language text of a contract and attempting to classify data types such as monetary amounts, dates and legal specific terms such as agreement parties, etc. into cicero variables from the existing model library.</p> <p>Therefore, users can export a smart legal contract by natural language contract text.</p> <h3>How to do it?</h3> <h4>A. Data Mapping using NER by RoBERTa.</h4> <p>Build a scaleable NER model by Adapter Transformers based on RoBERTa.</p> <p>The model also have Active Learning pipelines. User can define their own custom data type label then upload data and train the Adapter. By doing so, the model will recognize their new tag.</p> <h4>B. Suggest about templates by Classification Model</h4> <p>When users first upload their natural language contract, NLP model will tell them which smart legal contract template is suitable. So users can use or fine-tune the contract easily.</p> <h4>C. Identification contract variables by BERT QA Model</h4> <p>Input contract text, NLP model will suggest user which they need to put onto smart legal contract's variables.</p> <h4>D. API backend.</h4> <p>User can call the NLP model by API. Provide a Swagger UI Documents and plenty of examples.</p> <h3>For more detail, please <a href="https://github.com/accordproject/labs-cicero-classify" target="_blank">go to README in the GitHub Repo</a></h3>

javascriptreactcompiler+5
Student: EasonC13
Code

A Pipeline for NeRF Experimentation and Visualization

beginner
OpenCV•2023Varies90h (Small)

The goal for this project is to develop a NeRF model training pipeline within the OpenCV library. The end result will be a fully functioning data processing pipeline that is well integrated with the NeRF model training procedure, as well as online documentation that detail how to use the pipelines properly. There are 3 key deliverables for this project. First, implement data loaders that can process user-taken images of real-world scenes. This will involve using the COLMAP and OpenCV data processing pipelines in order to extract the camera poses and epipolar geometry of the scene; these are requirements for the model's ability to learn a meaningful representation of the given scene. Second, build, train, and test the actual NeRF model. This will involve using PyTorch's built-in CUDA support and extensive usage of the PyTorch library as a whole in order to incorporate critical components of the NeRF architecture such as positional encoding, ray sampling, and regularization into our model design. This step will also include rendering procedures that will allow users to extract images/videos, depth maps, and other logging information such as the training loss curve from the fully trained model. Third, create simple and intuitive documentation on how to use both the data loaders and the NeRF code base. This will involve creating a page on OpenCV's documentation (via Doxygen) that will list out specific terminal commands that the user should use to train the model. It will also include a summary of required packages, recommended environment configurations, and links to other helpful resources such as YouTube video demonstrations, which will all be geared towards increasing the usability and accessibility of the pipeline.

pythonmachine learningc+++9
Student: Joshua Ahn
Code
Proposal

Uyuni Event-Driven Automation via MQTT and Node-RED

beginner
openSUSE Project•2026Varies90h (Small)

Uyuni is a powerful systems management platform, but today it lacks a native way to automate actions based on events in real time. As a result, administrators often have to write custom scripts to react to things like patch updates or system changes, which adds unnecessary complexity and effort. This project aims to change that by introducing a simple, scalable event-driven architecture that turns Uyuni into an automation-friendly platform. The idea is to make it easy for administrators to connect Uyuni with other tools and build workflows without writing a lot of custom code. The solution has two main parts. First, an MQTT-based event publisher that hooks into Uyuni’s existing event pipeline and emits real-time events such as patch updates, system registrations, and Salt state results. Second, a custom Node-RED integration that allows administrators to visually design automation workflows using a drag-and-drop interface. The publisher is designed to be lightweight and non-intrusive, running as a passive listener so it does not interfere with Uyuni’s current behavior. It sends structured JSON messages, supports topic-based filtering, and includes reliability features like retries, batching, and rate limiting to handle larger deployments. On top of this, the Node-RED layer provides reusable nodes for consuming events, triggering actions, and interacting with Uyuni APIs. Overall, this project makes automation in Uyuni much more accessible, reduces the need for manual scripting, and enables easy integration with external tools like Slack or Jira. It also lays a solid foundation for building more advanced automation features in the future.

pythonlinuxjavascript+11
Student: Geetansh Goyal
Code

User Query Management Software

advanced
Zendalona•2024Varies350h (Large)

The project aims to enhance the open-source ticketing system Trudesk by integrating critical accessibility features and advanced functionalities. The primary goal is to make Trudesk more inclusive and efficient for all users, including those with disabilities. The main problems addressed are: 1. Lack of accessibility in existing ticketing systems, making them difficult to use for people with disabilities. 2. Inefficient ticket management due to manual tagging and sorting processes. 3. Absence of community support features like public forums. 4. Inflexibility to cater to organization-specific needs. To solve these problems, the project proposes the following solutions: 1. Accessibility Enhancements: Optimize Trudesk for screen readers and assistive technologies, ensuring full accessibility for users with disabilities. 2. Advanced Functionalities: Implement auto-tagging, auto-categorization, and voice input capabilities to streamline ticket management. 3. Public Forums Integration: Create public forums within Trudesk, enabling users to collaborate and share knowledge. 4. Organization-Specific Enhancements: Develop automatic documentation suggestions and customizable knowledge bases tailored to frequent queries. The key deliverables of the project include: - Accessibility patches for Trudesk to ensure compliance with accessibility standards. - Public question polling interface and public forums for community engagement. - Efficient question searching, answer polling, and thread merging features. - Knowledge base creation and FAQ generation based on user queries. - Document suggestion system and voice-based query creation (stretch goal). - Integration of private ticket tracking and public forums. - Comprehensive testing and documentation.

pythonjavascriptandroid+2
Student: Anima Regem
Code
Proposal

TESK - A GA4GH-TES based Kubernetes batch execution service

intermediate
Global Alliance for Genomics and Health•2024Varies175h (Medium)

This project endeavors to revamp the Kubernetes batch execution service to adhere to the Task Execution Service (TES) standards established by the Global Alliance for Genomics and Health (GA4GH). Objectives: Python: Rewrite the existing Java codebase in Python, utilizing the latest version of Python dependencies. Address deprecated code and enhance maintainability, considering the existing task-core is written in Python. Repository Consolidation: Merge all TESK repositories into a unified repository to streamline management and reduce redundancy. Simplify dependency management, ensuring compatibility and synchronized updates across components. Facilitate collaborative development and code sharing among developers. Standardization and Compatibility: Implement TES v1.1.0 To incorporate the latest GA4GH TES features, and comprehensive support for client-side GUI components. Ensure compatibility and interoperability with existing systems. Deliverables: Replacement of Java Springboot API with FOCA-based API implementation. Codebase rewritten in Python with updated dependencies and sanitized code. Unified repository for TESK components for simplified management. Documentation covering the entire system comprehensively. Enhanced collaboration among developers and streamlined build and deployment processes. Milestones: Environment setup and FOCA server, security, and logging configuration. Migration of endpoints as proof of concept (POC). Merge tesk-core into the unified repository. Creation of pydantic data models and data validations. Migration of Kubernetes wrapper. Migration of service and controllers. Upgrade to TES v1.1.0 and update helm charts and docker images. Merge deployment charts and add tests for continuous integration (CI) pipelines.

pythonjavamongodb+10
Student: Javed Habib
Code

Building Apache Beam Notebooks for Real-World ML Use Cases

intermediate
Apache Software Foundation•2023Varies175h (Medium)

In this project, I want to create Jupyter notebooks for a real-world machine learning use case, especially image processing using publicly accessible datasets. The goal is to create a reference guide that others can use to build ML pipelines for image processing or computer vision problems. I already have experience working with image processing to detect breast cancer cells in histopathological images and want to leverage that to build a similar pipeline using Apache Beam for image processing use cases. This can also be expanded to other computer vision problems like object detection, facial recognition, optical character recognition, and hand gesture recognition for disabled people. Following are some ideas on notebooks that I can build and contribute to : 1. Image Data Preprocessing: Apache Beam can be used to create a pipeline for different image pre-processing tasks like resizing, cropping, normalizing and filtering for different image file formats like TIFF, PNG and converting it into a more standardized format like JSON. 2. Model Inference: We can showcase how trained models can be used to make real time inferences in a Beam pipeline. 3. Model Evaluation: We can evaluate the model using Apache Beam, utilizing various metrics such as accuracy, precision, recall, and F1 score. 4. Stretch Goal: If time permits, we can do a similar process for video datasets and show how to preprocess videos using Beam. Deliverables Apache Beam notebook with working code to deploy a pipeline for image processing/video processing use case and supporting documentation.

pythonjavascriptjava+7
Student: Reeba Qureshi
Code

[DeepLense] Foundation Model for Gravitational Lensing - WaveLens-JEPA

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

Strong gravitational lensing is a powerful probe of dark matter structure and cosmology, yet no foundation model exists that is purpose-built for lensing data with theoretical training guarantees. This proposal introduces WaveLens-JEPA, a self-supervised vision foundation model for gravitational lensing that extends LeJEPA (Balestriero & LeCun, 2025) to the astrophysical domain. The core idea is to decompose lensing images using a 2D Discrete Wavelet Transform before encoding, separating the physically meaningful frequency scales — Einstein ring morphology, subhalo perturbations, and ALP vortex structure — into orthogonal channels. A physics cross-attention module injects convergence-map priors from the lensing equation at every ViT block, while Einstein-Ring-Aware Masking (ERAM) targets the physically informative annular region during pre-training. Fourier phase regularization preserves substructure-discriminative spatial information that standard encoders discard. The training objective inherits provable collapse-free guarantees via Sketched Isotropic Gaussian Regularization (SIGReg), unlike all prior lensing SSL methods. The pre-trained backbone is evaluated on six downstream tasks: two substructure classification setups, lens finding, mass density regression, super-resolution, and a novel interpretability task via Wavelet Attribution Maps (WAM). Deliverables include: (1) open-source modular codebase, (2) pre-trained backbone weights on Hugging Face Hub, (3) a six-task evaluation benchmark, (4) a sim-to-real domain adaptation protocol targeting COSMOS HST data, and (5) a full research paper.

pythonmachine learningc+++2
Student: Arnesh2212
Code

Machine Learning downscaling of PEcAn outputs

advanced
PEcAn Project•2024Varies350h (Large)

This project aims to develop and integrate machine learning models capable of downscaling the carbon flux outputs from the Predictive Ecosystem Analyzer (PEcAn) framework to higher spatial and temporal resolutions. The coarse resolution of PEcAn's current outputs limits their applicability for localized analyses of carbon dynamics. By leveraging deep learning techniques, specifically Convolutional Neural Networks (CNNs) and Spatio-Temporal Recurrent Neural Networks (STRNNs), this project will enhance the accuracy and granularity of PEcAn's model outputs, enabling more detailed analyses to support ecosystem management and climate change mitigation efforts. The project will involve developing a robust data preparation pipeline to handle diverse covariate datasets, including climate variables, land cover, soil properties, and disturbance history. Time-varying covariates and disturbance events will be integrated to capture their influence on carbon flux dynamics. Tailored CNN and STRNN architectures will be designed and implemented to effectively capture spatial and temporal dependencies in the data. Comprehensive model training, evaluation, and optimization strategies will be employed to ensure accurate downscaling performance. The developed models and workflows will be seamlessly integrated into the existing PEcAn framework, ensuring accessibility and reproducibility for researchers and practitioners. User-friendly interfaces, command-line tools, and comprehensive documentation will facilitate the adoption and usage of the downscaling capabilities. The key deliverables include a scalable data preparation pipeline, optimized CNN and STRNN architectures for downscaling, model training and evaluation pipelines, evaluation metrics , and the integration of the developed solution into the PEcAn framework with user-friendly interfaces and documentation.

cpostgresqljavascript+8
Student: Sambhav Dixit
Code
Proposal

Mifos X Smart Contract & Loan Agreement Summarization with LLMs

intermediate
The Mifos Initiative•2026$3k–$6.6k175h (Medium)

Loan agreements are supposed to protect borrowers. In practice, most people sign them without understanding what they say, not because they're careless, but because these documents are written in language that takes training to parse. For the rural borrowers and small business owners that Mifos X was built to serve, this gap is not a minor inconvenience. It is a direct risk to their financial wellbeing. This project builds an LLM-powered summarization layer that integrates directly into Mifos X. A loan officer pastes a contract or pulls a loan product from Mifos X via the Fineract REST API, and the system extracts every key financial term like loan amount, interest rate, repayment schedule, every fee. It runs a mathematical consistency check on the numbers, and returns a plain-language summary written so anyone can understand it before they sign. Every extracted value is verified against the source text before reaching the screen, so the tool never silently surfaces wrong information. For MFIs with strict data privacy requirements, the system supports fully local inference via Ollama, no borrower data ever leaves their server. Before writing this proposal I built a working POC, deployed at https://loan-analyzer.streamlit.app/ , to prove the core pipeline actually works on real contracts. That POC is the foundation. The GSoC project takes it from a proof of concept into a properly integrated Mifos tool, with three deliverables: a working application connected to Mifos X with summaries generated in under ten seconds; a documented LLM evaluation comparing four providers on accuracy, readability, speed, and cost submitted to the Mifos wiki; and a clean codebase any contributor can clone and run in under fifteen minutes.

mysqljavascriptandroid+5
Student: Silky Vyas
Code

Implementation of the RISC-V ISA Extensions for Control-Flow Integrity Mentorship Project

Intermediate
•Varies175h (Medium)

<p>Control-flow integrity (CFI) is a fundamental security mechanism that prevents attackers from hijacking a program's execution flow. By exploiting memory vulnerabilities, such as stack-smashing or use-after-free bugs, malicious attackers can corrupt pointers or overwrite return addresses, thereby silently redirecting execution to arbitrary malicious code. RISC-V has recently ratified two ISA extensions to enforce CFI at the hardware level through two complementary primitives. The shadow stack maintains a separate, hardware-protected copy of return addresses, preventing a corrupted call stack from redirecting returns to malicious code. Landing pads require that all valid indirect jumps must land at an explicitly marked location with a special instruction, preventing attackers from redirecting execution to unintended locations.</p><p><br></p><p>In collaboration between the Barcelona Supercomputing Center (BSC) and the SUSHI research team (Inria Rennes), this project aims to implement both CFI extensions on Sargantana, an open-source, Linux-capable, RISC-V core. The mentees will begin by studying the RISC-V CFI specification and the Sargantana microarchitecture, and will then produce an architectural plan of the required pipeline modifications. The mentee will then implement the shadow stack mechanism, including hardware enforcement of shadow stack semantics and access-protection logic. This will be followed by landing pad support, which will involve pipeline enhancements to validate indirect branch targets at commit time. Finally, the mentee will use the Sargantana emulation infrastructure to ensure functional correctness of the implemented extensions and to study the hardware overhead they impose.</p>

TBA
Proposal

Apache Arrow Interface for PODIO

advanced
CERN-HSF•2026Varies350h (Large)

This project aims to implement a high-performance Apache Arrow backend for PODIO. Currently, PODIO data is primarily persistent in ROOT and SIO formats, which can introduce significant I/O overhead for modern, language-independent analytics. The Problem In high-energy physics, data analysis often requires processing only specific subsets of complex event structures. Traditional file-based backends often require loading entire object hierarchies, leading to memory and I/O bottlenecks. The Solution The proposed solution implements a dual-path ingestion strategy within PODIO's code generation engine In-Memory Zero-Copy Access: Utilizing arrow::ListView to map existing PODIO memory buffers directly into Arrow tables for real-time, language-independent analysis. Serialized Normalization: Implementing a normalization layer that packs scattered memory blocks into contiguous arrow::ListArray structures to satisfy the strict requirements of Parquet storage. Relational Mapping: Resolving C++ pointers into a Composite Key (Collection ID + Index) to maintain complex object relationships across different platforms and memory layouts. Key Deliverables Core Arrow Backend: A C++ implementation integrated into PODIO's generator to translate YAML-defined models into Arrow’s columnar format. Parquet Support: Out-of-the-box serialization to industry-standard Parquet files. Round-Trip Validation: A robust testing suite ensuring 100% data parity when converting between PODIO Frames and Arrow Tables. Performance Benchmarking: A side-by-side comparison of throughput and disk footprints between ROOT TTree and the new Arrow/Parquet backend.

pythonc/c++machine learning+6
Student: Arnav Dham
Code
Proposal

Behavioral evals, Quality, and the OSS Community

advanced
Gemini CLI•2026Varies350h (Large)

This proposal focuses on improving the behavioral evaluation (eval) infrastructure of Gemini CLI to ensure reliable and safe AI tool usage. The current system has significant gaps, including missing eval coverage for ~37.5% of tools, a large number of non-CI-blocking (flaky) tests, and lack of tooling for debugging and contributing to evals. To address this, the proposal introduces a three-part approach: Expand and Stabilize Behavioral Evals Write 15–20 new evals covering uncovered tools and missing behaviors (error recovery, multi-step reasoning, safety, ambiguity handling). Stabilize flaky evals and promote reliable ones to CI-blocking status. Focus on testing tool-call decisions instead of text output for robustness. Enable Contributor Participation via Skills & Subagents Introduce an eval-writer skill to help generate evals. Build subagents like eval_investigator (debugging failures) and quality_analyst (coverage analysis). Make eval development accessible to open-source contributors. Fix Ecosystem Gaps (Process, Tooling, Documentation) Define clear eval review, promotion, and regression-handling processes. Improve logging with readable tool-call traces. Create the Eval Development Kit (EDK) with tools for: Eval inventory & coverage analysis Validation checks Auto-generating evals from real chat logs Add documentation, tutorials, and GitHub automation for easier community contributions. Overall, the goal is to transform evals from a limited internal system into a scalable, contributor-friendly quality framework, enabling the OSS community to actively improve AI behavior, reliability, and performance.

typescriptGenAIMCP+2
Student: VedantxMahajan
Code
Proposal

EΑΤ - Addition of Jboss Community Server Release Snapshot and multi-version Android Projects

intermediate
JBoss Community•2022Varies175h (Medium)

EAT (Eap Additional Testsuite) is a testsuite to develop tests against infinite number of JBoss servers. It’s an innovative tool because it’s creating the test once and testing with any version of the tested software. EAT is available for a number of server configurations and a CI pipeline can be built using the maven tool. The goal of the present project is to extend EAT with new features and tools. The implementation of the project is estimated to last from June to November (Large Size Project) and the timeline is envisaged as follows: During the 1st Phase (June 2022 - July 2022) a snapshot will be added for testing the latest version of JBoss Community Server. The newly added snapshot will be made available for use with the CI builds. Moreover, the extension of EAT with additional multiversion android projects (described at the second phase) will begin. Continuing to the 2nd Phase (July 2022 - September 2022), new multiversion Android projects will be added to EAT. In EAT there is already a basic android multiversion example. This will be extended with other open source android projects demonstrating how EAT can be used to support multiversion real life android projects. Finally, during the 3rd Phase ( September 2022 – November 2022) a multi-version Android application will be developed and added to EAT. This app will enable users to upload and view descriptions and ways of usage for various programs or functions. The users will be able to upload the descriptions of projects related to EAT, how they can be used and other project related information. The documents will be proposed for acceptance and when accepted they will be stored in e.g. google drive, from where they will be accessible for anyone interested.

androidjavaide+12
Student: Stefanos Vlachos
Code

A Seamless Interface Between LLMs and Pharo

advanced
Pharo Consortium•2025Varies350h (Large)

This project aims to build ChatPharo, an intelligent, AI-powered assistant that integrates Large Language Models (LLMs) directly into the Pharo development environment. Despite Pharo’s strengths as a live programming platform, it currently lacks a native and user-friendly interface for interacting with LLMs to assist with code explanation, generation, documentation, and debugging. To address this, the project proposes a seamless, modular, and extensible system that connects Pharo with both online (OpenAI, DeepSeek) and offline (TinyLLaMA, Mistral-7B via Ollama) models. A multi-tab chat interface will allow users to manage multiple contextual conversations, while intelligent AI commands (e.g., /explain, /generate tests, /refactor) will directly support day-to-day coding workflows. Memory optimization techniques—including smart caching, chat pruning, and lazy model loading—will ensure smooth performance even in long sessions. A key innovation includes experimenting with pseudo-parallelism in Pharo’s single-threaded architecture by spawning secondary images to offload heavy LLM processing. This enables parallel task handling without compromising the responsiveness of the main Pharo image. By midterm, users will have access to a working chat UI, multi-LLM switching, and foundational coding actions. By the final evaluation, ChatPharo will evolve into a context-aware assistant capable of inline suggestions, AI-driven debugging, and scalable architecture for future extensions. Through full documentation, tutorials, and community engagement, this project will not only enhance developer productivity but also showcase Pharo as a capable, modern AI-enhanced development platform.

smalltalkroassalpolymath+7
Student: SrajalDwivedi17
Code
Proposal

Implementing a Hair Shader for Cycles

intermediate
Blender Foundation•2018Varies175h (Medium)

<p>Realistic hair or fur is essential when creating a plausible virtual world. In feature animation, this is often used to define the signature look of characters; examples include Pixar’s <em>Brave</em> (Iben et al. 2013), and Walt Disney Animation Studios’ <em>Tangled</em> (Sadeghi et al. 2010; also Ward et al. 2010) and <em>Zootopia</em> (Chiang et al. 2016).</p> <p>Currently, Cycles has a working hair shader (<a href="https://docs.blender.org/manual/en/dev/render/cycles/nodes/types/shaders/hair.html" target="_blank">wiki page</a>, <a href="https://git.blender.org/gitweb/gitweb.cgi/cycles.git/blob/HEAD:/src/kernel/closure/bsdf_hair.h" target="_blank">sources</a>), based on Marschner et al. (2003)’s model. Its several assumptions and simplifications make it inaccurate for light colored hair (d’Eon et al. 2011) as well as for most types of fur (Yan et al. 2015). Furthermore, d’Eon et al. (2011) and Khungurn and Marschner (2017) demonstrated it to not be energy conserving.</p> <p>This project intends to upgrade Cycles’ hair shader to the aforementioned <em>Zootopia</em> shader by Chiang et al. (2016), by porting Pharr (2017)’s implementation. Lukas Stockner has made available <a href="https://github.com/lukasstockner/blender/tree/hairshader" target="_blank">a WIP patch </a>, which may also serve as a basis for this work.</p>

cpythonopengl+3
Student: L. E. Segovia (amyspark)
Code
Proposal

3D PDF Export in FreeCAD

advanced
FreeCAD•2025Varies350h (Large)

The 3D PDF Export for FreeCAD project aims to develop a native capability for exporting interactive 3D models directly to PDF format, enhancing FreeCAD's documentation and collaboration capabilities. Currently, FreeCAD users must rely on complex multi-step workflows involving external tools like MeshLab, LaTeX, or even commercial CAD software to create 3D PDFs, often resulting in loss of model fidelity, colors, and structure. This project proposes implementing a seamless 3D PDF export feature integrated directly into FreeCAD's TechDraw workbench. Users will be able to create standard technical drawings with traditional orthographic views and dimensions, plus an interactive 3D view that appears as a regular isometric view in print but becomes fully interactive when viewed digitally. Key components of the implementation include: 1. Document Structure Access: Utilizing FreeCAD's Python API to traverse the document object hierarchy or need to rely on Qt for accessing certain structural information. 2. 3D Format Conversion: Implementing exporters for both U3D format and PRC format to support NURBS surfaces for higher fidelity representation. 3. PDF Generation: Creating a PDF container that properly embeds the 3D content with interactive viewing capabilities. 4. TechDraw Integration: Extending the TechDraw workbench to include a new "3D View" type alongside traditional orthographic views. The completed feature will significantly enhance FreeCAD's usability for professional documentation, enabling users to share interactive 3D models with clients and collaborators who don't have CAD software, addressing a long-requested feature within the FreeCAD community.

pythonc++qt+2
Student: chiragsingh1711
Code
Proposal

BI connector and demonstration

intermediate
Apache Software Foundation•2026$3k–$6.6k175h (Medium)

Fineract is largely used as a system of record for lending in many institutions globally. As such, most of the analysis is about portfolio health — how well are people paying back, and what are the key risks around repayments. This includes PAR, loan loss provisioning, write-offs, and trend lines for the same, along with basic stats like number of customers, the loan cycle they are on, aging of customer cycles, exceptions tracking, and correlation to any characteristic in the data. Currently Fineract does not have a analytics pipeline where vendors, users, institution can see these analytics. This project solves this problem. My plan is to build a complete ELT analytics platform. A python extractor will pull data from read replica of Fineract DB incrementally using a read only database user. It will push the data the PostgreSQL analytics warehouse. From there a dbt project will handle all the data transformation (delinquency calculations, PAR ratios, repayment behavior, portfolio health). I will show interactive dashboards with different type of charts, graphs, stats and analytics using Apache Superset. By the end of GSoC, the deliverables are: a working Python ELT extractor with both backfill and incremental modes, a fully tested 4-layer dbt warehouse model covering the Fineract lending domain, five production-oriented Superset dashboards (Portfolio Health, Delinquency and PAR, Repayment Behavior, Risk and Finance, Customer Lifecycle), Docker Compose setup so anyone can run the full stack locally, and complete documentation including a runbook and data dictionary. The whole stack is Apache 2.0 licensed, self-hostable, and designed so future contributors can add new analytics modules without changing what's already there.

pythonjavascriptjava+7
Student: Aira Jena
Code
Proposal

Extend and improve the CERNBox Notifications platform

beginner
CERN-HSF•2023Varies90h (Small)

Reva is the core of the CERNBox service. It is a middleware framework, providing interoperability between storage and application providers using a universal set of APIs. Currently, Reva’s notifications system is under development. In the next few weeks, a small set of actions in the notifications system will be launched, including • Notifying a user you shared a file/folder with them via email. • Notifying a user you uploaded a file to a folder they shared with you. I propose to improve this notifications center with several additions. The notifications would have a new settings option in which the user can primarily choose which MIME type and possibly file type he wants to receive notifications for. This is to be done with additions to the database schema, possibly designing a completely new schema. Also, there is major work to be done in the back-end system in order to fully support this feature, and of course lastly, in the front end - there needs to be work done on creating the settings window and parsing the user choices for the setting they want to choose. After this, another improvement can be done to the notifications center which is the ability to get metrics on certain data - in particular how many files/folders of a certain type or in general have been shared to this or by this user. There is mostly work on the front end to be done here designing the possible options in the settings to display this metric. But also work on accessing the database to get these metrics displayed to the user. Deliverables: The extension of the simple notifications into a notifications center in the UI, including settings for filtering the MIME type of the file • Documentation on the implementation, reusability, extensibility, and testability of the system, alongside a guide on how to use the UI. • This includes extensions of the current back-end architecture as well as extensions in the front-end UI. • A richer API system for notifications that include metrics analysis

pythonc/c++machine learning+6
Student: daniel-rey
Code
Proposal
Showing 4657 - 4680 of 4718 Projects
193194195196197
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal