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 bring the power of Retrieval-Augmented Generation (RAG) into the Scala ecosystem by building a robust Scala interface to interact with RAG pipelines. I will design a Scala-compatible wrapper to connect with Python-based components like FAISS and Hugging Face Transformers via gRPC or HTTP APIs. The project will also include developing idiomatic Scala modules for preprocessing, querying, and evaluating textual data, making it easier for Scala developers to integrate RAG into NLP or search applications. By providing seamless interoperability and modular architecture, this will empower the Scala community to build intelligent, language-aware systems more efficiently.
TARDIS implements a regression testing framework which is used to compare the current output of TARDIS to a saved data repository to validate code. This data repository is modified at times when there are code/infrastructure changes in TARDIS, this could be environment updates, scientific code changes or more. However, the impact of smaller commits goes unnoticed. There is a comparison notebook implemented that can compare two different commits and spectra in a comprehensive manner but that does not provide a way to compare multiple commits at once. This project aims to build a system to compare the regression data produced by a range of TARDIS commits and will be able to find the commits which impact the regression data files. Also this project aims to enhance TARDIS HDF writing capabilities by adding a HDF writing system to most TARDIS objects and the simulation, so it is easy to reproduce TARDIS objects from stored HDF files.
In today's world sequential recommendation systems are used in various domains-- from life sciences to e-commerce and business. For example, within biology and ecology, recommendation systems help track a species behavior by suggesting research on migration patterns, and within e-commerce these systems are used to better a user's online experience. As such, recommendation systems are vital to systems today and is a important field of research. Despite widespread use, traditional sequential recommendation systems face limitations. They primarily on historical user interactions to predict future preferences however struggle to capture contextual dependencies and adapting to dynamic user behaviors. Similarly, existing models predefined embeddings which restrict the ability to adapt and generalize. As such these problems lead to reduced recommendation accuracy, typically for example in cold-start users. As such, the LLMSeqRec proposal will lead to a more personalized recommendation by interpreting and augmenting sequences with semantic context. Through this, LLMSeqRec can make up for the traditional difficulties-- making more accurate and adaptable recommendations personalized for each user.
DICOMHawk is a honeypot system designed to emulate a vulnerable DICOM (Digital Imaging and Communications in Medicine) server, primarily to detect, analyze, and understand malicious activity targeting healthcare infrastructure. This project proposes a set of enhancements aimed at improving its operational effectiveness, observability, and deployment experience. The plan involves integrating CanaryToken webhooks to enable deception-based detection of unauthorized file access, refining the logging system with structured and enriched logs to support real-time threat monitoring, and optimizing the Docker configuration to follow best practices for security, automation, and resource efficiency. These technical enhancements will be supported by thorough documentation, testing, and monitoring setup using tools like ELK stack. Together, these contributions aim to make DICOMHawk more robust, extensible, and easier to deploy while contributing meaningfully to the field of threat intelligence in healthcare cybersecurity.
Music Blocks has a feature to detect the color of pixels generated from drawing within the program, but it cannot detect the color of pixels from images that are either uploaded or from a webcam. By adding a feature to detect color from both uploaded images and a live webcam stream, users would be able to implement Lego music notation for the blind and similarly interactive programs. The goal of the project is to develop extended functionality to our existing tools of turtle/mouse glyph movement and limited color detection to sense color from uploaded images, as well as the real-time feed from a webcam. Upon successful implementation, the turtle/mouse glyph will be able to detect the color of pixels underneath it, regardless of whether those pixels were drawn by the turtle/mouse itself, part of an uploaded image stamped to the canvas, or part of a live webcam video feed into Music Blocks. One test of success is to run our Lego music notation for the blind project with a live feed. The result should be able to playback and record the abstract brick notation based on its contrasting colors.
NiiVue is a versatile tool for visualizing and handling neuroimaging data, but insufficient documentation creates friction in using it in deploying workflows. This makes it challenging for developers to integrate, reducing the usability of NiiVue. As demand grows for secure and efficient web-based processing, this project aims to provide a demo that helps developers implement and customize cloud providers and analysis tools for scalable, secure neuroimaging workflows. This project will develop a full-stack solution for scalable neuroimaging analysis, integrating client-side preprocessing with Niimath and visualization using NiiVue. A PostgreSQL database will be designed to manage neuroimaging tasks and results. Two backend approaches will be tested: one using Flask with Nipype to interface with neuroimaging tools like FSL and FreeSurfer, supporting parallel processing, and another using Flask with containerized neuroimaging tools managed via Docker orchestration (Kubernetes/ECS) for greater flexibility. The system will be deployed on AWS with secure infrastructure, including EC2 and S3, ensuring data security through encryption and access control. A minimal demo will showcase the workflow using FSL BET or FreeSurfer, accompanied by clear documentation for easy replication and deployment by developers with their own cloud provider.
The current logging system for Matrix communications at MeB relies on an unmaintained IRC-based bot (BrainzBot) that logs messages to a PostgreSQL database and displays them on chatlogs.metabrainz.org. While this system works, it uses outdated technology with known vulnerabilities, doesn't support many of Matrix's features and is no longer suitable as Metabrainz' primary communication platform. This project proposal replaces BrainzBot with a new archival service that archives messages directly from Matrix to HTML files and a PostgreSQL database. It will support Matrix features like message editing, reactions and media, and provide full text search over all messages. Both historical and new messages as they come in will be archived.
Lerobot is a framework for rapidly developing embodied intelligent robots, which includes classic imitation learning strategies such as ACT and Diffusion Policy, as well as low-cost robot hardware. It is necessary to combine it with dora. Recently, support for the SO-ARM100, a low-cost robotic arm, was added to Dora through its driver. However, there is currently no end-to-end tutorial available for using this arm. Tutorials and documentation are critical for making the project more accessible to new users. The goal of this project is to improve the Python-based tutorial for using the SO-ARM100 robotic arm with Dora-LeRobot, enabling users to easily get started and contribute to the ecosystem. Expected Outcomes: 1.Fix issues and add missing code so that Dora-LeRobot can be run with SO-ARM100 successfully. 2.Writing detailed setup and usage tutorials. 3.Implementing code for calibration, control, training, and inference. 4.Creating video tutorials and improve based on community feedbacks. 5.Creating test plan for user testing to ensure the tutorial is easy to follow. 6.Developing the Rust library for UR5 control. A well-documented, efficient, and effective Rust library that interfaces with UR5 robots through Dora.
Flamenco, whose target audience is small studios of artists and Blender users, could benefit by adding features that enhance the user-friendliness and speed up the workflow. The main features to be implemented for this project are: 1) a configuration editor page with simple form inputs that lets users visualize, edit, and save the settings directly to/from the YAML file 2) a mass deletion function for unneeded/unwanted render jobs and 3) UI-related bug fixes to improve the overall user experience.
Clang-REPL is an incremental compiler that enables interactive programming in C and C++, combining the flexibility of a REPL with the performance of compiled languages. Currently, users must manually load dynamic libraries when Clang-REPL encounters unresolved external symbols. This project aims to improve the user experience by implementing an Auto-Loading mechanism that automatically loads the required libraries when missing symbols are detected. In addition to auto-loading, the project will introduce Runtime Re-Optimization using Profile-Guided Optimizations (PGO). By collecting profiling information at runtime, Clang-REPL will be able to re-optimize initializers dynamically, leading to better performance without user intervention. Deliverables: 1. An Auto-Loading system that seamlessly resolves missing external symbols. 2. Runtime Re-Optimization support based on profiling data to improve execution performance.
Git currently relies on a global object the_repository and several global environment-related variables, which limits modularity and complicates long-term maintainability. This project aims to refactor Git’s environment handling by relocating global variables into more appropriate repository-specific contexts, primarily struct repository and struct repo_settings. However, some global variables are only relevant to specific subsystems. In such cases, instead of placing them in the repository structure, they will be moved into subsystem-specific contexts that better reflect their scope. Overall, the project will reduce global state and improve the maintainability and modularity of the codebase.
This project aims to improve the Text Tool in GIMP, enhancing the user experience by providing a more powerful and intuitive interface for editing rich text. The current system lacks flexibility and ease of use, especially for users who require advanced text formatting options. The updated tool will feature improved style management, better layout controls, and a more responsive editing interface. Additionally, users will be able to apply and preview formatting changes more easily, speeding up their workflow. The project will be developed in stages: design, implementation, testing, and documentation. The final deliverables will include an improved Text Tool interface, enhanced formatting and interaction capabilities making it easier for users to create and edit text elements in GIMP.
The Android build ecosystem includes a robust linting tool designed to detect Android-specific issues that general-purpose linters may overlook. Currently, Android Lint is not integrated into Oppia's Bazel-based build system. This project aims to bridge that gap by introducing a custom linting script that runs Android Lint independently of Gradle, with support for configurable exemptions via textproto files—ensuring alignment with Oppia’s existing scripting infrastructure. The project will proceed in two phases. The first will establish a foundational script that interfaces with Android Lint, handles exemption logic, and integrates with continuous integration workflows. The second will focus on resolving high-priority lint issues to improve overall code quality. The completed project will deliver a scalable and maintainable Android linting workflow tailored to the Bazel environment, enhancing code quality and developer productivity across the Oppia Android codebase.
This project enhanced SymPy's physics/control module by introducing two fundamental features. First, a robust method for symbolic stability analysis of continuous-time systems was implemented, based on the Routh-Hurwitz criterion, overcoming the limitations of previous purely numerical approaches. Second, support for discrete-time systems was extended with the development of the DiscreteTransferFunction and DiscreteStateSpace classes, which are fully integrated with existing interconnection functionalities.
ROOT's TMVA( Toolkit for Multi-Variate Analysis ) has SOFIE (System for Optimized Fast Inference code Emit) which offers a parser capable of converting ML models trained in Keras, PyTorch, or ONNX format into its own Intermediate Representation, and generates C++ functions that can be easily invoked for fast inference of trained neural networks. It is currently implemented for CPU inference along with a SYCL implementation. This project aims to explore different GPU stacks (such as CUDA, ROCm, ALPAKA) and implement GPU-based inference functionalities in SOFIE. Although there exist CPU implementations, working with HEP applications, need for GPU inferences become important. We will be writing optimized GPU Kernels for various operators such as RELU, GEMM, CONV2D, etc. that SOFIE already has for CPU implementation. Testing and experimenting which tech stack (such as CUDA, ROCm, ALPAKA) will be best aligned with SOFIE is our first goal. After getting to know about the pros and cons we can decide which one aligns with our goal. Our next aim would be to integrate all operators for GPU implementation in a incremental fashion ensuring each operator gets enough testing for edge cases. Once we have done basic implementation, we move on to optimizing thread-block config by using tools like Nsight for maximum performance. Once we have implemented our operators for the GPU stack, there is a need for performance benchmarking against popular frameworks like Pytorch/Tensorflow. Last part of the project would be extensive testing and benchmarking memory usage and execution time. I would end the project with proper documentation on how exactly to implement and scopes for further improvements.
Matchings and perfect matchings have received considerable attention in graph theory as well as in other related domains (such as, but not limited to, algorithms and optimization). There still remain many open problems — such as Barnette’s conjecture, Berge-Fulkerson conjecture, and so on — due to which it continues to remain an active area of research. At the heart of all this research lies the bottleneck of finding a maximum cardinality matching in undirected graphs. The objective of this project is to implement the Micali-Vazirani algorithm in SageMath — which achieves the best known theoretical runtime of O(|E|⋅√|V|) for computing such a matching — and to make all of this available freely to students, educators as well as researchers all across the world.
Apache Beam's test infrastructure is complex and difficult to manage manually. This project aims to improve resource management and security by introducing Infrastructure as Code (IaC) and automation tools. The main objectives are: - GCP Resource Cleaner: Identify and safely delete unused or orphaned cloud resources. - Terraform Modules: Define and manage Beam's infrastructure in a declarative, reproducible way. - Key Management Utility: Securely create, rotate, and audit service account keys. - Monitoring Tools: Enforce security policies and trigger alerts based on GCP audit logs.
Because of its cylindrical shape, the Compact Muon Solenoid (CMS) detector has intrinsic rotational symmetries. Data analysis can be greatly improved by taking advantage of these symmetries, especially in semi-supervised learning situations where labeled data is hard to come by. Using learnable rotation matrices conditioned on class labels or contextual information, this study aims to create a novel generative model that learns and applies rotational symmetry transformations to CMS data. Our goal is to find and utilize rotational symmetries by including this model into a GAN-like framework with a trained classifier. This will enhance data augmentation and model performance in semi-supervised CMS data processing.
This project aims to integrate the Sloan sparse matrix ordering algorithm from the Boost Graph Library into pgRouting, enhancing its capabilities for graph optimization for both undirected and directed graphs. The Sloan algorithm generates optimal vertex ordering that reduces profile and bandwidth of graphs, significantly improving the efficiency of matrix operations in network analysis applications. While pgRouting includes several matrix manipulation algorithms, it lacks specific matrix ordering algorithms like Sloan ordering that are essential for optimizing sparse matrices in network analysis. Current workarounds require users to export data to external tools, breaking workflow continuity. I plan to develop a new function pgr_sloanOrdering() with complete integration, comprehensive error handling, and support for both directed and undirected graphs. The implementation will leverage the Boost Graph Library's existing algorithm with careful adaptation to pgRouting's architecture. The project deliverables include a fully implemented Sloan ordering algorithm integration, comprehensive documentation and usage examples, an extensive test suite with performance benchmarks, and support for various graph types with configurable parameters. This project will benefit the community by expanding pgRouting's graph analysis capabilities, particularly for applications in transportation networks, utility network management, and scientific computing where matrix ordering significantly impacts computational efficiency.
InVesalius, a medical imaging tool, lacks user feedback during file loading and saving (e.g., .inv3 projects) and offers a basic, non-cancellable progress bar for volume rendering, frustrating users. This project aims to enhance usability by implementing a wxPython-based progress dialog with real-time updates and cancellation support. I’ll integrate this into invesalius/control.py and gui/frame.py, threading file operations (OpenPlistProject, SavePlistProject) and upgrading Volume.Render’s feedback with VTK-based stages. Deliverables include: (1) a cancellable progress dialog for .inv3 loading, (2) a similar dialog for saving, (3) a revamped volume rendering dialog with percentage updates, and (4) unit tests ensuring reliability. Built with Python, wxPython, and NumPy, this will make InVesalius more intuitive and responsive for researchers and clinicians.
Apache DataFusion is an in-memory query execution engine optimized for OLAP workloads using Apache Arrow's columnar format. However, to support queries that exceed available memory, DataFusion must spill intermediate results (e.g., from sort or aggregate operators) to disk. As a continuation of the community effort on external query execution, this project aims to improve the robustness of spilling execution and explore further performance optimizations including compression.
The Common Print Dialog Backends (cpdb-libs) library from OpenPrinting serves as a bridge between application print dialogs (like GTK, Qt, LibreOffice, Firefox, Chromium, etc.) and diverse print technologies (such as CUPS/IPP and cloud printing services). It decouples application UIs from backend print systems, enabling more flexible and rapid integration of new print technologies across all platforms. While it's natively written in C, bindings are required for other languages. Rust, known for its safety and concurrency advantages, currently lacks such bindings. This project aims to develop safe and idiomatic Rust bindings for cpdb-libs, enabling seamless integration of modern print backend capabilities in Rust-based applications.
As part of Google Summer of Code 2025 with VideoLAN, this project focused on integrating advanced audio features into VLC to significantly improve the user listening experience. To address inconsistent volume levels in media, I implemented a Dynamic Audio Normalizer by integrating FFmpeg's dynaudnorm filter, which intelligently balances quiet and loud sounds in real-time. To make VLC's powerful reverb effect more accessible, I also developed a user-friendly preset system for the Audio Spatializer. This feature replaces five complex sliders with a simple dropdown menu of common acoustic environments like "Auditorium" and "Great Hall," making a powerful tool easy for all users while retaining manual control for experts.
In this project, I aim to develop a fully fledged FM broadcast receiver application with integrated RDS and spectrum scanning. The application should be inviting to beginners and users will little or no background in Gnu Radio. It will also serve a purpose as a demo application which would allow potential users and beginners to see how Gnu Radio can build a production-grade application.