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

Hi Haddock

intermediate
Haskell.org•2018Varies

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)

<p>A long-standing issue with Haskell’s documentation tool Haddock is that it needs to effectively re-perform a large part of the parse/template-haskell/typecheck compilation pipeline in order to extract the necessary information from Haskell source for generating rendered Haddock documentation. This makes Haddock generation a costly operation, and makes for a poor developer experience.</p> <p>An equally long-standing suggestion to address this issue is to have GHC include enough information in the generated <code>.hi</code> interface files in order to avoid Haddock having to duplicate that work. This would pave the way for following use-cases and/or have the following benefits:</p> <p>1) Significantly speed up Haddock generation by avoiding redundant work.</p> <p>2) On-the-fly/lazy after-the-fact Haddock generation in cabal new-haddock and stack haddock for already built/installed Cabal library packages.</p> <p>3) Add native support for a <code>:doc</code> command in GHCi’s REPL and editor tooling (ghc-mod/HIE) similar to the one available in other languages (c.f. the Idris REPL or the Python REPL)</p> <p>4) Allow downstream tooling like Hoogle or Hayoo! to index documentation right from interface files.</p> <p>5) Simplify Haddock’s code base.</p>

haskellghccabal+3
Student: Simon Jakobi
Code
Proposal

Standardized Python Pipeline for Evaluating Perfusion Imaging Challenge

beginner
Open Science Initiative for Perfusion Imaging•2026Varies90h (Small)

This project will develop a standardized Python pipeline to evaluate submissions to OSIPI perfusion imaging challenges for ASL and DSC DCE MRI methods. Researchers use different computational approaches to generate perfusion parameter maps, but there is a need for a consistent system that can validate submitted datasets run submitted code and calculate evaluation metrics in a reliable and reproducible way. The proposed pipeline will accept challenge submissions that include parameter maps and the code used to generate them. It will first validate that submitted files follow expected structures and medical imaging formats such as NIfTI and BIDS. The system will then run the submitted workflows in a controlled environment and calculate evaluation metrics such as RMSE bias and coefficient of variation. Results will be organized into reports and visualizations that allow researchers to compare the performance of different methods against reference datasets. The pipeline will be implemented in Python and designed to support both ASL and DSC DCE challenge frameworks. The architecture will focus on modular design so new datasets metrics and evaluation procedures can be added in the future. Automated testing validation checks and documentation will be included to ensure the system is reliable and easy for researchers to use and extend. This project will help improve reproducibility and transparency in perfusion imaging research by providing a clear standardized framework for benchmarking computational methods used in quantitative MRI.

pythongithub
Student: Ranya
Code
Proposal

SciPy: Restructuring the F2PY frontend and replacing the build system

beginner
Python Software Foundation•2022Varies90h (Small)

F2PY is an open-source utility that provides an easy connection between Python and Fortran languages. It enables users to integrate Fortran code into Python easily and quickly. F2PY has been in maintenance mode since 2009, ever since it became feature-complete for Fortran 77. Beginners browsing its codebase in the current state might find it challenging to read, understand and contribute. The frontend of F2PY is a handwritten command line parser that predates the intrinsic ‘argparse’ module by several years. This project will include modernising the CLI with the “argparse” python library, simplifying the frontend codebase and making it more developer-friendly to contribute to. Since “np.distutils” is set for deprecation, I propose adding an option to build the F2PY’s generated CPython extension modules with Meson. Meson will significantly speed up building standalone extension modules through the F2PY CLI. There is no change proposed to the process of generating C and Fortran wrappers from Fortran source files. Generation of the source code for integration in Python projects will be carried out in the same way. Currently, “np.distutils” is used by F2PY to build generated extension modules. Adding a Meson backend will provide faster builds and long-term backend support for F2PY. Additionally, I plan to re-implement the class-based test-suite of F2PY in a modern pytest manner and add a developer’s guide to F2PY.

pythonmercurialjavascript+3
Student: Namami Shanker
Code

User management and notifications

intermediate
Internet Health Report•2022Varies175h (Medium)

