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.
<p>As seen on Blog Posts on Planet KDE support for High-DPI monitors has come a long way since Plasma 5.0. And thanks to the work by many dedicated people the situation in Plasma is now almost ideal. But unfortunately, this is not the case for all KDE applications. Support for HiDPI seems to be more of a hit-and-miss for some of them, many crucial for day-to-day workflows (like Okular and Gwenview). Competing desktop environments have nowadays a nearly perfect HiDPI support, so I think it is time to face the remaining problems once and for all.</p> <p>Therefore I suggest the following approach: My Google Summer of Code project will find HiDPI rendering issues in KDE applications and fix them in a coordinated approach. I will look at applications, which are usually installed on the users desktop, like the Plasma Workspace, Systemsettings and utilities from the kdegraphics module (gwenview, okular, spectacle).</p> <p>This will also require working together with KDE community members, which report bugs, and application maintainers, to get the submitted patches on the KDE reviewboard in a state that allows them to be committed in their respective repositories.</p>
<p>The primary goal of the project is to upgrade Afra's annotation editing code, to provide it performance upgrade. Afra's annotation editor is built using JBrowse and WebApollo, is completely browser based. Afra is unique in the way it addresses the challenges of biocuration. The community needs this kind of tool to grow. This goal will be achieved in following steps</p> <ul> <li>Extensive automated test for the annotation editing facility</li> <li>Determine change we made to the codebase of JBrowse/Apollo in Afra. Based on which we will implement new features for the performance upgrade.</li> </ul>
<p>WSO2 Complex Event Processor(WSO2 CEP) is real-time and it has a quick response time in identifying patterns in incoming stream of events/large data feeds with minimum storage. WSO2 CEP is popular among community since it’s simple and easy to use as well as since it is free and open source. The core of WSO2 CEP is Siddhi which is a SQL-like query language that is used for complex queries. An Eclipse plugin for Siddhi is a valuable approach for the developer community since eclipse IDE is a widely used IDE among developers. Eclipse plugin for Siddhi will comprise syntax highlighting, auto completion, error reporting, running and debugging support for Siddhi based on Siddhi grammar using Xtext and Java.</p>
<p>Jupyter Notebook is an interactive computing environment that is used to create notebooks which contain code, output, plots, widgets and theory. Jupyter notebook offers a convenient platform for interactive data analysis, scientific computing and rapid prototyping of code. A powerful tool used to perform complex computation intensive tasks is Apache Spark. Spark is a framework for large scale cluster computing in Big Data contexts. This project aims to leverage these existing big data tools for use in an interactive scientific analysis environment. Currently Spark jobs can be called from Jupyter Notebook using the pySpark module. However to know what is happening to a running job, it is required to connect separately to the Spark server. This project aims to develop a plugin to monitor jobs sent from a notebook application, from within the notebook itself. The plugin will have features to monitor tasks, stop ongoing jobs and detect errors. ROOT is a data analysis framework, widely used in the scientific community at CERN. The plugin designed will be used to monitor processing of ROOT objects using Spark. The plugin will also be used to monitor distributed machine learning tasks.</p>
<p>The aim of this project is to write support code for obtaining accurate transcriptions, exemplar pronunciations, and phonetic and part-of-speech labeling.</p> <p>One of the important concerns in Natural Language Processing is the availability of gold standard information such as transcripts of speech, part-of-speech tagged sentences, word pronunciation examples etc., which aid in training and evaluating the performance of speech and text processing algorithms. This requires extensive collection, processing and validation of information from a variety of sources.</p> <p>The data needs to be normalized across these sources, evaluated based on quality, quantity and other metrics. This requires a structured system which allows for the data collection and management tasks to be done effectively. This is especially important to CMU Sphinx contributors who require such data for their work, such as training and evaluating their speech and text models.</p> <p>The project involves the integration of a Flask and SQLite based leaderboard web application with a transcription record system into a broader data aggregation and processing framework for the aforementioned tasks.</p>
<p>Automatic speech recognition systems are traditionally based on Hidden Markov models(HMMs) as it had given the best results in the past. However due to recent advances in neural networks, recurrent neural network(RNN) models have became competitive and surpassed HMMs in speech recognition task. RNN models also have the advantage of being used in an end-to-end model and don't require extensive hand engineering of features like HMM. In this project I aim to implement a LSTM(Long Short Term Memory) based model as based on state of the art research and make it easily available using PocketSphinx like API.</p>
The current gate-level circuit simulator in qutip-qip utilizes a full sparse Qobj representation of each gate, expanding local gates to the Hilbert space before applying them to the state vector via matrix multiplication. This approach encounters significant memory and computational bottlenecks as the number of qubits increases. This project aims to address that limitation by refactoring the circuit simulator and adding tensor based executing via the recently added qutip.einsum. PR #225 in qutip-qip has made efforts to introduce a foundational tensor contraction approach, but it is only limited to the numpy backend and lacks support for GPU acceleration. Hence, this project aims to further implement JAX integration to the backend using qutip.einsum with JIT compilation for speedups on both CPU and GPU, As well as,to implement GPU accelerated circuit simulation using qutip-cuquantum.
The Problem: Spack’s combinatorial flexibility makes exhaustive CI testing computationally impossible. Current CI focuses almost exclusively on "leading-edge" configurations (latest packages with latest dependencies). This structurally excludes off-leading-edge scenarios where older packages meet newer, unbounded dependencies, leaving the ecosystem highly vulnerable to silent API/ABI breakages that users only discover in production. The Solution: This project introduces a Generative AI-assisted testing system to autonomously hunt for high-risk configuration breakages. The architecture treats configuration testing as a feedback-driven sequential decision-making pipeline. First, a data-driven heuristic risk model filters dependency pairs based on structural risk and historical failures. Next, an LLM acts as an iterative hypothesis generator to propose structurally diverse, high-risk abstract specs. Finally, a strict deterministic validation layer ensures mathematical correctness and bounds CI compute costs using Spack's Clingo ASP concretizer and semantic deduplication. Key Deliverables: Metadata Extraction Module: Parses package repositories to identify unbounded dependencies and analyze version gaps. Adaptive Risk Scoring Engine: Classifies package pairs into risk tiers using a multiplicative formula driven by structural signals and historical failure data. LLM Hypothesis Generator: An iterative prompt engine utilizing selective context retrieval and within-run adaptation to propose risky testing configurations. Validation Pipeline: A strict gating system utilizing spack.concretize_one() and 3-layered semantic deduplication to prevent redundant or hallucinated tests. State Management Registry: A unified SQLite database to map historical CI data, track tested configurations, and feed failure patterns back into the LLM context. Integration & Diagnostics: A working spack audit ai CLI subcommand and a heuristic log-triage pipeline.
This project investigates GPU-accelerated approaches for spatial searching and mesh intersection in CGAL, a widely used computational geometry library. These operations are fundamental to applications such as collision detection, mesh processing, and geometric querying, but are currently limited by CPU-based performance, especially for large or dense datasets. The core idea is to leverage the massive parallelism of GPUs to accelerate the broad-phase of spatial queries, where potential interacting primitive pairs are identified. These candidate pairs are then refined using CGAL’s exact geometric predicates to preserve robustness and correctness. The project will explore multiple architectural designs, including hybrid GPU–CPU pipelines, fully GPU-based approaches, and alternative spatial data structures such as bounding volume hierarchies and spatial grids. An initial exploration phase will compare these approaches across diverse input configurations (e.g., overlapping vs non-overlapping meshes) to identify the most effective design. The final outcome will be a modular and reusable GPU-accelerated spatial searching framework integrated with CGAL. Deliverables include a prototype implementation of selected GPU-based spatial data structures, a candidate pair generation system, integration with CGAL’s exact predicates, and a comprehensive benchmarking suite evaluating performance, scalability, and robustness across different workloads.
The Zulip web application is being redesigned but there are several UI inconsistencies in various parts of the web app. After seeing the redesign-label issues, I understood that the modals, sidebars, icons, and interactive visual features are not all developed with an integrated look. This makes an inconsistent user experience with elements such as modal inputs being unstandardized, Icons and symbols lacking visual consistency across the web app components, and elements within the sidebar having improper alignment, scroll animation, and elements such as link styles, color logic, and interactions. The goal of this project is to standardize and improve these UI elements in a structured way. I will work on redesign-labeled issues along with UI tasks, improving design pattern consistency, improving CSS structure, and managing elements with modern UI standards. With careful testing and taking mentor feedback to ensure accuracy, have discussions on future design provided in Figma.
The SSH client obtains its configuration either from command line arguments or from configuration files such as ~/.ssh/config and /etc/ssh/ssh_config. These files are parsed by the SSH client implementation (for example OpenSSH or clients built on top of libssh) and the parsed options are applied to the session configuration. Libssh follows a parsing architecture that slightly differs from OpenSSH. As a result, configuration files may be interpreted differently by the two implementations. Additionally, OpenSSH usually tends to be one-step ahead in introducing new configuration options, and libssh is having a hard time catching up with them. In such cases, libssh should ideally ignore unsupported options gracefully rather than misinterpreting them or causing unexpected behavior. Due to these differences, the same configuration file can produce different parsing results between OpenSSH and libssh. Since OpenSSH is the most widely used SSH implementation, such divergences may cause inconvenience for users and reduce configuration compatibility. This project focuses on building a differential fuzzer that compares how OpenSSH and libssh parse SSH configuration files. The fuzzer will mutate configuration inputs and identify cases where the two implementations behave differently. Based on the discovered divergences, libssh’s configuration parser will be refined to align its behavior more closely with OpenSSH. Finally, regression tests will be introduced for the discovered issues to ensure that future changes do not reintroduce the same bugs.
SW360 instances running for years accumulate thousands of stale projects, components, and releases that slow down searches, waste disk space, and clutter the UI. Currently, the only cleanup option is permanent deletion with no undo. This project adds a reversible archival workflow. Admins select entities, export them as self-contained TAR.GZ bundles with all metadata and attachments, then remove them from the live database. A CouchDB registry tracks what was archived and by whom. To restore, admins upload the archive, preview contents with conflict detection, and selectively re-insert entities. Deliverables: archival.thrift service definition, backend Maven module with archive and restore logic, REST API endpoints, a frontend admin page with entity selection, registry table, and multi-step restore flow, plus unit and E2E tests."
This medium-sized project aims to improve pattern matching support in gccrs, the GCC frontend for Rust, by implementing compilation for the currently unsupported patterns (StructPattern, SlicePattern, RestPattern, etc.). The successful implementation of these features will bring gccrs a step closer to becoming a production-ready alternative Rust compiler, while providing valuable experience in compiler frontend development.
This research project addresses the problem of time-consuming debugging of RPM build failures in openSUSE. By integrating the Log Detective model into the openSUSE workflow. The integration will be achieved through developing an osc plugin for command-line interaction and creating a web component within the Open Build Service (OBS) interface. The project aims to deliver a research document detailing Log Detective's AI approach, tools and scripts for log submission, and proof-of-concept implementations of both the osc plugin and the OBS web component.
In this project, we want to implement an infrastructure in Pgmoneta that can read and parse the WAL files into WAL records. When our infrastructure has a deep understanding of the WAL files and records, we can apply the appropriate WAL records on a base backup that we have, and we can reach the desired point in the restored database, which is a very helpful feature to achieve point-in-time-recovery (PiTR).
This proposal aims to improve an outdoor sensor platform by focusing on usability and expandability. To achieve this, the project will integrate a new type of sensor, allowing researchers to collect a wider range of data. A user-friendly interface will also be developed using PyQt5, so researchers can configure the device without writing code. Finally, the project will contribute to a more efficient and well-documented codebase by using Protobuf for data storage and potentially improving the code's structure. The proposal highlights a clear plan with a detailed timeline and showcases the proposer's experience in relevant areas like embedded systems and sensor interfacing.
Using machine learning, this project will develop an image processing pipeline that takes a user submitted image from Boston’s 311 app and helps the resident submit a corresponding non-emergency city request. By automating this process, this service can be accessible and more intuitive for a wider range of audiences, who may not have English as their first language or be well-versed with using technology, while also consuming less of the city’s resources due to erroneous submissions. Curating a dataset from the previously submitted 311 system photos, I will prepare a large image collection that will then be used to develop a CNN for image classification with the TensorFlow library. Then, I will develop a large language model trained on past service requests that can help draft a service request for the user that is customized to the specific situation at hand. These models will be saved, compressed, then deployed to an accessible API endpoint.
The objective of this proposal is to implement a new data fetch layer for frontend in Plone CMS. I intend to implement a library “@plone/client” that will work as a client for “plone.restapi”, using Tanstack Query. This client will enable Plone to move away from the “AsyncConnect” data fetch layer that is based on Redux. Then Redux can be used as the application-level data store only. TanStack Query brings many benefits with it, like caching support, de-duplication of queries, cancellation, refetch, easy-to-use hooks, SSR support, and more. A modern API client should use these features fully. The primary goal of this client is to be robust, yet flexible enough to support all use cases, and be easily extensible.
GNOME Settings (aka gnome-control-center) is GNOME's main interface for configuration of various aspects of your desktop. GNOME Network Displays is a standalone application for casting your display's content onto another remote display in the network. The goal of this project would be to reuse the work in gnome-network-displays to be able to manage remote displays in the GNOME Settings Display panel. Allowing users to select the remote display from the list where they already can find local displays/monitors. This work will involve iterating with the GNOME design team and discussing the UX of the functionality.
My goal is to enhance the Keploy Typescript SDK's versatility and accommodate a wider range of developers and use cases. I aim to make it more flexible, allowing for easier future integration of additional technologies/databases by creating reusable code blocks. Major deliverables: 1. Add support for Httpclients in TypeScript 2. Add support for popular SQL databases using Sequelize 3. Add support for MongoDB database 4. Add support for cloud storage services 5. Add support for Redis and Elasticsearch 6. Sample Project: Include a sample application that will contain all the above integrations in the Sample-Typescript repo for seamless testing of each implementation.
Use of Hydra-Space in order to make an asynchronous chess game, so two-player could play from different places so we will use satellites communications. The first idea is to adapt the chess logic using the already existing GNU Chess so we will need to implement the game communications. About the front-end, we will display the Chess game in the LG-rig, just like the LG-Retro-Gaming games (Snake, Pong, …)
This project aims at creating a step-by-step form to help beginners submit a Wikipedia edit request. An edit request is a request for someone to change some text in an article. Edit requests are an important part of Wikipedia. The form created in this project will help the edit requests comply with Wikipedia policy. It will be developed as a Wikipedia user script that shows a form for submitting a Wikipedia edit request, with high-quality guidance and error messages, suitable for use by beginners, and a backend server that the user script will make calls to for validation of source and quote.
This project aims to introduce a new testing strategy so that we encourage Behaviour-driven Development here, at Phoenix — the official web event display of the ATLAS experiment. The whole testing setup of Phoenix needs a complete revamp. Currently, Phoenix as a project comprises 3 packages: phoenix-event-display, phoenix-ui-components, and phoenix-app. And, my goal is to set new benchmarks and coverage thresholds for these 3 packages that will essentially, enforce and encourage testing for the whole of the project with Behavior-driven Development as its sole motivation so that potential issues that may occur in a critical environment can be identified much before they happen. This can effectively help us to troubleshoot problems and bugs so that the changes that will be made in the future to the codebase can be deemed reliable.
<p>Competing Destination (CD) models, which are an extension of Spatial Interaction (SI) models, has been around since 1980's and are often used within Economic and Social Sciences . CD models involve the analysis of flows from an origin to a destination similarly to traditional SI models, however, CD includes the ‘Competing Destination’ term also known as ‘Accessibility’ term, which accounts for the spatial-structure effect of the flows from behavioural perspective. Although the SI models are established within Python and R modules already (SpInt, simR), specification for deriving Accessibility term for CD estimation is missing. This project aims to fill this gap by developing a Competing Destination class that will include the computation of the accessibility term and will be binded to the existing SpInt module. The main challenge here is the scaling of the accessibility computation for large datasets. This is an important aspect of the project as flow datasets often have hundred thousands and even millions records. This project will extend the use of the SpInt module and PySAL library for high level analysis of spatial flows.</p>