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.
This project aims to implement machine learning algorithms in JavaScript and C within stdlib, laying the foundation for a broader ecosystem of machine learning tools and supporting dependencies. The focus will be on ensuring consistency, accuracy, and efficiency across implementations. Deliverables include multiple machine learning algorithms, loss functions, distance metrics, and comprehensive documentation. Collectively, these contributions will help enable efficient execution of machine learning workflows on the web.
ScanCode-Toolkit relies on "required phrases" to prevent false positive license detections, but 74% of its rules currently lack this protection. To solve this, I am building an AI/NLP pipeline that automatically reads raw license texts and extracts the exact phrases needed to protect these rules. I have already built a working proof-of-concept, complete with a trained model and a live web demo that the maintainers can test right now. During GSoC, I will build this into a lightweight, production ready tool. My core deliverables include a highly accurate machine learning model optimized for offline use and a native Command Line Interface (CLI). This tool will automatically inject high-confidence phrases and provide an interactive "human-in-the-loop" review mode for edge cases, ultimately delivering a measurable reduction in real world false positives.
OmniFold produces per-event weights that cannot be reused without the original analysis environment. The original OmniFold paper deposited input datasets on Zenodo but not the learned weights, iteration metadata, or normalization contract, meaning independent reproduction requires rebuilding the full training setup from scratch. This project defines a publication standard to close that gap. The solution is a versioned metadata schema (YAML), a Parquet-based storage format for per-event weights, and a Python API for loading, validating, and applying published weights to compute observables. The package supports nominal weights, iteration metadata, and one uncertainty family as the required deliverable, with HEPData integration and extended systematics support as stretch goals. Deliverables: (1) formal schema specification with required and optional fields, (2) reader/writer package implementing the Parquet-based format, (3) validation tools covering schema compliance, normalization checks, and alignment integrity, (4) end-to-end reference example demonstrating export, reload, and observable reproduction, and (5) documentation and tutorial workflow. A working prototype with 17 passing tests is available at https://github.com/aashirvad08/omnifold-gsoc-eval.
The Goal of this project is to add the functionality to import and export OpenTimelineIO (.otio) files in Blender. OpenTimelineIO is an open-source interchange format and C++ API that represents an editorial cut as a structured, JSON-serialized object graph carrying precise cut information, media references, markers, transitions, and effects across non-linear editors (NLEs). With the ability to import and export .otio files in Blender, the artists would be able to work using different softwares on the same timeline keeping Blender in their production pipeline.
Stochastic simulation is essential in computational biology and infectious disease modelling, but existing methods require a trade-off between accuracy and computational efficiency. While exact stochastic simulation captures dynamics in small populations, it scales poorly, whereas deterministic ODE models are efficient but fail to capture stochastic effects. The Jump-Switch-Flow (JSF) framework addresses this by dynamically switching between stochastic simulation and deterministic ODE integration based on population size. However, despite a mature Python implementation, R remains the dominant language in epidemiology and biostatistics, creating a significant accessibility gap. This project will develop rjsf, an R package that provides user-friendly functions for running the Python `jsf` library directly within R workflows via reticulate. Key deliverables include a core simulation function, S7-based result objects, diagnostic and visualisation tools, a comprehensive test suite, and a detailed vignette, with the goal of CRAN submission. As a stretch goal, the project will explore incorporating additional intermediate stochastic simulation methods to further enhance flexibility and performance. The resulting package will enable researchers and scientists to seamlessly integrate hybrid stochastic-deterministic simulation into their existing R-based modelling workflows.
This project aims to develop a Julia module for simulating and optimizing Bell distillation circuits, addressing the challenge of selecting efficient entanglement purification strategies under varying noise and resource constraints. I will first construct a structured database of Bell distillation circuits with associated performance metrics. I will then design an optimization algorithm that selects the most suitable circuit based on inputs such as target fidelity, error rates, and resource availability. The project will include a simulation framework for evaluating circuit performance under configurable noise models. Deliverables include the circuit database, simulation tools, optimization algorithm, and a well-documented, user-friendly Julia product that integrates with existing quantum simulation workflows. This tool will enable researchers to systematically explore and deploy optimal distillation strategies, improving efficiency and accelerating experimentation in quantum computing.
This proposal aims to implement a functional cloud storage integration for VLC Media Player using libcloudstorage Although the open merge request (!7526) introduces basic components such as service discovery and access modules, testing shows that the integration is not usable due to issues in authentication flow, threading, and state handling. For example, authentication cannot be triggered properly from the UI due to preparsing constraints, and token persistence issues lead to repeated login attempts. This project focuses on completing and correcting the integration so that users can reliably browse and access cloud storage within VLC. The work includes restructuring the authentication flow to work correctly with VLC’s threading model, fixing token storage and session handling, and ensuring proper navigation after login. In addition, necessary updates will be made in libcloudstorage to address outdated API usage and improve compatibility with current cloud providers. Testing will be included to validate authentication, directory access, and overall integration stability. By the end of the project, users will be able to log in once, browse their cloud directories, and stream media files directly within VLC.
This project brings two new algorithms from the Boost Graph Library into pgRouting: planar face traversal and k-core decomposition. pgr_planarFaces extracts enclosed city block regions from planar street networks using Boyer-Myrvold planarity testing and BGL planar_face_traversal. The output integrates with PostGIS ST_MakePolygon to build polygon geometries directly from road topology. pgr_coreNumbers computes k-core decomposition using the Batagelj-Zaversnik algorithm, assigning each vertex a core number representing its connectivity level. Core 1 vertices are dead-end streets, core 2 are corridors, and core 3+ form the dense urban grid. Together they create a pipeline: pgr_coreNumbers prunes dead-ends before pgr_planarFaces extracts clean faces. Both run in O(V+E) linear time. If time allows, pgr_isKuratowskiSubgraph will extract the exact K5 or K3,3 subdivision causing non-planarity, completing the planar diagnostic toolkit. pgr_isPlanar is included as a standalone companion function.
Currently, the wild linker has limited support for linker scripts, which are commonly used in the Linux Kernel and embedded development. This makes it nearly impossible to use the wild linker for any Linux or embedded development. This proposal lays down a suggested path to try and implement most, if not all the major features requested for Linux kernel module support.
Time series forecasting is paramount in many domains, including finance, healthcare, energy, and climate science. This project suggests incorporating deep learning-based forecasting models—Informer, TCN, and DeepAR—into the aeon/tookit. The objectives are to construct an efficient and scalable framework for forecasting that accommodates top-performing models, is compatible with Aeon’s data management, and provides stable training, evaluation, and documentation. Through simplifying the availability of advanced forecasting software, the project would make it easier to utilize the toolkit to assist researchers with streamlined time series analysis.
This proposal seeks to extend the build system in Clang's driver to natively support module-based builds by leveraging Clang's existing support for scanning C++20 module dependencies between source files and adding support for generating the appropriate build steps.
The OpenPrinting ecosystem includes several utilities for driverless printing, protocol implementation, and printer management, including projects written in Go and Python. These polyglot projects currently lack fuzz testing, making them prone to undetected bugs and security issues. This project proposes integrating such polyglot OpenPrinting projects, namely ipp-usb, goipp, pycups, and pyppd, into OSS-Fuzz to enable continuous, large-scale fuzzing. The work will include evaluating current unit tests, improving coverage where lacking, identifying suitable fuzzing targets based on test coverage and risk, developing fuzz harnesses, and integrating the projects into OSS-Fuzz. This effort will help expand OSS-Fuzz coverage across OpenPrinting projects, further strengthening their overall security and reliability.
I propose to integrate native text tokenization support into OpenCV’s DNN module so that Large Language Models (LLMs) can be run end-to-end directly in OpenCV. Currently, to feed text into models like GPT-2 or GPT-3, users must rely on external libraries (e.g. tiktoken) for tokenization. My project will create a built-in tokenizer utility—implemented in C++ with Python bindings—that can convert raw text into token IDs and decode model outputs back into text. The core deliverable is a new cv::dnn::Tokenizer class supporting Byte Pair Encoding (BPE), along with the ability to load typical vocabulary/merges files and handle special tokens. Once implemented, this will allow a seamless pipeline for text-based or multimodal models within OpenCV: raw text -> tokens -> DNN inference -> tokens -> decoded text. I will also write comprehensive documentation and test this functionality against known tokenizer outputs (e.g., Hugging Face), ensuring correctness and good performance. By adding native tokenization, OpenCV’s DNN module becomes more versatile for cutting-edge AI tasks involving both vision and language. This reduces external dependencies, makes it easier to deploy LLMs in pure C++ or Python environments, and helps unify image and text processing in a single library—further strengthening OpenCV as a comprehensive open-source toolkit.
The Borg Collective offers essential Python-based backup tools like Borg, Borgmatic, and Vorta, which help users with secure, efficient, and reliable data backups. Vorta provides a user-friendly desktop GUI for Borg, while Borgmatic serves as a command-line interface for managing backups. This proposal outlines four projects designed to improve the functionality, security, and usability of both Vorta and Borgmatic. For the first project aims to add a new feature to the Vorta GUI that lets users change their repository passphrase. Changing a Borg repository passphrase is a feature that’s often requested but hasn’t been fully implemented yet within Vorta. This would make security management more accessible and eliminate the need for users to use Borg directly for such tasks. The second project aims to develop a custom file selector with PyQt6 FileDialog, which will handle multiple file and directory selections in one window. At the moment, Vorta has separate dialogs for selecting files and directories. This allows users to select both files and directories in a single window. The third project aims to introduce a much-needed improvement by adding a file selector dialog that allows users to pick files and directories to exclude directly through the UI. Right now, users who want to exclude certain files or directories from their backup have to manually type in paths or use patterns. This will allow users to eliminate the need for manual match expressions and reducing errors. These enhancements will make Vorta and user-friendly and feature-complete, ultimately improving the quality of backup process for users across different platforms.
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.