Implement user registration: When the user enters email address, regular expression matching will be conducted at the front end to check if it is in the proper format. After entering the password twice, user can submit the form, and MD5 algorithm will be used to encrypt the password at the front end. In addition, once the verification code submitted by the user is verified, the user email address and password will be written into the database. Implement user login: When user email address and password are filled in at the front end, the back end will verify the user's password. After passing the verification, a unique token secret key will be returned to the front end which is generated according to user's account and password by using Django tokens. Implement notification settings: The user selects the sources and sets the level of verbosities at the front end. After submitting the form, the user account will be firstly recognized according to the tokens, and then the selected sources and verbosities will be stored in the database. User can also search for sources at the front end. Approximate string matching will be used to look for values in a reference database. The first 30 matching results will be returned for users to choose. Implement sending email: I plan to use the email service supported by Django framework. I will configure SMTP related settings and develop an API, which can be called where the alert emails need to be sent.

pythonjavascriptapache kafka+1
Student: Luofei
Code
Proposal

End-to-end handwritten text recognition for early modern spanish documents

advanced
HumanAI•2025Varies350h (Large)

This project focuses on end-to-end Handwritten Text Recognition (HTR) for early modern Spanish manuscripts. Unlike traditional OCR systems, which process isolated characters or lines, end-to-end HTR captures entire documents, preserving not only the text but also structural elements such as layout and reading order. Although this approach holds significant promise for both research and practical applications, it remains underexplored, especially for historical texts. This project proposes to apply end-to-end HTR techniques to early modern Spanish manuscripts, a historically rich yet computationally challenging corpus. Leveraging recent advances in deep learning. The project aims to improve recognition accuracy on handwritten and printed texts from this period by building on models which focus on document-wide attention mechanisms, the system will be able to better handle complex layouts and diverse handwriting styles typical of early modern Spanish texts. Ultimately, this research sits at the intersection of machine learning and historical document analysis, contributing both to technical innovation and cultural preservation. By improving the accessibility of early Spanish documents, the project not only supports scholars in the humanities but also contributes to the growing field of AI-driven humanities research. The integration of cutting-edge HTR models into historical workflows can open new possibilities for indexing, searching, and analyzing large volumes of archival material in a scalable, automated fashion.

pythonmachine learningc+++2
Student: Aniket Junghare
Code

Improve lifecycle management of sandbox monitors (2026 Term 2)

Intermediate
•Varies175h (Medium)

<p>Currently, urunc launches sandbox monitors, such as Firecracker and QEMU</p><p>through command-line invocations. This approach offers limited control over the</p><p>sandbox lifecycle once the process is started. On the other hand, most</p><p>monitors expose remote management interfaces, typically through a socket-based</p><p>API.</p><p><br></p><p>These interfaces provide access to the same operations currently performed via</p><p>CLI, but also enable further control over the sandbox lifecycle. In particular,</p><p>they allow more fine-grained lifecycle management of the sandbox, including</p><p>querying and monitoring its state, performing device hotplug and unplug</p><p>operations and interacting with the guest.</p><p><br></p><p>This project aims to extend urunc's sandbox integration layer to support remote</p><p>management interfaces and to explore each monitor's capabilities in order to</p><p>extend the functionalities of urunc sandboxed containers.</p><p><br></p><p>Expected Outcome:</p><p>&nbsp;- A design document describing the updated architecture and workflow for</p><p>&nbsp;&nbsp;spawning and managing sandbox monitors in urunc.</p><p>&nbsp;- Implementation of the necessary changes in urunc to manage sandbox monitors</p><p>&nbsp;&nbsp;through their respective APIs.</p>

TBA
Proposal

Generate Counter Examples for Bounded Model Checks in CIRCT

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

