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 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.
This project proposes adding new features to Rimu.jl --- a Julia package that implements a random integrator for many-body quantum systems --- allowing it to read FCIDUMP files or directly use data from the ElemCo.jl package and construct a molecular Hamiltonian. This will provide users with the ability to obtain highly accurate data from quantum Monte Carlo simulations and exact diagonalisation for extensible models involving the electronic structure of molecules starting from readily available quantum chemistry data.
The aim of this project is to extend the functionality of GlobalRouting to Ipv6, while maintaining minimal code duplication. Global Routing is based on the OSPFv2 routing protocol and uses the Djikstra Shortest path algorithm to compute paths for a single area network configuration. The problem is that GlobalRouting doesn't work for IPv6, and that's a huge limitation. The goal of the project is to fix that limitation The general Idea is to convert the Ipv4 Classes to Generic Template Classes and Handle Ipv6 based Implementation differences using a combination of Type Traits and Compile time if statements. Deliverables include a working implementation of Ipv6GlobalRouting which handles different Address Types in Ipv6, while also maintaining Minimal Code Duplication.
This project aims to enhance the Robotics-Academy platform by porting selected exercises to native ROS 2, removing the need for the Hardware Abstraction Layer (HAL). The current implementation relies on a custom interface, limiting exposure to standard ROS 2 practices. By transitioning exercises like Follow Line and Basic Vacuum Cleaner to use native ROS 2 nodes, topics, publishers, and subscribers, users will gain hands-on experience with real-world ROS development patterns. The project will also ensure compatibility with ROS 2 tools like rqt_graph, ros2 topic echo, and rviz2 for debugging and visualization. Deliverables include: - ROS 2-native versions of two exercises (Follow Line and Basic Vacuum Cleaner) - Removal of HAL dependencies - Integration with standard ROS 2 tools and practices - Documentation and examples to help users build, debug, and run their solutions using native ROS 2 By the end of this project, Robotics-Academy will offer a more authentic ROS 2 learning experience, better preparing users for real-world robotics development.
The efficient computation of molecular integrals is crucial for large-scale quantum chemistry calculations to obtain the properties of the system. Gbasis is a free and open-source Python library for molecular property calculations using Gaussian basis functions, which are commonly used in quantum chemistry. It can evaluate various functions expanded in a Gaussian basis set, such as the electron density, as well as integrals over Gaussian basis functions. For all of these computations, a large number of complex integrals must be evaluated. Gbasis can compute various one- and two-electron integrals, but as the system size increases, these integrations become increasingly time- and memory-intensive. Screening is common in computational chemistry, and most codes use it to skip unnecessary integral evaluations. Currently, Gbasis applies screening only to overlap integrals. The aim of this project is to extend screening to other one-electron and two-electron integrals. By evaluating different types of integrals, a variety of properties such as the electrostatic potential, electron density, and its derivatives can be obtained. These evaluations are typically performed on a spatial grid, and screening for such grid-based evaluations will also be addressed in this work.
The project aims to improve Joomla's workflow system by enhancing its UI and functionality. The current workflow implementation is not intuitive, making it challenging for users to create, modify, and manage workflows effectively. The proposed solution includes a graphical workflow builder, predefined workflow templates, enhanced documentation, and thorough testing. The project will introduce drag-and-drop functionality, interactive flowcharts, and default workflow templates to streamline the process.
Currently, there is no plugin in MariDB that can generate vector embeddings. If the user wishes to store vector embeddings for a document, they have to use a separate solution and then manually insert them into the database. This is inefficient and complicates related pipelines. The goal of this project is twofold: 1. Create a function plugin that implements a function to query OpenAI’s API to generate vector embeddings for a given input. 2. Implement a concept of “expensive” functions in the MariaDB server. When expensive functions are used in stored generated columns, they should not be recomputed whenever possible (for example during ALTER TABLE commands). Instead, the old values should be copied to the new table, just like with regular columns For this project to be successfully completed, the goal would be to create a PR to MariaDB’s server repository that: 1. Implements a function plugin for generating vector embeddings via API calls to OpenAI 2. Introduces and implements the concept of “expensive” functions, to avoid recomputing them whenever possible 3. Ensures the quality of the newly developed features is up to standards, via appropriate testing and documentation
This proposal aims to an all-round enhancement to PictoPy by improving its backend scalability, frontend usability, and deployment accessibility. Key backend upgrades include implementing user-named face clusters, optimizing face clustering with dimensionality reduction, upgrading to YOLOv11 for better detection, adding GPU accelerated inferencing, and redesigning inefficient database schemas. On the frontend, a fresh modern UI using Radix UI will be introduced, along with a unified folder selection, an advanced search bar supporting face and object queries, object bounding box display, and user notifications. To ensure broader accessibility, the project will package and publish PictoPy on the Ubuntu Snap Store, Microsoft Store, and macOS Store, enabling seamless installation and updates. This will involve creation of CI/CD pipelines on the Github repository. Additionally, comprehensive documentation—including contributing guides, API references, and setup videos—will encourage new developers to contribute. These improvements will make PictoPy more user-friendly, scalable, and ready for widespread adoption.
This project aims to enhance Wi-Fi rate adaptation by integrating Deep Q-Networks (DQN) with the ORCA and RateMan frameworks. Traditional rate adaptation algorithms like Minstrel-HT struggle in dynamic wireless environments, especially in fast-changing conditions. By using machine learning, specifically DQN, the project will dynamically optimize Wi-Fi transmission rates based on real-time metrics such as SNR, RSSI, retry counts, and throughput. The system will be tested and compared against existing algorithms to assess improvements in throughput, latency, and packet loss. Deliverables include a fully integrated DQN-based rate adaptation model, detailed simulation results, and code contributions to the open-source community.
The MIFOS Payment Hub EE (PH-EE) is a microservice-based financial infrastructure requiring high availability, security, and resilience. However, systematic architectural testing—especially under failure and stress conditions—is currently limited. This project introduces an AI-driven testing framework designed to assess and improve PH-EE’s robustness by simulating faults, generating and analyzing synthetic logs, and applying machine learning models to detect anomalies and predict failures. Using tools like OpenTelemetry, Prometheus, Elasticsearch/Kibana, and Isolation Forest/Time-Series models, the framework will monitor service behavior, generate failure scenarios, and highlight weak points in system architecture. It will provide visual dashboards, anomaly tagging, and metrics to guide debugging and resilience improvements. Deliverables include: Architecture mapping and categorization of critical PH-EE components Synthetic log generation simulating realistic failure patterns Integration of AI-based anomaly detection models Dashboards and visualization for observability (Grafana, Kibana) A reproducible proof-of-concept and documentation This project will empower MIFOS developers and adopters with actionable insights to improve system health, scalability, and fault tolerance through intelligent architectural testing
PyGoat is an intentionally vulnerable Python web application designed to teach web security through hands-on practice. The project aims to modernize its architecture and improve the overall educational experience by providing a clean and user-friendly interface, isolating labs into Dockerized microservices, expanding coverage with real-world vulnerabilities, and showcasing secure coding practices alongside vulnerabilities.
My vision is to build Monumento, anopen-source, interactive platform for exploring and connecting around historical monuments. Users can contribute content, plan events, and engagethrough social features like feeds, profiles, and communities. I will enhance the user experience with personalized itineraries, dynamic monument highlights ,more social features and full device responsiveness. To expand Monumento’s reach, I will also develop a promotional landing pagethat highlights its unique features and value proposition, attracting a wider audience of travelers, history enthusiasts, and cultural explorers.