Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
Mixxx currently allows assigning a single free-text genre to each track, which often leads to inconsistencies such as duplicate or fragmented categories (e.g., "Hip-Hop", "Hip Hop", "Hiphop"). This project proposes a complete rework of genre metadata handling, introducing three key features: local genre autocompletion with fuzzy matching, support for assigning multiple genres to a single track, and optional online genre suggestions using MusicBrainz and Discogs APIs. As a long-term extension, the project also explores a customizable genre mapping layer, enabling users to define how external genres are grouped or renamed according to personal preferences. Deliverables include: a redesigned genre database schema, enhanced UI for editing and filtering genres, API integration for genre lookups, and internal tools for mapping and translation of genre labels.
Maths-Mantra is an inclusive Android math learning app designed for visually impaired and sighted learners, transforming the way mathematics is explored through touch, sound, and interaction. Building on a foundation of accessible learning, the app introduces Quick Play, Learning Mode, and additional game modes, offering varied, engaging experiences for learners of different skill levels. It integrates device sensors such as the gyroscope, accelerometer, and multi-touch inputs to make geometry, number lines, and spatial concepts interactive and tangible. With gesture-based navigation, audio-tactile feedback, adjustable difficulty levels, and localization support, Maths-Mantra creates a multi-sensory, barrier-free environment that empowers students to understand and enjoy mathematics in a playful, engaging, and fully accessible way.
EchoGem introduces a novel batching engine designed to answer multiple questions about the same source parallelly to reduce response times heavily. It does so by building a modular smart batching engine for Gemini that teaches the model to think in context-aware batches. What sets EchoGem apart is its focus on modularity and testing—each component is designed to be independently swappable and improvable allowing for open testing and matching different strategies for different parts of the engine. Instead of a naive sliding window or top-k search approach, EchoGem uses semantic clustering of both chunks and questions to form intelligent batch groups. It is also committed to measurable, reproducible gains. Every design decision—whether it's a new chunking strategy or a different context ranking model—can be rigorously backtested using a structured evaluation suite.
This project aims to extend PySAL's spatial optimisation library (spopt) by implementing flow-based facility location models, specifically the Flow Refueling Location Model and the Deviated Flow Refueling Location Model. While spopt currently includes various node-based location optimisation models, it lacks flow-based models that are crucial for transportation infrastructure planning. The proposed implementation will include comprehensive data processing components for network and flow data, core optimisation model implementations with solver integration, and output processing tools for visualisation and analysis.
The iD Editor is a powerful tool used by thousands to contribute to OpenStreetMap, but its current session management system relies on localStorage, which poses several usability and technical challenges. With a small 5MB storage limit and synchronous behavior that blocks the main thread, users often face sluggish performance and occasional data loss. These issues become even more pronounced when users work across multiple browser tabs, where localStorage provides no real synchronization, leading to conflicts and inconsistent states between sessions. This project proposes to modernize session management in iD by adopting IndexedDB for efficient, large-scale, and non-blocking data storage. A key focus will be enabling real-time multi-tab editing support using the BroadcastChannel API to keep changes synchronized across tabs without clobbering data. The project will also improve crash resilience, ensure safe cleanup of resources using modern browser lifecycle events like pagehide, and introduce a graceful fallback for older browsers. Together, these improvements aim to make iD more robust, responsive, and aligned with modern web standards while keeping the editing experience reliable and smooth for all contributors.
Music Blocks and Turtle Blocks lack a structured version control system, making it difficult for users to manage project history, collaborate, and contribute effectively. This project aims to integrate Git-based version control, allowing users to track changes, fork projects, submit pull requests, and collaborate seamlessly. To achieve this, I will develop a backend API that interacts with GitHub or GitLab, enabling repository creation, commit tracking, forking, and merging. A user-friendly frontend UI will be implemented to provide an intuitive experience for project management. Deliverables: -A backend API supporting Git operations (repository creation, commits, forks, PRs, merges) -A frontend "Git Menu" for managing project versions, viewing history, and contributing. -A "Projects" page displaying repositories with commit history and branches. -Robust testing and documentation to ensure maintainability. -Initial user testing with community contributors and educators. The goal is to use GitHub as a back-end and database and use Git's powerful features to make learning more effective for students.
This project makes drone control easier by using a web-based AI assistant. Pilots can type or speak commands like “Arm the drone” or “Fly 10 meters north,” and the tool converts them into MAVLink messages for ArduPilot vehicles. It reimplements MAVProxy’s AI chat module as a modern WebTool, integrating the OpenAI API with JavaScript and WebSocket for Mission Planner connection. Development focused on core actions such as arming, takeoff, directional flight, and switching modes.
In order to make LFortran reach beta quality, it is essential to compile more benchmarked fortran codes. FPM(Fortran Package Manager) is one of the best example of such codebase. Successfully compiling FPM will make LFortran a more robust compiler and it will be a huge boost for LFortran to reach at beta quality. For this year's GSOC project, I am planing to compile FPM with LFortran. Since FPM depends on other 5 open source fortran codebases (toml-f, fortran-regex, fortran-shlex, M_CLI2, jonquil) , my plan is to compile those 5 small codebases till 1st month of coding period. To compile any code, my idea is to create workarounds that compile with LFortran till code compiles fully with LFortran, then create MREs for each workarounds and finally fix them and remove workarounds from original code. This way I will compile in order: toml-f, fortran-regex, fortran-shlex, M_CLI2, jonquil so that all dependencies are solved well. After completing these 5 codes, I will follow same process to compile FPM. Detailed weekly plan is discussed in my proposal. Deliverables: Compile toml-f, fortran-regex, fortran-shlex, M_CLI2, jonquil, FPM completely with LFortran.
This project aims to enhance QEMU's HP PA-RISC emulation by implementing LASI Network Card and NCR 710 SCSI Controller device models. LASI Network Card: Debug, test and complete the current Intel 82596 based implementation to provide full functionality NCR 710 SCSI Controller: Develop a new, accurate QEMU device model based on documentations present. Deliverables: Fully functional LASI Network Card and NCR 710 SCSI Controller models.
The project aims to build a real-time monitoring dashboard and terminal UI (TUI) for Crankshaft, a genomics workflow engine. Using gRPC for streaming and Ratatui for visualization, it will allow users to view live task statuses and logs directly in the terminal. The system will instrument task events (Queued, Started, Logs, Completed, Failed) without impacting performance and stream them efficiently. A stretch goal includes enabling job control (e.g., cancel tasks) through the TUI. The project will significantly improve observability and debugging in Crankshaft workflows.
The goal is to implement a functional GNSS receiver that uses INS measurements to improve the position, velocity and time solutions. This will advance research on sensor fusion, enabling reliable high-accuracy navigation solutions in challenging environments such as the urban cannon. I will leverage state-of-the-art AI techniques, such as Bayesian filters (e.g., Kalman filters and particle filters), graph neural networks (GNNs), and transformers for spatiotemporal data modeling. The end product will consist of a functional prototype receiver which will implement the necessary algorithms.
Weighted ensemble (WE) simulations enhance the exploration of a molecular system’s phase space by running numerous short, parallel simulations and selectively replicating trajectories that enter under-sampled regions. This approach improves sampling efficiency compared to traditional long, continuous simulations. However, a potential bottleneck arises from the need to analyze each iteration’s trajectories before starting the next round of simulations. Typically, this involves loading and processing trajectory data after each iteration, which can introduce significant delays due to disk I/O. To address this issue, my project focuses on integrating trajectory streaming into WESTPA using MDAnalysis. Instead of waiting for full trajectories to be written and reloaded for analysis, this implementation will enable real-time, on-the-fly analysis of simulation data as it is generated. By eliminating post-processing delays, this modification will streamline the weighted ensemble workflow.
This project aims to enhance fulldome content rendering in ossia score by integrating advanced ray-tracing render pipelines. Traditional fulldome rendering requires multiple render passes, which leads to high computational overhead. By leveraging ray-tracing techniques on modern graphics APIs (e.g. DirectX, Vulkan), this project will enable single-pass fulldome rendering, significantly improving efficiency and render quality. The project will explore and conduct comparative analysis on various rendering pipelines and graphics APIs, including HDR, meshlet-based, volumetric, and SDF-based techniques, with a focus on their suitability and performance for fulldome rendering within ossia score. Final Deliverables: [1] Integration of the ray-tracing fulldome rendering pipeline into ossia score for better performance and quality. [2] Systematic comparison and analysis of different ray-tracing fulldome rendering pipelines. [3] Open-source release of the codebase and benchmarking results of Deliverable [2]. [4] Documentation of rendering pipeline design, challenges faced, and solutions implemented. Mentors: Jean-Michaël Celerier and Manuel Bolduc
This document proposes a detailed architecture on how to implement the Audio Switchboard API. This idea enables numerous features, including translation layers and lightweight breakout rooms, as described in the idea page. This proposal introduces a metadata-based mechanism to manage audio streams. The implementation involves extending jitsi-meet to handle metadata, and Jitsi Videobridge (JVB) to handle signaling from senders and filtering requests from receivers. Senders attach metadata to their streams, such as spoken language or breakout room identifiers, while receivers specify criteria for the streams they wish to receive. JVB processes these inputs, filtering and forwarding only the matching streams.
I improved GNOME Crossword Editor's word suggestion algorithm, by re-implementing it as a forward-checking algorithm. Previously, our word suggestion algorithm only considered the constraints imposed by the intersection where the cursor is. This resulted in frequent dead-end word suggestions, which led to user frustration. To fix this problem, I re-implemented our word suggestion algorithm to consider the constraints imposed by every intersection in the current slot. This significantly reduces the number of dead-end word suggestions and leads to a better user experience. As part of this project, I also researched the field of constraint satisfaction problems and wrote a report on how we can use the AC-3 algorithm to further improve our word suggestion algorithm in the future. I also performed a competitive analysis of other crossword editors on the market and wrote a detailed report, to help identify missing features and guide future development.
Gemma is a lightweight, open-source large language model by Google DeepMind. This project aims to build an intuitive web interface for fine-tuning Gemma models. The interface will allow users to upload datasets, configure hyperparameters, monitor training progress, and export trained models — all without writing a single line of code. By lowering the entry barrier, the UI will empower a broader range of users to experiment with and adapt large language models to their specific tasks.
The proposed implementation is planned to include building the camera-based warning system, starting from the low-level driver implementation, creating necessary logic inside PipeWire nodes, training AI models for objects detection, and designing the suitable User Interface using Flutter. The final product would be a Warning System that leverages implemented inference models (e.g. Object Detection) and accordingly issues a visual alert in response to critical conditions, such as the detection of an object in the blind spot, or a very low time-to-collision.
At the end of Moore’s law, building domain-specific computer architectures is considered the next step in improving program efficiency. Hls4ml is an open-source project that translates machine learning (ML) models to high-level synthesis (HLS) code for deployment on hardware accelerators. The idea stems from the high-energy physics community at CERN. Google XLS (Accelerated Hardware Synthesis) is a novel framework that implements an HLS toolchain to produce synthesizable code for FPGA and ASIC applications. Thus, XLS can be integrated as one of the backends in hls4ml for transforming ML models into synthesizable code. The goal of this project is to integrate an XLS-based backend for the hls4ml framework. In doing so, hls4ml benefits from improved vendor compatibility and portability while also offering the potential to increase hardware efficiency. During development, we will benchmark performance and resource utilization against the existing backends (e.g., AMD Vivado, Intel Quartus). Furthermore, XLS provides a domain-specific language (DSL) called DSLX and an optimized compiler that can reduce compilation time. The expected results are an XLS backend prototype and benchmarks performed on various metrics for the synthesized code. Everything will be documented to facilitate use and future developments.
There is an available set of images for running Debian in Raspberry Pi computers (all models below the 5 series)! However, the maintainer severely lacking time to take care for them and called for help for somebody to adopt them, but have not been successful. The image generation scripts have bit rotted a bit, but it is mostly all done. And there is a lot of interest and use still in having the images freshly generated and decently tested! This project is about getting the [https://raspi.debian.net/ | Raspberry Pi Debian images] site working reliably again, and ideally making it easily deploy-able to be run in project machines.
smartmontools (smartctl) is a widely used tool for collecting SMART metrics from storage devices (SATA, SAS, NVMe). However, its runtime metadata file, drivedb.h, suffers from inconsistent labeling of attributes such as SSD wear, endurance, and temperature, which hinders meaningful monitoring and integration with observability tools like Prometheus/Grafana in environments such as Ceph clusters. This project proposed a two-part solution. First, I added interpretation logic in the smartmontools C++ codebase to normalize metrics (e.g., converting wear remaining to wear used as 100 - value) and expose them under a consistent JSON key. Second, I developed regex-based classification and drafted a standard spec to map freeform SMART attribute labels in drivedb.h to a consistent set. Together, these changes improve data reliability and facilitate integration with monitoring dashboards. Deliverables include: Interpretation logic enhancement in the smartmontools C++ source Regex-based normalization rules & classification Documentation of a SMART attribute label standard Test builds and reports from real SSD validation
The goal of this project is to address the challenge of checkpointing distributed applications, which generally run across multiple nodes with active TCP connections. While Kubernetes has recently introduced checkpointing support, it lacks a proper synchronization mechanism for distributed workloads, especially in managing network state during checkpoint and restore. To solve this, the project proposes to extend the existing criu-coordinator tool with support for network connection management via CRIU’s hook mechanisms. The work will involve implementing network-lock and network-unlock hooks, developing a pod-level network locking mechanism, and differentiating between internal and external TCP connections during checkpointing.
This project aims to enable testing of Guarded Control Stack (GCS) functionality within CRIU (Checkpoint/Restore In Userspace) on AArch64 by integrating the Armv9.4-A GCS feature into CRIU’s ZDTM test suite through a dedicated test case that confirms whether TPIDR2_EL0 is preserved and still readable in user space after restore. The project leverages recent upstream additions to glibc and Linux kernel that enable GCS support in user space, using Yocto and Arm's Fixed Virtual Platform (FVP) to emulate and test the architecture-specific functionality. This is a first step in exploring how CRIU might need to change to handle GCS systems, starting with test coverage Project Deliverables June 2 (coding begins) - GCS-enabled Environment Verified. Yocto + FVP setup is confirmed working. Compiling and running GCS-marked binaries with glibc tunables active. July 12-16 (Midterm Evaluation) - First GCS ZDTM test added. A basic test that reads verifies TPIDR2_EL0, and explores stack/register consistency across the restore boundary. Integration with --nocr working. Investigation of parasite.c and restorer.c to identify the point at which TLS or control state (e.g., TPIDR2_EL0) could be saved or restored. August 16-August 23 (Final Evaluation) - Full round-trip test of checkpointing and restoring a GCS-using process. All tunables, toolchain flags, and kernel glibc dependencies documented. August 31 (Final Results Announced) - Final cleanup and documentation. Tutorial-style instructions provided on how to replicate setup, test flow, and next steps. Post GSOC - I will remain available to support further maintenance, and help any future contributors pick up.
This proposal aims to build upon and expand the progress made in recent years on Quantum Vision Transformers (QViTs) for High Energy Physics (HEP) analysis. Specifically, the project will adapt and extend the state-of-the-art Particle Transformer architecture, which has already demonstrated excellent performance in jet classification tasks, by integrating it with quantum components.
In high-energy physics (HEP), automating the symbolic computation of squared amplitudes is essential for predicting cross-sections and validating theoretical models against experimental data. Current transformer-based approaches excel in sequence modeling but falter in capturing the relational structures and physical consistency required for HEP expressions, such as those involving gamma matrices and Mandelstam variables. To tackle this, I propose the Physics-Informed Performer (PIP), a novel framework that integrates the Performer transformer’s efficient kernel-based attention with a physics-informed tokenization scheme and a SymPy-based validation layer. This approach leverages Performer’s ability to handle long sequences, introduces tokens like <SQUARE> and <S> to embed HEP-specific operations and kinematics, and ensures symbolic accuracy through empirical post-processing. By focusing on data representation, PIP offers a computationally efficient alternative to traditional symbolic methods, tailored to the Task 1.2 dataset of amplitude-to-squared-amplitude mappings.