circt-bmc can already prove when an assertion is falsifiable, but it does not yet produce the counterexample trace format hardware developers rely on for debugging. Today, users get a SAT/UNSAT result without a practical cycle-by-cycle waveform showing how the design reached failure. This project adds that missing debugging path. I will preserve meaningful signal identities before lowering, track the corresponding solver expressions across BMC timesteps, and evaluate those expressions against the first satisfying Z3 model. The implementation is intentionally staged: first a readable text counterexample for the failing prefix, then VCD waveform generation from the same trace data. The focus is the first-failure prefix (cycle 0 to the violating step), which delivers high user value with low integration risk and clean upstreamability. Deliverables: 1. Signal tracking and naming pipeline for user-relevant values (ports, externalized registers, selected internals where remapping is reliable). 2. A BMC trace runtime component that records per-step solver ASTs and supports model-driven trace emission. 3. Midterm milestone: first-failure text counterexample dump. 4. Final milestone: VCD waveform output for the same counterexample path, exposed through circt-bmc CLI flags. 5. Upstream-quality tests and documentation (IR-level + end-to-end regressions, including failing and no-violation cases).

pythonjavascriptfpga+11
Student: Shri Vishakh Devanand
Code

Enhanced Reuse Agent for Intelligent License Reuse

intermediate
FOSSology•2026Varies175h (Medium)

The current reuse workflow in FOSSology provides a powerful mechanism to copy license clearing decisions from a previously analyzed upload to a newer version. However, this process remains largely mechanical and opaque, offering little insight into what has changed between versions after reuse is applied. As a result, users must manually inspect differences to understand the impact of reuse, which becomes increasingly difficult for large codebases and frequent updates. To address this limitation, this project proposes the development of an Enhanced Reuser Agent that adds an intelligent analysis layer on top of the existing reuse workflow. The agent runs automatically after scanners complete and reuse decisions are applied, comparing the previously cleared upload (v1) with the new upload (v2). It generates insights such as a diff-aware file tree, license comparison, aggregated statistics, and a risk-level summary. In addition, a Smart Reuse (Suggested Matches) mechanism automatically identifies and recommends similar previously-cleared uploads, reducing the manual effort required to search for suitable reuse candidates. By providing a clear and interactive view of structural and license-level changes, along with proactive reuse suggestions, the system enables users to better understand the outcome of reuse and efficiently refine decisions where needed. This transforms reuse into a more transparent and insight-driven process, reducing manual effort and improving overall usability while remaining fully compatible with the existing FOSSology workflow.

linuxpostgresqlc/c+++7
Student: Saksham Mishra
Code
Proposal

Time-Travel Data Access and Versioning UI for istSOS Web Administration

intermediate
OSGeo (Open Source Geospatial Foundation)•2026Varies175h (Medium)

The istSOS backend already provides strong support for time-travel queries and versioned data through parameters like as_of and from_to. However, these capabilities are currently only accessible through manual API usage, which makes them difficult to use for most users. This project focuses on bringing these features into the web administration UI by building an intuitive and accessible interface for exploring historical data. Users will be able to select a specific timestamp or time range, view the exact past state of entities such as Things, Sensors, and Datastreams, and understand how data evolved over time without writing API queries. The approach is to design lightweight frontend components that map user input to existing backend parameters, keeping the backend unchanged while making the feature usable. In addition, a Commit History Viewer will be implemented to allow users to browse changes, view metadata like author and timestamp, and load past snapshots directly into the UI. By the end of the project, istSOS will have: - Time selection controls integrated into the UI (instant and range) - Historical views for all major entities - A commit history explorer for tracking data changes - A clean query mapping layer between UI and API - Proper testing and documentation for long-term maintainability Overall, the goal is to make time-travel functionality a first-class feature in istSOS, improving transparency, usability, and accessibility for both technical and non-technical users.

pythonjavascriptc/c+++4
Student: Bhudev Bhanpuriya
Code

Create a new Backend for Frontend and Frontend POC for Apache Fineract

advanced
Apache Software Foundation•2026Varies350h (Large)

