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.
During GSoC'24, a huge effort was made to improve Checkstyle's Google config coverage and updated our implementation of google style guide to the latest version ( 03 Feb 2022 ). but there's still a lot of work left. google_checks.xml is the configuration file where our google java style guide is implemented. Though most of the implementation work has been done and we have covered almost all the rules in google java style guide, users have reported a bunch of issues pointing out flaws in our implementation, these issues are labeled as google style issues, we need to solve them. On top of this, we have few rules which we are not able to completely follow/implement, they are marked with "Blue Tick" in our coverage page, we need to find a way to reduce such blue ticks rules and improve our coverage
Lima(LInux MAchines) is a tool that helps to run Linux Virtual Machines on macOS and other hosts, with a focus on running containers on them with auto file sharing and port forwarding. Lima's internal virtual machine backend drivers are tightly connected with the main binary, making maintenance difficult and cluttering the main binary. This makes it difficult to incorporate different virtual machine backends. This project seeks to construct and develop a plugin subsystem or framework that offers support for multiple virtual machine backends that can be integrated into the main Lima application via gRPC or built into the main binary.
The migration to Maven Central's new API instance has introduced significant changes, requiring specialized support in Gradle plugins for seamless publishing. This project aims to develop a new Gradle plugin compatible with the updated APIs, simplifying the process with Kotlin DSL extensions and automating tasks like GPG signing and artifact packaging. Deliverables include a fully functional plugin, comprehensive documentation, and robust test coverage.
The project focuses on improving the functionality and usability of key components in the Eventyay platform, specifically the talks, tickets, and video modules and integrating them into a cohesive, unified system. The goal is to streamline event management by ensuring consistent user experience, reliable data handling, and simplified admin operations. Work includes fixing existing bugs in the ticketing and talk modules, refining attendee and speaker management flows, and aligning data models across tickets, sessions, and users. The contributor will optimize database interactions, implement input validation and error-handling mechanisms, and enhance admin interfaces to allow efficient management of attendees, speakers, sessions, and video resources from a single dashboard. Additionally, integration tests will be written to ensure system stability and prevent regressions during development. The contributor will also provide updated documentation reflecting the improved workflows and interfaces. These efforts aim to create a maintainable, scalable platform that supports a seamless experience for both event organizers and attendees. As part of the ongoing development process, the project also includes maintaining the documentation for the unified platform. This involves ensuring that the deployment of documentation works correctly, keeping it up to date with recent changes in the system architecture, and revising content as needed to reflect new features and workflows.
Today, with Ubuntu increasingly adopting Snap packages, Uyuni currently lacks support for managing these applications. This project proposes adding native Snap support to Uyuni, including install, update, remove, and channel management. By extending Uyuni’s capabilities to cover Snap, this work fills a key gap and ensures continued relevance for Ubuntu system management. I explored how Uyuni manages CVE audits and package upgrades for Ubuntu systems. Initially, Uyuni connects to client machines via SSH to install and register the Salt Minion. Once set up, all communication occurs through Salt’s remote execution system, eliminating the need for SSH. Salt gathers package data using grains, pillars, and custom modules, which Uyuni then compares to its centralized SUSE Manager database. For CVE auditing, Uyuni fetches security metadata (e.g., CVEs, OVAL data) from upstream sources like Ubuntu Security Notices and stores it in a PostgreSQL database. When Salt reports installed packages, Uyuni analyzes the data and generates patch or upgrade recommendations. APT repositories are mirrored into structured software channels, allowing clients to receive updates without direct internet access. Building on this workflow, I propose extending Uyuni to support Snap packages. While Snap lacks structured CVE metadata, we can implement a version-based upgrade system: Uyuni retrieves the latest Snap versions from the Snap Store and compares them to client versions reported via Salt, suggesting upgrades when newer versions exist. To support airgapped environments, we can pre-download .snap and .assert files on a connected system and distribute them through Uyuni’s software channels. Additionally, to manage storage and stability, Uyuni admins can choose which Snap channels (stable, beta, etc.) to mirror—defaulting to stable. Deliverables: Support Snap auditing, lifecycle management, airgapped environments, testing/validation, and user documentation in Uyuni.
My GSoC 2025 proposal focuses on enhancing the "Transformed Cubic Grids" framework (Issue #264) within the QC-Devs organization by implementing adaptive quadrature methods. Current Becke-style molecular grids suffer from overlapping atomic grids, leading to redundant computations and reduced accuracy in quantum chemistry simulations. Building on prior work (Issues #7, #15, #96), I will develop algorithms to dynamically adjust grid points and weights based on integrand behavior, such as electron density, ensuring high accuracy with fewer points. My deliverables include refreshing and merging Pull Request #136, implementing adaptive methods (e.g., trapezoidal or Simpson’s rule with refinement), writing comprehensive tests and documentation, and creating Jupyter notebook tutorials for practical use in molecular property calculations.
Metagenomic assembly is essential for understanding microbial communities, but existing tools often struggle with fragmented genomes, misclassified errors, and scalability issues. My goal is to develop a distributed algorithm for error correction and assembly, making it easier to process large and complex metagenomic datasets efficiently. To achieve this, I plan to use distributed computing frameworks like Dask to improve scalability, ensuring that even terabyte-scale datasets can be handled smoothly. I also aim to design better error correction techniques to preserve low-abundance species and improve assembly accuracy. Additionally, I want to explore GPU acceleration and machine learning to refine error detection and optimize processing times. At the core of my approach is a distributed de Bruijn graph assembly algorithm that constructs graphs from k-mers while clustering and annotating nodes based on coverage, GC content, and paired-end data. Unlike existing tools like Velvet (designed for single-genome assembly) and MetaVelvet (for metagenomic assembly), my method will efficiently break down graphs into species-specific subgraphs, reducing errors and improving the quality of the final assemblies. This will lead to better contig generation, taxonomic classification, and error correction, while also ensuring the method scales well for large datasets. Deliverables: 1. A distributed error correction module that improves accuracy while retaining biologically important data. 2. An optimized assembly pipeline to generate high-quality contigs and scaffolds for taxonomic and functional analysis. 3. A novel species-aware de Bruijn graph decomposition to improve metagenomic assembly and reduce errors. 4. Scalability improvements to ensure smooth performance across HPC clusters and cloud platforms. 5. AI/ML enhancements to improve error correction and sequencing accuracy. 6. Comprehensive documentation and testing to make the tool easy to use and reproducible.
This project aims to address the challenge of text recognition from historical Spanish printed sources dating back to the seventeenth century, a domain where existing Optical Character Recognition (OCR) tools often fail due to the complexity and variability of the texts. Leveraging hybrid end-to-end models based on a combination of "Weighted CRNN architecture" and "CTC based beam-search decoding", this project seeks to develop advanced machine learning techniques capable of accurately transcribing non-standard printed text. The final objective is to create an "end-to-end solution/product" for users, to directly scan a page and obtain its transcription using a smart AI tool.
This project aims to build a CLI and TUI utility for easy WiFi and network management on the FreeBSD operating system. The base features for listing/configuring network interfaces, scanning, connecting/disconnecting from wireless networks will be implemented using libifconfig, with additional functionality added to the library as needed. The project aims to keep the dependencies to a minimal so that it can be suitable for inclusion into the FreeBSD base system. The CLI will include a REPL interface like iwctl, and a TUI like NetworkManager's nmtui will be built using terminal raw mode and control sequences, avoiding libraries like ncurses.
This project aims to automate metadata harmonization for cBioPortal, a widely used platform for cancer genomics research. Currently, metadata from different studies often uses inconsistent terms, limiting cross-study analysis and making it harder to apply AI/ML models effectively, while manual harmonization is time-consuming and not scalable. To address this, I propose building an automated metadata harmonization tool using fine-tuned biomedical sentence transformer models to semantically match and standardize metadata terms. The pipeline will include data preprocessing, semantic matching, low-confidence flagging, and expert validation, with interfaces to support expert review. The key deliverables are a fully functional metadata harmonization pipeline, semantic similarity models fine-tuned on curated biomedical data, a persistent vector database for scalable and reproducible retrieval, and documentation with testing coverage. This tool will reduce manual curation time by over 70%, improve metadata consistency, and enhance the platform’s readiness for AI-driven research.
This project aims to improve Git-based collaboration in JabRef by building a reliable synchronization layer for BibTeX files. It treats Git changes as edits from remote collaborators and introduces support for conflict detection, a guided merge UI, and safe synchronization workflows. Key deliverables include a modular GitSyncService, a conflict resolution interface, integration with JabRef’s save flow, and secure credentials management. The result will be a smoother, more collaborative experience for researchers using version control in their bibliography workflows.
The Unicode Inflection project currently provides its code in source form, which can be a challenge for users and developers who want a simple, ready-to-use solution. The goal of this project is to create automated, cross-platform packaging for the library, making it easier for users to install and use across Linux, macOS, and Windows. I will achieve this by utilizing CMake to streamline the build process, creating CMake-based scripts that can automatically generate compressed source and binary distribution packages for each platform. The final deliverables will include a set of tools to package the library and data files, along with clear documentation on how to build and distribute the packages. This work will improve accessibility for new users, save time for developers, and enhance the overall usability of the Unicode Inflection project.
High-fidelity detector simulations are critical for accurate analysis in particle physics, but traditional Monte Carlo-based methods are computationally expensive. DeepFalcon introduced a promising approach using Graph Variational Autoencoders (GVAE) that treat particle hits as graph nodes, enabling faster inference while maintaining high accuracy. This implementation used CMS Open Data of boosted top quark jets and considered only the ECAL layer of the detector, achieving a 400× speedup in reconstructing jets compared to traditional simulations. The model architecture employed GraphSAGE layers and mincut pooling, while training used Adam optimizer with a hybrid loss function combining MSE and KL divergence. However, the current approach is limited to single-layer detector responses and doesn't fully capture the correlations between multiple detector components. This project aims to extend DeepFalcon’s GVAE architecture to support multi-layer detector systems, specifically incorporating Tracker, ECAL, and HCAL layers simultaneously. The proposal is structured into two phases: Phase I will focus on enhancing the graph data representation by including all three detector layers and designing optimized connectivity patterns that capture spatial and inter-layer dependencies. Phase II will explore advanced pooling techniques and alternative message-passing strategies to improve latent representation quality and model generalization, while maintaining fast inference speeds. All components will be implemented using Python and relevant machine learning libraries such as PyTorch Geometric. Expected deliverables include a multi-layer GVAE model, benchmark comparisons against existing results, and detailed analysis of the architectural choices. This project contributes toward advancing fast simulation techniques in high-energy physics by enabling more comprehensive and scalable detector modeling.
The original proposal for this project focused on building a machine learning service to improve monitoring within the Seam and National Research Platform (NRP) environments. The goal was to analyze Prometheus metrics, detect anomalies proactively, and use NRP’s GPU and managed LLM resources to provide human-readable explanations and root cause analysis through Seam’s portal. This approach aimed to give the Seam/NRP community an intelligent tool for faster troubleshooting and more resilient operations. As the work progressed, and with the rapid growth of agentic AI approaches, the project shifted toward building an Intelligent Kubernetes Management and Observability System, inspired by the INFOGENT design. Rather than focusing solely on anomaly detection, the system was developed as a modular Python framework that integrates Kubernetes operations with large language model–driven explanations. It classifies user input as either an operational command or a documentation query, executes the corresponding action, and returns either the system output or a clear explanation drawn from NRP knowledge. The outcome is a practical, open-source framework that provides both command execution and AI-assisted guidance. It lowers the barrier for researchers working with Kubernetes, helps them understand and troubleshoot workloads more easily, and extends the Seam initiative by showing how agentic AI systems can enhance usability in high-performance computing environments.
Java PathFinder (JPF) is an extensible software analysis framework for java bytecode which can be used to check for concurrency defects like deadlocks, and unhandled exceptions like NullPointerExceptions and AssertionErrors. Symbolic PathFinder (SPF) is its extension that enables symbolic execution of java programs. This proposal outlines my plan to contribute to The JPF Team by working on the Support portfolio of solvers in SPF Project during Google Summer of Code 2025. The main goal of this project is to enable the simultaneous invocation of multiple constraint solvers, where execution halts as soon as any solver returns a satisfactory result. This approach is expected to enhance SPF's ability to handle a broader range of constraints. This Project will extend SPF branch sv-comp. The outcome will enhance SPF’s scalability and applicability in symbolic execution tasks.
This project aims to enhance both user and contributor experiences for the Resonate App by implementing critical quality-of-life features, improving accessibility, and preparing it for public release. To achieve this, the following deliverables are planned: 1. Make the app fully responsive by replacing fixed dimensions with LayoutBuilder and Flex widgets for a consistent UI across devices. 2. Stabilize the codebase and prioritize deployment of Resonate v1.0.0 to the Play Store and App Store. 3. Implement automated testing in Flutter targeting 90%+ code coverage to prevent regressions and ease PR reviews. 4. Set up CI/CD pipelines to automate deployment on updates to the main branch. 5. Complete the partially implemented Text Chat feature and add in-app notifications. 6. Add Internationalization (i18n) to support multiple languages. 7. Improve the Pair Chat experience by allowing users to select who to chat with from a list. 8. Expand the Search functionality to include Creators and Users, and introduce a "Follow Creator" feature. 9. Add a Friends System to enable one-on-one calls. 10. Introduce TTS and STT features in audio rooms for accessibility to non-verbal users. 11. Add Host Controls using the LiveKit API to allow moderation in rooms. 12. Enable creators to start Live Chapters, which will be recorded and uploaded automatically. 13. Replace current Appwrite search queries with Meilisearch to support scalable and advanced search capabilities. 14. Conclude the project with final testing, merging of features, and deployment of Resonate v2.0.0. This project will ensure Resonate becomes production-ready while staying contributor-friendly and inclusive for all users.
Open WebUI is a very popular component that provides a user interface to generative models. It supports use cases related to text generation, RAG, image generation, and many more. It also supports integration with remote execution servings compatible with standard APIs like OpenAI for chat completions and image generation. The goal of this project is to integrate Open WebUI with OpenVINO Model Server. It would include instructions for deploying the serving with a set of models and configuring Open WebUI to delegate generation to the serving endpoints.
This project modernizes the classic Kennedy Approach air traffic control game by rebuilding it as a custom, multi-screen interactive experience on the Liquid Galaxy platform. Rather than emulating the original Commodore 64 version, the game is being ported from scratch, allowing for enhanced features and seamless integration across multiple synchronized displays. The system is designed around a master-slave architecture, where the master node handles game logic and display rendering. The visual output is split and distributed to multiple slave nodes on the network, creating a panoramic and immersive gameplay view across multiple screens using the Liquid Galaxy setup. Players interact with the game using a mobile controller app built in Flutter, which communicates with the master system over a local network. A Node.js backend on the master node manages incoming control commands via WebSockets/Socket.IO, ensuring smooth, real-time interactivity. Optional UI dashboards built in React or Next.js can be used for monitoring system status, visualizing live data, or enabling multiplayer interaction.
This project aims to make Tölvera more accessible to artists and researchers by adding a Natural Language Interface (NLI). Currently, Tölvera's reliance on Python coding presents a barrier for those without programming expertise. This project will refine and substantially extend tv.llm, a functional proof-of-concept NLI module, enabling users to generate and modify Tölvera sketches using natural language commands. The core work of this project involves expanding the NLI's architecture, which utilizes Pydantic for configuration validation and Jinja2 for reliable code generation, to encompass a broader range of Tölvera modules (tv.vera, tv.osc, tv.cv, tv.mp, tv.iml), refining prompt engineering strategies, and improving the command-line interface. Deliverables will include the full release of the tv.llm module integrated as a core Tölvera feature, detailed documentation, and an evaluation report. The goal is to help empower a broader community of users to integrate Tölvera into their creative workflows.
This project aims to develop Quarto notebooks as an accessible yet flexible interface for running PEcAn workflows, bridging the gap between the limited web-based UI and the more advanced API or R script methods. It will create workflow templates that cater to both new and experienced users. To support adoption, the project will also produce a written vignette demonstrating their use.
Seeing the current increasing demand of high performance batteries, accurate thermal modelling of battery behaviour is essential. This project extends PyBaMM by adding the capability to simulate battery temperature in three dimensions. It starts by developing 3D meshes (box, cylinder etc) and FEM method. Then we develop a 3D thermal model for batteries, initially assuming a constant heat source. This thermal model is then coupled with existing battery models (like the SPM or DFN) so that the heat generated during battery operation can be simulated. The model will also eventually allow temperature data from the thermal simulation to feed back into the battery model, enabling more realistic, two-way interactions.
State-space models (SSMs) provide a flexible framework for modeling dynamic systems where latent states evolve over time. In econometrics, Dynamic Factor Models (DFMs) are widely used to capture the co-movement of multiple time series by assuming that a small number of latent factors drive the observed variables. The PyMC library already includes implemen- tations of SARIMAX, VARMAX, and structural state-space models, along with example notebooks for their usage. This project aims to extend the existing PyMC state-space module by implementing Dynamic Factor Models, aligning with the functionality available in statsmodels. Our implementation will follow a Bayesian approach, leveraging PyMC’s probabilistic programming framework and PyTensor for computation. Additionally, an accompanying example notebook will demonstrate estimation, forecasting, and causal analysis with the new model, ensuring accessibility for users. This enhancement will significantly expand PyMC's capabilities, empowering student, practitioners and researchers in econometrics, macroeconomics, and beyond to model complex time-series data probabilistically.
Problem: IP cameras are frequent targets for cyberattacks due to their widespread use and often weak security. Current honeypots like SweetCam lack comprehensive protocol support and realistic emulation, limiting their effectiveness in detecting and analyzing threats. Solution: This project aims to transform SweetCam into a versatile, multi-protocol honeypot by: 1. Expanding protocol support for RTSP and ONVIF, enabling deeper interaction with attackers. 2. Introducing template-based device emulation using YAML to simulate real-world cameras (e.g., Dahua, Hikvision). 3. Improving usability with Docker enhancements, automated configuration, and a realistic HTTP interface featuring error simulation and multi-language support. Deliverables: 1. A production-ready SweetCam with RTSP/ONVIF support and 5+ device templates. 2. Optimized Docker deployment (multi-stage builds, Compose profiles). 3. Enhanced HTTP interface (login flows, error simulation, i18n). 4. Comprehensive documentation, including setup guides and protocol specifications. Impact: This upgrade will equip researchers and defenders with a powerful tool to study attacker behavior, improve IoT security, and contribute to the broader honeypot ecosystem.
Jupyter Notebooks provide a powerful, interactive environment widely used by data scientists and ML engineers for exploratory analysis, visualization, and prototyping. However, as the scale and complexity of data workloads grow, running computations locally within notebook pods becomes inefficient and limiting. The Batch Processing Gateway integrates with Kubeflow Spark Operator to manage the full lifecycle of Spark applications in a cloud-native environment. It enables distributed computation at scale and automates job deployment, resource management, and status tracking using Kubernetes Custom Resource Definitions (CRDs). This project proposes integrating Jupyter Notebooks and the Batch Processing Gateway, enabling it to manage the notebook kernel lifecycle of remote Spark kernels as distributed Spark applications. This decouples computation from the notebook pod and scales Spark workloads efficiently in Spark. To achieve this, we will introduce Batch Processing Gateway to manage the lifecycle of Notebook kernels and introduce Jupyter Enterprise Gateway (JEG) for runtime communication to enable Jupyter messaging protocol for notebook cell execution during runtime.