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 addresses the challenge of accurately digitizing degraded 17th-century Spanish manuscripts, which suffer from irregular layouts, archaic grammar, and low scan quality. The solution integrates a hybrid OCR pipeline: a Mask R-CNN model segments text blocks into lines, a fine-tuned TrOCR transformer recognizes printed/handwritten text, and a T5 + LLM hybrid system corrects errors while preserving historical grammar. An open-source annotation tool enables historians to validate outputs and expand datasets. Deliverables include: (1) a production-ready OCR pipeline, (2) post-correction module with fallback strategies, (3) annotation tool for dataset refinement, and (4) comprehensive documentation. This tool will enable scalable, accurate digitization of cultural heritage texts.
This project will aim to create an LLM module within Mesa that enables the use of large language models as autonomous agents, via mesa.llm. This module will extend Mesa by providing tools to define, simulate, and analyze agents powered by large language models.
I’m building a tool to make working with Kro YAML files easier and more efficient. This tool, called a Language Server Protocol (LSP), will help developers by giving real-time feedback, catching errors early, and suggesting code completions. It will also make code more readable with better syntax highlighting and helpful pop-ups. The LSP will support popular code editors, starting with VS Code. I’ll also include clear instructions and examples to help users get started. My goal is to make writing and managing Kro YAML files faster and less error-prone, so developers can focus on their work without getting stuck on small issues.
Graph Neural Networks (GNNs) are powerful tools for processing graph-structured data, with applications spanning social networks, recommendation systems, molecular modeling, and beyond. The Julia package GraphNeuralNetworks.jl, based on Flux.jl, provides access to common graph convolutional layers, offering a flexible framework for building GNN models. Sparse computations are essential for the efficient implementation of GNNs, since many operations, such as propagating node features, can be expressed as the multiplication of a sparse adjacency matrix with a dense feature matrix. Improving these operations through enhanced GPU kernels and fused operations is critical to reducing memory overhead and increasing the overall performance. This project aims to address these limitations by enhancing CUDA.jl’s sparse matrix support and integrating these improvements into GraphNeuralNetworks.jl, ultimately enabling faster and more scalable GNN computations in Julia.
Graphite currently offers only a limited set of shape tools with basic gizmo support, limiting the scope of creative and precise editing. This project aims to enhance the Polygon Tool by introducing a variety of predefined shape nodes—such as Trapezoid, Star, Donut, Pie, Crescent, and more—each equipped with custom, interactive gizmos. To manage these features, a centralized Gizmo Manager will be developed to handle both general transform cages and shape-specific gizmo points. These gizmos will integrate with the Select Tool using a state-driven interaction model to enable intuitive, fine-grained shape manipulation. Each shape will expose unique transformation controls (e.g., adjusting edge curvature, radii, angles, and segment lengths), allowing users to craft complex designs efficiently.
BeagleMind is an AI-powered documentation copilot for BeagleBoard that uses Retrieval-Augmented Generation (RAG) and tool calling to assist contributors and developers. The assistant retrieves precise, context-aware answers from a vector database built from official BeagleBoard documentation, ensuring accurate and citation-backed support. With integrated tool-use capabilities, it can help users explore documentation, generate code, and automate development tasks. The MVP will be released as a Python package on the Python Package Index (PyPI), providing a lightweight command-line interface for seamless access. By streamlining access to technical knowledge and tools, BeagleMind will reduce friction in the development process and empower the BeagleBoard community.
This project enhanced Stingray.jl, the Julia-based implementation of the Stingray library for X-ray timing analysis in high-energy astrophysics. Starting from my childhood passion for astronomy, GSoC allowed me to contribute to real astronomical research tools that analyze signals from stars and X-ray telescopes. Technical Journey & Contributions: Beginning with learning Julia from scratch and understanding astronomical data formats through NASA HEASARC documentation, I implemented core functionality across multiple areas: Event Data Processing: Developed comprehensive read events functionality supporting .evt and .fits files from telescopes like NICER, including GTI (Good Time Intervals) handling, energy filtering (filter_energy), and metadata extraction. This enables astronomers to process millions of X-ray events efficiently. Light Curve Analysis: Built complete lightcurve workflows from raw telescope data to scientific plots, including creation, error handling, rebinning, and intuitive plotting recipes allowing simple plot(lc) commands. Spectral Analysis: Implemented Power Spectrum and Averaged Power Spectrum analysis for both binned and unbinned data, with multiple normalization options (Leahy, fractional, absolute) and comprehensive visualization capabilities. Cross-Spectrum Analysis: Tackled the most challenging component - Cross-Spectrum and Averaged Cross-Spectrum implementation for studying phase lags and time delays between different energy bands. This contribution includes advanced plotting for amplitude, coherence, time lag, and phase lag analysis. The project transformed my understanding from basic stargazing to sophisticated astronomical data analysis, creating tools that real astronomers will use to unlock the mysteries of the universe.
This project develops an open-source, diffusion-based super-resolution (SR) pipeline for enhancing the resolution of gravitational lensing images. High-resolution lensing data is often limited, and the project also aims to create a synthetic benchmark dataset of paired LSST-like low-resolution and Roman-like high-resolution images. The developed pipeline will be compared against state-of-the-art SR approaches, with an analysis of their respective strengths and limitations. This project lays the groundwork for future applications of SR in downstream tasks such as classification and regression of lens properties. Deliverables include: - a synthetic benchmark dataset of paired low- and high-resolution gravitational lensing images; - a diffusion-based pipeline for SR; - comparative analysis of SR techniques on the benchmark dataset; - open-source code base and final report.
The Gemini API, known for its multimodal capabilities and efficiency, is a powerful tool that enables advanced AI agent interactions. However, its integration within open-source software (OSS) tools like LangChain and LlamaIndex is limited by gaps in functionality and documentation. LangChain and LlamaIndex, two frameworks designed to streamline the development of LLM-powered applications, will significantly benefit from enhanced Gemini API features. This project aims to enhance Gemini API integrations in these tools by implementing high-priority features that unlock its full potential. Key improvements include dedicated support for structured output, tool calling with Union types, and resolution of the code execution bug in LangChain, as well as context caching, search grounding, and code execution features for LlamaIndex. In addition to these features, I will update Gemini-specific documentation and create practical workflows to make these tools easier for developers to adopt. By addressing these challenges and engaging with the OSS community for feedback, this project will increase Gemini API adoption and empower developers to create powerful, scalable AI agents. The final deliverables include six new features, updated documentation, example workflows, and a community engagement report.
Synopsis: Support WebRTC-HTTP ingestion protocol for FFmpeg but do minimal changes to current code. Support basic ICE candidate exchange and basic DTLS handshake. Deliverables: 1. Research and understand RFC9429 and related WebRTC/WHIP specifications. 2. Add new file named whip.c in libavformat as muxer 2. Implement basic ICE interaction in FFmpeg. 3. Add minimal DTLS support for WHIP. 4. Modify RTP/RTCP workflow to support WHIP. 5. Develop tests and documentation.
This project aims to improve Animint2 by, enhancing grid layouts for ggplot2 to simplify plot arrangement, porting the Animint gallery from NAU rcdata to GitHub Pages while resolving existing issues, migrating tests from selenium to chromote for a modern testing framework. If time permits, I’ll also work on replacing RJSONIO with jsonlite, adding code coverage via GitHub Actions using covr and V8.
This project aims to implement some new language features introduced in Fortran 2018 and Fortran 202x, enhancing gfortran's compatibility with newer Fortran standards.
This project aims to create a benchmark dataset for tree species classification using multi-sensor airborne data (RGB, HSI, and LiDAR) from the National Ecological Observatory Network (NEON). The goal is to build a reproducible, well-documented dataset of hand-annotated tree crowns and use it to train baseline models for each modality individually and in combination. Alongside this, we’ll explore integration with DeepForest to support crown detection and classification workflows. Deliverables: 1. A finalized, curated data product for tree species classification using NEON data added to TorchGeo. 2. Baseline models for each modality and multi-modal combinations. 3. Reproducible training pipelines and clear documentation. 4. A utility to simplify NEON data access. 5. Integration work and documentation linking this effort with DeepForest.
This project aims to modernize Webpack by implementing comprehensive support for ECMAScript Modules (ESM) output. Webpack currently lacks robust ESM output capabilities, creating challenges for developers working with modern JavaScript. The implementation will focus on four key areas: parser and module analysis enhancements to detect strict mode compatibility issues and identify statically exportable modules; code generation improvements to properly transform CommonJS to ESM exports; runtime optimization to eliminate unnecessary boilerplate; and platform-specific feature support for CSS modules, URL handling, and ESM workers.
This project aims to enhance the multi-agent traffic debugging tool in Open-RMF's site editor for stress testing the multi-agent path finding (MAPF) package that is used to route multi-agent traffic for real world deployments. The site editor will be used to generate a wide variety of test cases, including complex scenarios such as two-endpoint corridors and T-junctions that require careful robot coordination to avoid deadlocks. The mapf library will then be used to simulate the planning results. This enhancement would allow users to visualize the per-iteration output of the MAPF solver to identify identify scenarios where the solver fails to produce an output or gives inconsistent results. Based on these insights, improvements to the mapf framework can then be made accordingly.
In moderated usability testing sessions, moderators often need to revisit specific points mentioned during the session. Without clear markers, this typically requires replaying the entire video recording, which is time-consuming and inefficient. Providing task-based transcriptions of these sessions significantly streamlines the review process. However, such transcriptions allow moderators to quickly locate and focus on relevant parts of the session, enabling them to reflect, annotate, and derive insights more effectively. Furthermore, these transcripts can be easily shared with collaborators, facilitating collective analysis and deeper understanding of user behaviors and challenges encountered during the session.
JNIgen enables the generation of Dart bindings for Java/Kotlin libraries, but writing equivalent Dart code to interact with these bindings remains challenging due to language differences. This project focuses on automating the translation of Android (Java/Kotlin) docs snippets into JNIgen-compatible Dart code using a Large Language Model (LLM). It makes Android documentation more accessible to Dart developers, allowing them to directly use and experiment with examples in their projects.
The project addresses the rising energy consumption of ML workloads in high-energy physics (HEP) at CERN. While models like Baler and ATLAS top taggers are essential for real-time data processing at the LHC, they impose significant carbon and energy costs. This proposal introduces GreenML@CERN, a holistic framework for optimizing the energy footprint of scientific ML workflows. The solution combines cross-architecture energy profiling (GPUs, CPUs, TPUs), scheduler efficiency analysis (HTCondor, Kubernetes), algorithmic optimizations (quantization, pruning, dynamic training), and an automated Jupyter-based energy profiler with a real-time dashboard. Deliverables include energy-optimized versions of CERN ML models, benchmarking datasets, a profiling toolkit, and visual dashboards. The project extends CERN's ongoing GreenDIGIT sustainability efforts with developer-focused ML tools to help the community balance performance with energy awareness—contributing directly to CERN’s 2030 carbon neutrality goals.
The goal of this project is to integrate pitch-correction into Blender's video sequence editor (VSE). While the editor supports retiming video and audio through the retiming keys, one particular feature that is missing for audio clips is being to preserve the original pitch of the audio when it is sped up or slowed down. So, this project will add a "Pitch Correction" toggle option to the audio strips in the editor, allowing the audio to retain its natural tonal quality if retimed.
This proposal addresses the lack of debugging tools for pocketpy, a lightweight Python interpreter for game scripting. It will develop a VSCode debugging extension along with Debug Adapter Protocol (DAP) support. The solution includes a debugger core that integrates with pocketpy's interfaces to support breakpoints, variable inspection, and call stack visualization, paired with a VSCode extension providing an intuitive debugging interface. Deliverables include a DAP-compatible debugger core, a VSCode extension with debugging configuration capabilities, and APIs for runtime inspection of variables and stack frames.
The Large Hadron Collider (LHC) particle track reconstruction faces increasing computational demands, driving exploration into novel methods like Quantum Computing QC. However, evaluating these requires assessing factors such as performance and sustainability. This project aims at developing a modular Python benchmarking framework to systematically compare classical algorithms e.g., Neural Network based against quantum approaches e.g., VQC simulated via PennyLane for tracking tasks using TrackML dataset. The framework will evaluate algorithms based on physics performance efficiency, purity, computational cost runtime, memory, quantum resource requirements gates, depth, and sustainability indicators simulated/projected energy consumption. The key deliverable is the framework itself, providing the community with a tool for quantitative comparison, understanding performance/sustainability trade-offs, and informing future directions in deploying potentially sustainable computing solutions for High Energy Physics.
The goal of this project is to enhance the Volesti library by implementing a sparse variant of the Billiard Walk sampling algorithm, which proposes to leverage lazy Cholesky-based solutions in order to preserve sparsity during rounding and sampling operations. Taking advantage of the sparse linear algebra infrastructure already present in the library, this project aims to improve the computational performance by implementing new methods that will perform dynamic, on-the-fly operations directly through triangular solves, avoiding explicit dense matrix transformations.
The proposed project aims to develop Spicy-based protocol parsers for HTTP and DNS. Although Go is an efficient language used for system programming and network tasks, it requires a more hands-on, step-by-step approach to parsing. This means dealing with the intricate details of state machines, binary data, and protocol-specific rules. On the other hand, Spicy uses a higher-level, declarative style that simplifies these complexities, letting us focus more on understanding the protocol itself.
The project will develop the first version of an app that uses Bluetooth to connect with heart-rate and respiration sensors, calculate metrics of synchronization and variability based on these measurements and implement a biofeedback protocol to control this variability. This will allow the study of autonomic nervous function, and will allow biofeedback protocols for mood and health intervention to be implemented via live tracking of breathing and heart-rate. I plan to use the available open source code which is in python and re-write the modules in dart using the pub dev packages.