My name is Edward. I'm a Master’s student at the University of Colorado Boulder in the US and I am passionate about Apache Fineract’s mission to improve the availability of financial services to people all over the world. Apache Fineract provides core banking APIs, but lacks a community-maintained layer for end-users. The former Self-Service API was removed, leaving vendors to build their own frontend from scratch. To support this new frontend, I am proposing a new Backend for Frontend (BFF) and associated frontend that enables improvements to end-user security, reliability, performance, and auditing. The focus of this project is to build a POC that is well-tested and documented so we can build a "release-ready" solution in the future. Deliverables include: 1) Standalone Spring Boot BFF application with its own user model and JWT-based authentication 2) Feign client integration with Fineract's core API via a dedicated service account 3) API Aggregations for User data summaries, account information, loan and savings views, and transaction capabilities 4) User registration flow with OTP and Identity Verification 5) User login flow with 2FA 6) Auditing for Basic Frontend Concerns 7) Open Banking Authentication Flow 8) A working frontend to demo these features Some stretch goals include but are not limited to: 1) MPIN for transaction authorization 2) Rate Limiting 3) HSM key storage

pythonjavascriptjava+7
Student: Edward Kang
Code

Internet Archive GSOC Project Proposal

intermediate
Internet Archive•2017$3k–$6.6k175h (Medium)

<p>This project focuses on "Building a Chrome extension for the Way Back Machine, Adding new feature for the way back machine's chrome extension."</p> <p>The original chrome extension was released during January 2017 where the unofficial and pre-release version was developed and released as an open source contribution at mid-2016. This is an extended update for the January 2017 chrome extension of the way back machine. This project has already several repositories in GitHub, where previous selected projects for building a chrome extension for the way back machine alongside with integrations, are available at the link below:</p> <p><a href="http://www.github.com/rakesh-chinta/WayBackMachineChromeExt/" target="_blank">http://www.github.com/rakesh-chinta/WayBackMachineChromeExt/</a></p> <p>The project's Goals and criteria for success:</p> <ul> <li>Integration with the Wayback Machine’s Site Search</li> <li>Support for social sharing, including Twitter and Facebook</li> <li>Display Tweets about a URL for a given date range</li> <li>Provide user with visual feedback based on if we have archived a URL or not</li> <li>Provide user with a one-click Summary view of a given site (Alexa Rank Whois, etc.)</li> <li>Automatically archive URLs that are not in the Wayback Machine</li> <li>Quick access to an overview of all the Archives for a specific URL</li> </ul>

pythonjavascriptpthon+6
Student: Rakesh N Chinta
Code
Proposal

Sampling correlation matrices

advanced
GeomScale•2022Varies350h (Large)

We study the sampling of correlation matrices from a given probability density, which has applications in various scientific, engineering and business areas (biology, finances,...). This problem is technically difficult due to the constraints of correlation matrices (entries in [-1,1], positive semi-definiteness). The current methods can only scale to a few tens of dimensions. This project aims to provide efficient C++ implementations for new geometric-flavored algorithms to sample correlation matrices (Arakelian, Chalkis 2021) and integrate them into VolEsti, an open-source high-performance software for sampling, volume computing and geometric statistics. Our main tasks consist of implementing a new class of convex bodies to represent the space of correlation matrices and geometric operations for performing two random walk sampling algorithms (the accelerated billiard walk and Reflective Hamiltonian Monte Carlo algorithm) over those convex bodies. These tasks can be supported by the already existing geometric facilities of VolEsti and the theoretical results found in related works. We will focus mainly on building an optimized C++ code to achieve better scalability for those algorithms and carry out intensive experiment and benchmark with other competitors to justify our efficiency. The expected duration of this project is 175 hours spread over 7 weeks of coding period (June 13 - July 29). The C++ implementation obtained by the end of this project will expand VolEsti towards an all-in-one high-performance statistic tools for research and business uses.

pythonc++r+2
Student: Huu Phuoc Le
Code
Proposal

Round-trip integration between GitHub/GitLab issues and git-issue

beginner
Open Technologies Aliance - GFOSS•2019Varies90h (Small)

