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.
Problem Statement: The current MyUoM app for Greek universities is a central hub for students and faculty, but it's missing some key features. Right now, it lacks a solid login system, a scalable backend, and real-time updates from official university sources. Plus, there’s no easy way for other universities to customize or integrate the platform to fit their needs. This makes the app less flexible and limits its potential to be a truly unified solution for higher education in Greece. Proposed Solution: I’m proposing MyUni—a unified, open-source platform that fixes these headaches. Built with a modern MERN stack (Next.js, Express.js, MySQL), MyUni will offer a scalable backend, real-time data syncing via APIs, and a flexible CMS for announcements and updates. It’ll support multiple universities with customizable branding and layouts, all wrapped in a user-friendly interface. Using TypeScript, microservices, and tools like Nginx and Redis, I’ll ensure it’s fast, secure, and ready to grow. Deliverables: By the end of GSoC 2025, I’ll deliver: - Web application that provide good user experience(UX) and has good User Interface(UI). - Admin dashboard where myuni admin can able to handle CMS and more. - Student dashboard where student can able to take-care of their profile, notifications of academics, and more. - Backend Architecture which serves as solution to all project requirements. - REST APIs with at least 95% test coverage. - REST APIs with modern design patterns. - Docker container image of entire app.
This project will develop the core execution engine for Music Blocks 4, an educational platform that helps students explore music, mathematics, and programming through block-based coding. The Program Engine will allow users to create musical programs by arranging visual blocks and then execute these programs to generate music with precise timing. I will implement a robust Abstract Syntax Tree (AST) representation of programs, an interpreter that executes block instructions, a state manager to track variables and program state, and a scheduler for time-based musical operations. Key deliverables include a complete execution system for basic programming constructs, music generation capabilities, concurrent execution for multi-part compositions, and comprehensive error handling to provide clear feedback to users. The end result will be a performant, reliable foundation that enables Music Blocks users to create, share, and learn through interactive musical programming, with special attention to educational use cases and accessibility.
ProLIF, a tool for identifying protein-molecule interactions in molecular dynamics trajectories, lacks a straightforward method for evaluating hydrogen bonds when only heavy atoms are present. Many users usually compare experimental and computational structures without explicit hydrogens, but the existing protonation tools are cumbersome and error-prone for beginner-level programming users. This proposal introduces an "implicit hydrogen bond (H-bond) interaction method" directly using heavy atom positions to detect H-bonds. The goal is to strike a balance between efficiency and accuracy and increase ProLIF's usability. The method will leverage distance-based calculations with geometrical constraints, similar to Mol* and Chimera, and incorporate a confidence score based on AutoDock Vina's hydrogen bond term. Standardizing residue names from various force fields (CHARMM, AMBER, GROMOS, OPLS-AA) and assigning their associated protonation/hybridization states will be crucial for the new "Protein helper function” before the H-bond detection. Lastly, I plan to use the PINDER and PLINDER datasets (protein-protein and protein-ligand interactions, respectively) to validate the implicit H-bond interaction method by comparing the results from the standard H-bond method.
Mixxx uses a linear interpolation when scratching. This is blazing fast, but the sound can be improved by providing more accurate resampling techniques. This project involves a review of the currently used resample libraries RubberBand and Soundtouch and a comparison with other candidates. The one with the best Sound/CPU load trade off shall be selected. Another key requirement is supporting on the fly changing of the sample rate without artefacts. This project may also involve contributing a missing feature to an existing resample library. https://github.com/mixxxdj/mixxx/issues/9328
This project aims to develop a Python library that abstracts multiple RDF triplestore systems into a unified, developer-friendly interface. By standardizing how applications interact with different SPARQL backends, the library will simplify the use of semantic web technologies and promote greater flexibility in backend selection. The work will involve comparative research on triplestore architectures, performance benchmarking, and the design of an extensible abstraction layer. Deliverables include a well-documented codebase, performance analysis, and integration of four triplestore systems, supported by real-world testing and usage examples.
etcd is a distributed key-value store that serves as the backbone for Kubernetes and other cloud-native systems, storing critical configuration and state data. However, at scale, multiple applications constantly querying etcd for current state and watching for changes can overload the server and create expensive catch-up scenarios for slow subscribers. This project developed an experimental caching solution that brings Kubernetes' proven watch cache pattern to any infrastructure project without depending on the Kubernetes codebase. Core Components: (1) Watch Demultiplexer: Consolidates multiple client watch subscriptions into a single upstream etcd connection, then broadcasts events to all subscribers, reducing server load; (2) Event History Buffer: Maintains an append-only ring buffer of recent watch events, enabling lagging watchers to catch up from local history rather than reopening expensive upstream watches; (3) B-Tree State Mirror: After an initial snapshot, builds and maintains an in-memory B-Tree of current key/value state, applying watch events incrementally for fast range queries and lookups; (4) Point-in-Time Snapshots: Preserves historical B-Tree snapshots in a ring buffer, allowing exact stale reads at specific revisions without hitting etcd; (5) Resilient Control Loop: Handles initialization, upstream errors, compaction events, and automatic cache rebuilding with proper client notification.
The project tackles inefficiencies in API contract testing for microservices, focusing on schema management, validation, and consistency across distributed systems, which often cause bugs and delays due to fragmented schemas and poor versioning. I propose enhancing Keploy’s contract testing by implementing local schema storage as a mock registry, unifying schemas into a single service contract, adding advanced comparison with dependency resolution and real-time validation, and introducing provider-driven testing with contract publishing and rollback capabilities. My solution builds on a Go-based prototype, utilizing tools like Cobra, YAML, and Docker, with extensibility to S3. Deliverables include an integrated CLI with versioning and multi-format support, schema merging with diffing and real-time validation, and a provider-driven testing framework with rollback, all supported by comprehensive documentation and tests. This will streamline microservice interactions, ensuring scalability and consistency for developers.
The goal of this project is to build OTPKit, a Swift library that brings OpenTripPlanner to iOS. It will work as a standalone package that can be added to any iOS app. The first use will be in the OneBusAway app, giving users a modern trip planning experience with real-time updates, smart routing, and easy-to-follow directions. OTPKit will support key features like trip requests, walking directions, and smooth map interaction. Built with SwiftUI and a clean architecture, it will be easy to maintain and integrate with other iOS apps. By the end of the project, OTPKit will be the first Swift-based, Apache 2.0-licensed OpenTripPlanner library—making trip planning better for OneBusAway and available to other iOS transit apps too.
Summary : The OBA project aims to develop an integration testing system to ensure the accuracy and stability of the OneBusAway API server. This system will use Docker to create a controlled test environment to simulate various test scenarios and a Golang-based tool to validate API responses against expected outputs using GTFS and GTFS-RT data. It will include time simulation, structured test cases, and CI/CD integration to detect regressions and prevent inconsistencies. By automating the validation process, this project will enhance API reliability, making it easier for developers to trust and build upon OBA transit data services.
I intend to implement missing features in Uspot, in particular traffic accounting and traffic usage limits as well as improve the documentation of Uspot and its sibling projects ('ratelimit').
Greece’s public business records, available through the GEMI portal, contain valuable information such as company names, founding dates, and key individuals, but much of it is locked away in difficult-to-search PDFs. To make this data more accessible, we’re building an open-source tool that transforms these documents into a searchable, user-friendly database—legally and ethically. Instead of scraping, we will systematically fetch records from Greece’s official Open Data Portal, extract metadata and text using OCR and NLP tools , and organize everything in OpenSearch, which efficiently handles Greek text. A simple REST API will allow users to query companies, dates, and individuals while ensuring scalability, smart search, pagination, and overload protection. The project will provide an automated pipeline for downloading, processing, and indexing documents, along with clear documentation, Docker support, and easy cloud deployment. By unlocking these records, we’re not just solving a technical problem—we’re making public data truly public, empowering watchdogs, entrepreneurs, and citizens to better understand Greece’s business landscape.
Extend the Debian rsync package autopkgtest suite by running more upstream tests, setting up end-to-end tests with a proper ssh connection, and adding new tests for so far uncovered cases.
The pandemonium package is a specialized cluster analysis tool designed for physics applications. It employs hierarchical clustering and provides an interactive interface for selecting tuning parameters such as distance metrics and linkage methods. The app currently includes eight analysis tabs that explore clustering solutions across two representation spaces of the same observations using techniques like parallel coordinate plots, tour visualizations, and dimension reduction. This project aims to generalize pandemonium into a more flexible, general-purpose tool applicable to any domain where cluster analysis can help uncover relationships between two connected data spaces. In addition to broadening its applicability, the project will explore and implement new visualization techniques, including interactive visualizations, slice tour visualizations, and projection pursuit within tours. By the end of the project, pandemonium will be developed as an R package and submitted to CRAN for public availability. The package will provide an accessible, interactive platform for exploring clustering solutions across connected data spaces, integrating cluster analysis and multivariate data visualization into an intuitive graphical user interface (GUI). This will significantly enhance accessibility, making these advanced analytical tools available to a broad community of users across different fields.
This project explores Quantum Kolmogorov–Arnold Networks (QKANs) as a novel and interpretable architecture for analyzing collider data from the High-Luminosity LHC. Inspired by the Kolmogorov–Arnold theorem, QKANs decompose complex multivariate functions into compositions of univariate ones—translated into quantum models using parameterized circuits and Chebyshev-based activations. QKANs leverage quantum singular value transformation (QSVT), block-encoding, and variational unitaries to efficiently model high-dimensional, nonlinear relationships in jet physics tasks like quark-gluon tagging. The goal is to develop scalable and NISQ-compatible QKAN layers using the Pennylane framework and benchmark them against classical MLPs and spline-based KANs on realistic HEP datasets. This includes implementing quantum-friendly activation functions, evaluating noise robustness, and integrating hybrid QKAN layers selectively across high-impact features. The final deliverables will include a modular, open-source codebase, training pipelines, evaluation reports, and insights into symbolic function discovery in collider physics. This project contributes to building transparent, compact, and hardware-efficient quantum models for the next generation of scientific discovery at the LHC.
The FreeBSD mac_do(4) and mdo(1) utilities enable controlled transitions of user and group credentials without relying on inherently risky setuid executables. Currently, mac_do only authorizes the /usr/bin/mdo executable, and does not fully support granular group transitions or per-jail executable authorization. This project enhances security by allowing configurable paths for authorized executables (beyond mdo), implementing granular group management via mdo(1) (new -g and -G flags), and integrating comprehensive jail support for isolating credential rules. Key deliverables include kernel-side implementation of allowed executable path lists, enhanced per-jail rule management, extended userland functionality for group management, password authentication integration, and complete documentation updates.
This project aims to enhance cBioportal's analytical capabilities by integrating Variant Allele Frequency (VAF) visualization into the Plots Tab and OncoPrint views. Currently, in Plots Tab we can visualize mutation types of particular gene across different cancer types but it is not possible to visualize VAF data for different samples across different cancer types. It is very crucial for researchers to understand mutation clonality and prevalence across cohorts through VAF. Similarly in OncoPrint view we cannot add tracks for VAF heatmaps across different genes. The proposed solution has two components. For the Plots Tab, we will introduce VAF (linked to a specific gene) as a selectable numerical data type of mutation for plot axes. Existing plot components will then automatically render Box-Scatter or Scatter plots. For OncoPrint, we will implement gene-specific VAF heatmap tracks displayed below the main alteration grid. VAF heatmaps corresponding to primary displayed mutations with a dedicated 0-1 color scale.
The grepreaper package addresses the critical need for efficient pattern matching and selective data loading in R, particularly for large datasets. Currently, R users must load entire files before filtering, creating performance bottlenecks. My solution implements four core functions: 1. grep_count(): Counts pattern matches without loading entire files 2. grep_read(): Selectively loads only matching data 3. grep_files(): Discovers files containing specific patterns 4. grep_context(): Shows matches with surrounding context lines The package leverages system commands for pre-filtering, significantly improving performance by avoiding unnecessary data loading. It supports flexible pattern matching options, including case sensitivity control, inverted matching, and multi-pattern support across multiple files. Deliverables include: 1. Complete R package with documented functions 2. Comprehensive test suite 3. Performance benchmarks against traditional methods 4. Introductory vignette with practical examples 5. Integration with popular data manipulation workflows This project will provide R users with a powerful tool for efficient data exploration, particularly beneficial for large dataset analysis and text mining applications.
Despite capturing millions of web pages daily, The Wayback Machine may fail to archive many important resources before they disappear. This proposal outlines a comprehensive technical pipeline to optimize web archiving resources through intelligent URL ingestion, quality assessment, and prioritization. I propose a machine learning-driven pipeline that integrates diverse signal sources to identify at-risk, high-value web content while filtering low-quality material. The implementation includes a unified data collection framework, real-time quality scoring system, dynamic priority queue, and continuous evaluation mechanisms. This project, therefore, aims to significantly improve the Internet Archive’s ability to preserve historically significant web content before it potentially vanishes.
Provide financial institutions with real-time insights into loan risk, helping them make better lending decisions. A reactive backend ensures the system can handle a growing number of requests as Mifos deployments expand. Improved risk assessment can lead to more responsible lending practices, ultimately benefiting underserved communities. Create a dedicated microservice in Java that handles loan risk assessment asynchronously. Utilize reactive programming paradigms to ensure scalability and high throughput. Design and implement a configurable risk scoring model that can incorporate multiple factors such as client financial history, repayment behavior, and external credit ratings. Allow for model tuning via configuration, so institutions can adapt the scoring criteria to local requirements.
The KDE Mentorship website plays a important role in onboarding new contributors to the KDE community. However, the current site lacks a modern, user-friendly UI, and doesn’t fully support KDE’s future goals of recruitment and engagement. This project aims to redesign the website into a contributor onboarding and recruitment platform. It will organize the site into clear sections: Mentorship Programs, Communication Channels, Resources, Community Engagement and Recruitment Services. The project will be built using HuGo for static site generation, Go for the backend logic such as personalized resource recommendations and contributor assessment. Deliverables include a fully responsive website which shows all the mentorship program details, resource recommendations, contributor testimonials, and a recruitment pathfinder system. This project directly aligns with KDE’s goal: "KDE Needs You" , which aims to bring more contributors into the community for next two years.
This project addresses the issue of fragmented tools within the Kubeflow ecosystem, specifically Elyra, Kale, and Jupyter Scheduler, which complicates workflows for data scientists. The proposal aims to solve this by developing a unified JupyterLab plugin for Kubeflow. This plugin will consolidate and modernize the functionalities of the existing tools, providing a cohesive environment for developing, testing, and deploying machine learning workflows directly from JupyterLab. The plugin will achieve this by implementing seamless integration with Kubeflow Pipelines. Users will be able to convert notebook cells to pipeline steps, define and visualize pipeline workflows, submit pipeline runs, and monitor their execution status, all within JupyterLab. The plugin will be built with a modular architecture, including Python backend components for interacting with Kubeflow Pipelines and parsing notebooks, and TypeScript/React frontend components for the user interface. The key deliverables of this project are: • A unified JupyterLab plugin architecture consolidating Elyra, Kale, and Jupyter Scheduler functionalities. • Seamless integration with Kubeflow Pipelines, enabling notebook-to-pipeline conversion, workflow definition and visualization, pipeline submission, and monitoring within JupyterLab. • A user-friendly UI for pipeline development and management using modern React components. • Initial integration with Kubeflow Notebooks for easier notebook provisioning. • Comprehensive documentation and usage examples. • A robust testing framework to ensure plugin reliability, including unit tests, integration tests, user acceptance testing, continuous integration, and compatibility testing. This unified plugin is expected to significantly improve workflow efficiency for data scientists and ML engineers by bridging the gap between interactive development and production-grade ML infrastructure.
The goal of this project is to improve the compositor's sampling situation. This includes exposing the interpolation option to all nodes reliant on it. The interpolation options are already partially implemented, as seen in this issue: https://projects.blender.org/blender/blender/issues/119592. Furthermore, sampling requires boundary conditions, such as zero, extend, or wrap. Currently, these conditions are not exposed to the user, but use the wrap condition across different sampling methods. The conditions should also be selectable in the node giving more freedom to the users. Lastly, there is one sampling method that requires some special attention – BLI_ewa_filter. Currently, the EWA sampling uses different implementations across CPU and GPU, leading to different results on different devices/OSs. Blender uses EWA sampling primarily for anisotropic texture sampling. The goal is to write an implementation of the EWA filter for the CPU, which is transferable to the GPU, aiming for similar/equal results for CPU and GPU versions, allowing it to be used in the compositor to enable anisotropic compositing.
Cmm is the intermediate representation and code generation layer used by the Glasgow Haskell Compiler (GHC). It is written in Haskell and sits between GHC's high-level STG output and low-level native or LLVM code generation. Cmm enables multiple backends: a fast native code generator and a more sophisticated LLVM backend. In principle, this design allows users to choose between faster compilation or better runtime performance. However, like other parts of GHC, the documentation for Cmm is sparse, fragmented, and in many places outdated. For example, references to Static Single Assignment (SSA) form often describe it as "future work," even though there has been a prior attempt at implementing it. There is no cohesive documentation to explain what was done, how the backend currently works, or how one might extend it. This is an obstacle to contributors, researchers, and users alike. In practice, the LLVM backend suffers from long compile times and a fragile implementation. It depends on a custom LLVM AST that is hard to maintain, and requires users to install a specific, outdated version of LLVM. Meanwhile, the native backend is fast but unable to fully optimize performance-critical code. This project proposes to address these issues in stages: 1. Document the Cmm pipeline, the backend interfaces, and existing SSA infrastructure. 2. Then, depending on the mentor's and community's feedback, pursue one of two improvement paths:
ProLIF’s current 2D interaction diagrams often suffer from overlapping protein residues and tangled edges due to reliance on a default physics engine of vis.js. I propose to enhance ProLIF by developing an automated residue layout system that computes optimal 2D coordinates using graph-based algorithms (e.g., force-directed, radial, or circular layouts via NetworkX). This system will integrate into ProLIF’s visualization framework, allowing users to select and refine layouts interactively. Additionally, I will implement an export function to convert interaction fingerprints into a NetworkX graph for further analysis. Deliverables include a coordinate generation function, updates to the visualization module, comprehensive testing, and detailed documentation.