<p><code>Git-issue</code> is a minimalist issue management system based on <code>git</code>. It strives to be <strong>simple to use</strong>, <strong>decentralized</strong>, and in line with existing <strong>Unix software philosophy and design</strong>. Currently, <code>git-issue</code> can import data from GitHub's issue management interface, but <strong>not</strong> export them. This is limiting in the following ways:</p> <ul> <li>It can lead to out-of-sync issue databases between git-issue and <em>GitHub</em>, which means that users have to access both to get the whole picture</li> <li>It prevents usage of git-issue as an <strong>one-stop solution</strong>, since GitHub's interface still needs to be used to process issues opened in GitHub</li> <li>It limits potential use cases, since <code>git-issue</code> has to compete with ubiquitous issue management solutions such as <em>GitHub/Gitlab</em>, instead of synergizing with them</li> </ul> <p>Thus, adding export capabilities would complete the round-trip integration between <code>git-issue</code> and <em>GitHub</em>, and pave the way to wider adoption. The same argument can be made with <em>GitLab</em>, for which neither export nor import capability is currently supported. This proposal aims to add import and import/export functionality for GitHub and GitLab respectively.</p>

pythonjavascriptgtk+2
Student: Vyron Drosos
Code

Building Immersive Learning Experiences

advanced
Society for Arts and Technology (SAT)•2023Varies350h (Large)

The proposed project aims to support teaching in hybrid telepresence settings by developing and embedding examplar explorable explanations into the Satellite hub, an immersive 3D social web environment developed at the Society for Arts and Technology (SAT) using Mozilla Hubs. Explorable explanations are interactive documents that use visualizations, animations, and simulations to help learners understand complex concepts. The project will integrate explorable explanations in Mozilla Hubs used for Satellite by adapting Spoke to defining dynamic assets with interactivity. This integration will allow for the creation of immersive and interactive educational environments that cater to diverse abilities in learning and allow learners to play with parameters to deepen their understanding of the concepts. The project seeks to create synergy by interconnecting various cultural and artistic contents in the Satellite hub and embedding explorable explanations to enhance the learning experience. The explorable explanations will be designed to cater to a broad audience and facilitate access to learning. The project will involve prototyping examplar explorable explanations and embedding them in Satellite / Mozilla Hubs, leveraging the capabilities of the platform to provide an immersive learning experience. The aim is to enhance the teaching of digital arts concepts in hybrid telepresence campus settings and promote interactivity and innovation in teaching, leveraging emerging technologies to enhance the learning experience. Ultimately, the project will contribute to promoting interactivity and innovation in teaching, leveraging emerging technologies to enhance the learning experience.

pythonjavascriptopengl+4
Student: Pedro Andrade
Code

Flent Application API Integration and Validation in ns-3

advanced
The ns-3 Network Simulator Project•2026Varies350h (Large)

The Flexible Network Tester (Flent) is an industry-standard tool for evaluating Bufferbloat and network performance. However, benchmarking simulated networks in ns-3 currently requires researchers to rely on external, error-prone parsing scripts to translate simulator events into Flent-compatible data. This project solves this disconnect by natively integrating the Flent Application API into the ns-3 mainline. The proposed solution involves modernizing a legacy C++ wrapper, eliminating artificial queue constraints used in prior proof-of-concepts, and refining the linear interpolation logic to accurately translate discrete ns-3 trace callbacks into strict periodic data points. A critical phase of the project involves scientific validation. comparing the simulated ns-3 outputs against real-world Linux hardware benchmarks (using tc and ss) to guarantee mathematical and statistical accuracy. Deliverables: 1) A robust, memory-safe FlentHelper C++ API that allows users to seamlessly configure tests and directly output visualization-ready .flent JSON files. 2) A scientific validation report proving the parity between the simulated network metrics and physical Linux network namespaces. 3) Expanded support for complex multi-flow Bufferbloat tests (including RRUL, Best Effort, and VoIP). 4) Comprehensive user documentation and automated example scripts merged into the ns-3-dev mainline.

pythonc++c/c+++2
Student: Kedar Kisan
Code

CauST: Causal Gene Intervention for Robust Spatial Domain Identification

advanced
UC OSPO•2026Varies350h (Large)

Spatial transcriptomics methods identify tissue domains by clustering spatial gene expression patterns, but current approaches select genes using variance-based heuristics such as highly variable genes (HVGs). Many HVGs reflect donor-specific noise rather than genes that truly drive spatial organization, which leads to poor generalization when models are applied across tissue slices from different donors. This project addresses this limitation by introducing CauST, a framework for identifying causally important genes for spatial domain identification. CauST evaluates each gene through in-silico gene knockout experiments, measuring how much removing the gene changes the learned spatial embedding produced by a spatial graph neural network. To ensure robustness, the method then applies a cross-slice invariance criterion, selecting genes whose effects are both strong and stable across multiple donors. The resulting causally invariant gene set is used to retrain spatial domain identification models, enabling improved cross-donor performance without modifying the underlying model architecture. The project will deliver a production-quality open-source CauST Python package, integration with multiple spatial transcriptomics backbones (STAGATE, GraphST, and SpaGCN), a multi-dataset benchmark evaluating cross-slice robustness, visualization tools for interpreting causal gene importance, and tutorial notebooks and documentation to support adoption by the spatial transcriptomics community.

pythonc/c++visualization+5
Student: Phil_Li
Code

Ujjwal Agrawal/ WikiEdu Dashboard Android App

intermediate
Wikimedia Foundation•2019Varies175h (Medium)

<p>Wiki Edu Dashboard App is an Android client for the Wiki Education Dashboard API to support managing programs, including edit-a-thons, education programs, and other events. The app allows users to access Wiki Education Dashboard and Programs &amp; Events Dashboard from their Android phone. The Android app would be handy, especially for use in bandwidth-constrained situations and during edit-a-thons.</p> <p>The app will contain the following features:</p> <ul> <li>Log in to either dashboard.wikiedu.org or outreachdashboard.wmflabs.org</li> <li>SignUp to either dashboard.wikiedu.org or outreachdashboard.wmflabs.org</li> <li>See a list of current, active courses</li> <li>See a list of your own courses</li> <li>List of users for a course</li> <li>List of articles edited for course</li> <li>Recent activity for a course</li> <li>List of uploads for a course</li> <li>Search for courses by name</li> <li>List of my articles (articles assigned to me) in a course</li> <li>Assign yourself articles for a course you are in</li> <li>Join a course that does not require a passcode</li> <li>Join a course by opening an enrollment URL</li> <li>As a program organizer, create accounts for edit-a-thon participants</li> <li>If time permits, Release the app in Play Store (at least in alpha).</li> </ul>

javascripthtmlphp+7
Student: Ujjwal Agrawal
Code
Proposal

Enhanced Dual Contouring

intermediate
CGAL Project•2025Varies175h (Medium)

The goal of this project is to enhance the existing Dual Contouring (DC) method in CGAL by implementing manifold contouring methods. While the classical DC is a powerful isosurfacing method, it may produce non-nonmanifold surfaces, leading to topological inconsistencies and computational challenges. Manifold dual contouring methods overcome this issue by introducing manifold constraints to ensure the generation of 2-manifold surfaces. The project will begin with a detailed study of existing literature, including Manifold Dual Contouring by Schaefer, Ju and Warren, and other related methods. Based on the research, we will determine an algorithm that combines the most robust aspects of these methods. The next phase is to review current DC implementations in CGAL to identify gaps that require modifications, particularly in routines such as the Quadratic Error Function (QEF) minimization, octree traversal, and polygonalization. Lastly, additional features will be added, including manifold criterions like the Euler characteristic test, and the support for multiple vertices per cell. The final deliverables will be a robust implementation of the enhanced DC method integrated into CGAL under the Isosurfacing subroutine. The implementation will adhere to CGAL’s existing coding conventions to ensure flexibility, consistency, and maintainability within the library. The documentation will include a test file under Isosurfacing 3/test/Isosurfacing 3, visualization of test cases under Isosurfacing/fig, and a theoretical background under Isosurfacing 3/doc/Isosurfacing 3/Isosurfacing 3.txt.

githubc++git+4
Student: Taoli Shen
Code
Proposal

Carbon-Aware Local Fitness Tracker

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

During GSoC, I propose to build a carbon-aware fitness tracker application from scratch that combines personal health tracking with environmental awareness while prioritizing user privacy. The project addresses two key problems: the lack of privacy in existing fitness apps, which often rely on external servers, and the absence of tools that help users understand their daily carbon footprint. To solve this, I will develop a Flutter-based mobile application along with a Wear OS companion app, integrating them using the Data Layer API and platform channels to seamlessly transfer fitness data such as steps, heart rate, and activity metrics from the watch to the phone. On the Wear OS side, I will use the Health Services API to collect real-time data, while the mobile app will feature a transport logging system that calculates carbon emissions or savings based on user travel choices, along with a dashboard displaying weekly summaries, visual charts, and actionable sustainability suggestions. All user data will be stored locally using SQLite to ensure complete privacy, and the application will be supported by comprehensive unit, widget, and integration testing to ensure reliability. The final deliverables will include a fully functional mobile and Wear OS application, a secure local data management system, a carbon footprint tracking and visualization module, and a production-ready app prepared for deployment on Android and Wear OS platforms.

pythonjavascriptswift+8
Student: Aneesa Fatima
Code
Proposal

Expected Returns: Factor Formation

advanced
R project for statistical computing•2025Varies350h (Large)

Financial factor investing relies on rigorous quantitative research to explain asset returns and generate alpha. While many academic models and institutional frameworks exist, open-source tools that replicate these methods — especially in R — are few and far between. This project aims to close that gap by contributing to the ExpectedReturns package, developing clean, modular functions that implement and generalize key factor construction techniques inspired by Antti Ilmanen’s Investing Amid Low Expected Returns. The focus will be on engineering reusable code for factors like value, momentum, profitability, and investment using raw or semi-structured financial data. These will be built using lightweight, testable components supported by packages like FactorAnalytics, PerformanceAnalytics, and tinytest, while following conventions used by Chen, Zimmermann, and Kelly. Also included will be vignettes and documentation that show how to reproduce these concepts in practice — making the tools both transparent and portable. This will be a two-month project. Deliverables will include: – Core functions for factor construction and data prep – Lightweight unit tests and clean vignettes – Documentation of inputs, outputs, and assumptions – A reproducible build setup that works across systems The goal is to make these concepts accessible — not just for researchers, but for anyone trying to understand and apply factor models in real-world contexts. If successful, this project will leave behind a set of tools that are as useful to the open-source community as they are to academic replication.

cc++r+4
Student: Al Pakrosnis
Code
Proposal

Robotics Academy: improvement of Gazebo scenarios and robot models

advanced
JdeRobot•2025Varies350h (Large)

This project aims to significantly enhance two specific simulation scenarios within the JdeRobot Robotics Academy: Follow Line and Vacuum Cleaner. While these exercises serve as valuable educational tools for robotics learners, the current Gazebo environments and robot models lack visual realism, accurate physical behavior, and modular ROS2 integration. To address these limitations, the project will refactor the URDF model used in the Follow Line scenario using modular Xacro descriptions and realistic textures. The line track world will also be improved with high-quality road textures and better lighting for consistent perception results. In the Vacuum Cleaner scenario, the environment will be rebuilt using realistic room furniture and obstacles imported from Blender assets. Additionally, the Roomba robot model will be upgraded for improved physical dynamics, and its SLAM and navigation performance will be enhanced by tuning ROS2 Navigation2 parameters. Common improvements across both scenarios include updating the launch files to align with ROS2 Humble best practices, ensuring compatibility with the latest versions of Gazebo such as Fortress or Ignition, and producing clear documentation to support scenario creation and extension. The final deliverables will include the revamped simulation scenarios, reusable robot models, an organized and modular launch structure, and comprehensive user documentation. These improvements aim to boost the realism, engagement, and overall educational value of the Robotics Academy platform.

pythonrosgazebo+2
Student: Nikhil_36
Code
Proposal

mlr3torchAUM A Comprehensive Solution for Imbalanced Classification in R

advanced
R project for statistical computing•2026Varies350h (Large)

Problem: Imbalanced datasets pose a significant challenge in machine learning, where standard metrics like accuracy can falsely evaluate a model that simply predicts the dominant class. Currently, the R community lacks a comprehensive and unified framework for handling imbalanced data and X-Risks problems natively integrated into the mlr3/mlr3torch ecosystem. Solution: This project, mlr3torchAUM, provides a comprehensive solution for imbalanced classification in R. It will bridge the current gap by integrating state-of-the-art loss functions, advanced evaluation metrics, and various data sampling techniques directly into the mlr3/mlr3torch pipeline. Deliverables: 1. State-of-the-Art Loss Functions: Implementation of algorithms including log-linear all-pairs squared hinge loss, Area Under Min (AUM) loss, and cost-sensitive logistic loss. 2. Sampling Operators: A robust suite of over-sampling techniques including SMOTE and ADASYN, alongside under-sampling techniques, all implemented safely under a `lazy_tensor` mechanism to avoid memory issues. 3. Advanced Evaluation Metrics: Integration of Precision-Recall curves, Macro/Micro AUM/AUC, and MCP/IMCP to fully support multiclass imbalanced scenarios. 4. LibAUC Integration: Porting cutting-edge losses and optimizers from the Python LibAUC library into R. 5. Engineering & Release: Comprehensive Test Driven Development, GitHub Actions for CI/CD, detailed vignettes, and a final submission to CRAN.

cc++r+4
Student: Wei Cao
Code

LLM Agent Protocols/Memory

intermediate
Apache Software Foundation•2026Varies175h (Medium)

Integrating AI agents with databases today requires custom implementations for each framework—no standard exists for capability discovery, safe query execution, or persistent context across sessions. This project adds agent compatibility to Apache AsterixDB by implementing two emerging standards: the Model Context Protocol (MCP) for structured tool exposure and the Agent-to-Agent (A2A) protocol for multi-agent coordination, along with persistent agentic memory utilizing AsterixDB's native storage. Key deliverables include: McpServlet implementing JSON-RPC 2.0 protocol with tools/list, tools/call, and resources/read methods; ToolRegistry enabling dynamic capability discovery; QueryTool and SchemaTool exposing SQL++ execution and dataset introspection; rate limiting and query safeguards for production safety; AgentMemoryManager providing durable CRUD storage for session context via SQL++ datasets; MemoryServlet REST endpoints for memory operations; and A2A protocol endpoints for multi-agent task delegation (stretch goal). The implementation integrates with existing AsterixDB infrastructure—BasicAuthServlet for authentication, MetadataManager for schema access, and LSM storage for persistence—requiring no breaking changes. By project end, AI agents can discover AsterixDB's capabilities, execute queries like "find customers with orders over $1000," and recall previous interactions across sessions—transforming AsterixDB into an AI-native database that speaks the language of modern agent frameworks.

pythonjavascriptjava+7
Student: Vivek Gangavarapu
Code
Proposal

MNE-Python: Implement decoding and statistical tools for advanced connectivity analyses

advanced
Python Software Foundation•2024Varies350h (Large)

Effective connectivity analyses are a staple of many neurophysiological research projects, providing key insights into the healthy functioning of the brain and pathological alterations with disease. MNE-Connectivity leverages the API of the highly-popular MNE-Python signal processing package to provide tools for computing such connectivity. However, given the complexities associated with studying interactions in the brain, it is critical that the metrics for estimating connectivity are robust, and the estimates themselves statistically significant. Naturally, it is essential that such tools are available in open-source toolboxes, something we will address in this project. First, building on recent work in the MNE-Connectivity toolbox, we will implement further support for advanced multivariate connectivity metrics in the form of a dedicated decoding module. This module will provide flexible tools for the data-driven analysis of connectivity that is critical for robust characterisations of network activity in multi-channel recordings. The only comparable implementations of such methods are in toolboxes for the proprietary language MATLAB, limiting the availability of these tools to the wider research community. Second, we will expand the existing set of statistical features available in MNE-Python to include tools for assessing the statistical significance of estimated connectivity, crucial for distinguishing genuine interactions from background noise. In all cases, new features will be complemented with detailed examples and tutorials in the MNE-Connectivity documentation. Altogether, the project will expand the repertoire and quality of open-source tools available for studying connectivity in the brain, a cornerstone of modern neurophysiological research.

pythonmercurialjavascript+3
Student: Thomas S. Binns
Code
Showing 4609 - 4632 of 4718 Projects
191192193194195
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal