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 proposal aims to address the lack of support for histogram charts and other advanced chart types introduced in Microsoft Office 2016 within LibreOffice. Histograms are essential for data analysis, scientific research, and machine learning, providing valuable insights into data distribution. Currently, LibreOffice users rely on some clunky workarounds to create histograms, limiting productivity and compatibility with industry standards. The goal is to implement native histogram chart support in LibreOffice, eliminating the need for workarounds and enhancing the user experience. By leveraging the existing column chart implementation as a starting point, the project will gradually transform and extend the code-base to support histogram-specific functionality. This approach minimizes disruption to the stable code-base while introducing new capabilities.
This project develops cloud-native tools to detect novel insecticide resistance in African malaria mosquitoes. Current PLINK-based methods are insufficient as VGSC L995F mutation is now fixed and new resistance mechanisms have undefined targets. The solution implements advanced statistical methods (mixed-effects models, Bayesian approaches), population structure correction, interactive visualization tools, and cloud optimization for accessibility. Following a tiered strategy, core deliverables include statistical methods and visualization, with machine learning extensions if time permits. Leveraging my interdisciplinary background, this project will improve resistance detection sensitivity, helping researchers identify emerging resistance mechanisms before they become widespread, contributing to more effective malaria vector control.
<p>Reinforcement learning is a class of machine learning methods that uses the reward signal of the environment to infer optimal actions. Reinforcement learning is used in various fields, including robotic control, conversational bots, resource management, personalized recommendations, and games. Two algorithms are widely used as baselines in reinforcement learning: Deep Q-Networks (DQN; Mnih et al., 2015) and Proximal Policy Optimization (PPO; Schulman et al., 2017). This project will add these two algorithms to Swift for TensorFlow’s open-source repository of models. With the addition of these modules, the users will be able to easily use these algorithms on their problems and rapidly prototype their reinforcement learning algorithm using Swift for TensorFlow.</p>
Kdenlive currently supports single-point timeline markers, which limits efficiency for workflows that require marking time ranges, such as highlight editing or collaborative annotations. This project proposes enhancing Kdenlive's marker system by introducing duration-based markers that define a clear start and end time. The project will extend the marker data model to support a duration attribute while maintaining backward compatibility. The UI will be updated to visualize range markers as colored regions on the timeline, with interactive handles for resizing and editing. These markers will be integrated with key features like zone-to-marker conversion, search and navigation, rendering specific ranges, and import/export capabilities-streamlining workflows and aligning Kdenlive with professional editing tools.
<p>This project proposal formalizes my intention on helping CVXPY in creating and implementing a new library to centralize the shared functionality from CVXPY, CVX, and Convex.jl. By the end of the project, the main goal is to have an efficient C++ library that performs the required actions: convert a convex optimization problem given by any of these modeling frameworks into standard form, call the solver, and return the solution to the correspondent problem. In addition, this proposal presents my intention to integrate CVXPY with ILOG CPLEX solver. This would provide the user an alternative solver other than Elemental, Gurobi, MOSEK, and GLPK. This proposal presents the main steps to accomplish both goals and possible collaborations after Google Summer of Code 2016. Finally, the proposal is concluded with a summary of my academic, research, and coding background experience.</p>
This project aims to build a modular, containerized pipeline for medical image processing (e.g., IVIM analysis) with DICOM and NIfTI support. It will allow users, especially researchers and clinicians, to define and execute their own workflows via a web interface. Users will be able to configure multi-step image processing workflows, such as image ingestion, preprocessing, fitting, and report generation, that are executed based on dependencies between tasks. These workflows will be modeled as Directed Acyclic Graphs (DAGs), where each task runs only after its required inputs are available. To orchestrate these workflows efficiently, the system will use a combination of Docker containers, Kaapana for healthcare-specific orchestration and frontend visualization, and Kubernetes and Argo or Airflow for advanced DAG-based control and scaling.
Adding support of a new file format (SPDX 3.0) and a new compliance standard (EU Artificial Intelligence Act) for SPDX SBOM Conformance Checker. This proposal introduces two key capabilities: 1) SPDX 3.0 Parsing: Add ability to parse SBOMs in SPDX 3.0 JSON format and build a computational model of the SBOM for further processing. 2) EU AI Act Compliance Checks: Add ability to assess SBOM conformance against selected provisions of the EU AI Act. For example, concerning Article 49 (Registration), the checker will analyze the SBOM to determine if it includes the information mandated by Annex VIII, providing users with a clear report on present and missing data elements.
Currently, both of the projects, Talawa-API and Talawa-Admin, provide support for basic functionality related to events (like creation, updation, and deletion of events for an organisation). But this functionality still needs to be completed from a practical point of view. The system lacks some fundamental functionality required for event management (from both the organization's and the attendee's perspective). The purpose of this project includes the following:- 1. Update the API models in a scalable and performant manner to provide support for new event management functionalities that are client agnostic (thus can be consumed on both the Talawa Admin and Talawa Mobile App) 2. Create all the relevant UI for these functionalities in the Talawa Admin. 3. Add a new feedback portal to the Talawa API and Talawa Admin to track the quality of organized events.
Open Data PVNet aims to democratize solar energy forecasting by extending the PVNet framework to work entirely with publicly available weather datasets like GFS, DWD ICON, and ERA5. Current solar forecasting models often rely on proprietary data, creating barriers for researchers and developers in low-resource settings. This project will build a training pipeline based on open NWP data, enhance data preprocessing tools, and benchmark PVNet’s performance using these sources. Key deliverables include zarr-formatted datasets, an open-source training pipeline, performance evaluation scripts, and comprehensive documentation. The end goal is to make high-quality solar forecasting more accessible, scalable, and globally impactful.
Setting a calendar event is a small, but important process in our day-to-day job. It can take some of your time when you want to set up another meeting if you 1) Already have a tight schedule; 2) Your coworkers are in different time zones; and 3) Have to switch back and forth between the calendar and the messaging app. Hence, this project aims to streamline the process using a scheduling assistant, that can create meetings or set up a reminder using a prompt. A slash command can simply trigger it through a messaging app (in this case, Rocket.Chat). The solution will involve a lot of large language models (LLM) experiments for the user prompt. Therefore, this project can act as a semi-research in which the result of LLM experiments can be used to approach similar cases.
HiperHealth's clinical pipeline currently lacks visual diagnostic capabilities. This project adds a modular MedVision skill channel, an external, installable module that brings medical image analysis into the existing pipeline with zero core modifications. The project delivers shared infrastructure (MONAI preprocessing, Grad-CAM explainability, structured Pydantic output models, confidence calibration) and two body-region skills: SkinAnalysisSkill (DINOv2 backbone, ISIC 2018 dataset) and a second body-region skill (Eye/Nail) to validate extensibility. Each skill automatically enriches the DiagnosticsSkill's differential diagnosis via the prompt_fragments mechanism, producing calibrated predictions with saliency maps for clinical transparency. The project includes Fitzpatrick fairness auditing and ≥90% test coverage.
Nowadays, data is increasing at a rapid rate and is being structured efficiently by the Linked Data Cloud. The data is stored in a specific format and can be queried using the SPARQL language hence it becomes difficult for lay users that are not familiar with formal query language such as SPARQL to search their interests. Question Answering (QA) systems have worked very well to solve this problem. The Neural QA model focus on seq2seq learning to translate natural language questions to their respective SPARQL queries. The goal of the project is to make our end-to-end system perform better via the automatic generation of natural language question (NLQ) templates, the inclusion of new varieties of questions that have advanced SPARQL queries, improving the compositionality of questions, and enhancing the existing generator and learner module.
<p>Equadratures is a powerful open-source library assisting the user to make the use of orthogonal polynomials for uncertainty quantification, machine learning, numerical integration and dimension reduction. The upcoming version of Equadratures adds more functionalities such as plotting functions (Sobol Indices, Zonotopes), scaling functions (min-max scaling, mean-var scaling) etc. The main aim of this project is to enhance the visualization capability of Equadratures and creating an application for uncertainty quantification for computational simulation. The application would help users with no prior coding experience in python to dive deep into statistics using Equadratures. Dash framework would be used for the creation of this application. The application would provide operations for uncertainty quantification and various plotting functions helping the user to gain insights from the model.</p>
This project aims to improve fuzz testing for OpenPrinting’s C/C++ codebases by leveraging OSS-Fuzz-Gen, a new framework that uses Large Language Models (LLMs) to assist fuzz testing. While some OpenPrinting projects are already integrated into Google’s OSS-Fuzz, current fuzzing efforts achieve limited runtime coverage (e.g., only 11.84% for cups), leaving many functions untested. To address this, the project will (1) refine existing fuzzers, (2) improve corpus and dictionary quality using LLMs, and (3) generate additional fuzz harnesses with OSS-Fuzz-Gen to improve the coverage. This will enhance test depth, uncover hidden vulnerabilities, and strengthen the security of OpenPrinting projects.
This project mainly aims at improving the user experience of Synfig. It does so through various improvements. The first is implementing non-vertex editing tool/s. It also attempts to improve the performance by testing internal layer operations to see if it would be beneficial to apply caching optimizations to them. Other than that, it also includes fixing various crashes and issues. The project is divided into the following parts: 1- “Select (non-vertex editing) Tool” : Includes implementing tool/s to handle various transformations in non-vertex ways. 2- Fixing UI Lags and Crashes: Includes testing internal layer operations to see if they would benefit from caching mechanisms (implementing the mechanisms if they would be beneficial), and fixing various crashes. 3- Additional Features/Fixes: Includes various miscellaneous improvements.
<p>Checker framework is a great lightweight tool which could easily type check code having a dependency on a library if the library has already been annotated. Google Gson is a widely used library written in java to transform the Java objects to JSON (JavaScript Object Notation) and vice versa. This library has a total of 143 directories and 255 files out of which 208 are java files. This project could be an overall evaluation of the type-checkers on real code and can also help detect bugs or suggest improvements to the library being annotated. The main goal of the project</p> <ol> <li>Adding annotations to the Google Gson library for Nullness, Index and Interning checker.</li> <li>Adding missing annotations in JDK and reporting bugs if found any in the process.</li> </ol>
<p>Information obtained from an <strong>Inertial Measurement Unit</strong> (IMU) is constrained due to physical limitations such as noise, drifts, misalignments and offsets. Since obtaining the state of a robot/vehicle requires integrating IMU outputs with time, the errors in the integrated estimates grow very fast. This project develops tools to accurately <strong>model the errors</strong> that affect IMU outputs, to <strong>estimate their relevant parameters</strong> and to understand <strong>how each parameter changes with time</strong>. Additionally, a <strong>sensor-fusion based pipeline</strong> is proposed for <strong>regularly correcting the estimated IMU parameters</strong>. The proposed method does not require any external mechanical setup and is designed to ideally work on low-computation processors and/or microcontrollers.</p>
This project introduces native per-character text animation support in Synfig. Currently, text is rendered as a single shape, making effects like staggered animation, typewriter effects, or per-letter transforms difficult without workarounds. The proposed solution decomposes text into glyph-level elements and enables independent animation of position, rotation, scale, color, and opacity for each character. A reusable stagger engine will be implemented to support delayed animations across characters, with a design that can be extended to general group-based animation in the future. The project will deliver new layer types for glyph-based rendering, full integration with Synfig’s animation system, UI support, file format compatibility, and user documentation.
<ul> <li><p><strong>JAX</strong> as the latest machine learning library has all the advanced gradient techniques aided by acceleration of GPU/TPU and high-level modules for model prototyping.So it definitely is a faster alternative to <strong>numpy</strong> as it can use XLA engine and the JIT compiler.</p> </li> <li><p>The book “<strong>Probabilistic Machine Learning: An Introduction</strong>” is an amazing book for any level of machine learning enthusiast and the examples mentioned in the book are very accurate and helpful in analysing the ML algorithms and tools.</p> </li> <li>So the <strong>ML examples</strong> presented in this book can be a great pick to <strong>test and prove the potential</strong> of JAX and also helps to improve the library.</li> </ul>
Problem: Currently, Joomla items such as articles are limited to a single category, which makes it difficult to organize content that belongs to multiple contexts. While tags are sometimes used as a workaround, they do not integrate with core features such as routing, menus, and structured layouts in the same way as categories. Solution: This project introduces multi-category support by implementing a generic mapping table (#__category_item_map). It preserves backward compatibility and SEO integrity by using a "Primary Category" as the main reference for routing, workflows, and parameter inheritance. Deliverables: A new database schema, an updated backend interface for multi-category selection, frontend updates to reflect multi-category assignments in item views and category listings, model-level integration for custom fields, extended batch operations, unit tests, and documentation.
This project aims to modernize the LLVM Integrated Tester (lit) to improve its execution speed and long-term maintainability. Performance is currently hindered by synchronous subprocess management and the high OS-level overhead of launching separate processes for routine commands. To address this, the execution engine will transition to a non-blocking, asynchronous model using asyncio, and core built-ins like cat and diff will be moved in-process to eliminate redundant interpreter startups. Additionally, the project will resolve functional limitations in internal shell utilities and leverage Scalene for data-driven performance profiling. Deliverables include a modernized Python 3 codebase, an asynchronous execution engine, integrated in-process built-ins, and a comprehensive performance evaluation report.
My project proposal aims to optimize the FasTensor tensor computing library to work efficiently on GPUs to enable efficient tensor contraction while maintaining the structure-locality of tensor data. This project involves creating custom-defined computational operations on GPUs and is essential for many scientific applications, including advanced AI model training. My expected deliverables include a working implementation of FasTensor on GPUs, a report on the performance of the execution engine, and documentation of the execution mechanism. My implementation plan involves using a combination of programming languages, including C++ and CUDA, and managing memory and data movement efficiently. My project timeline includes research, planning, implementation, testing, documentation, and reporting. I have a relevant academic background and professional experience in software engineering and machine learning.
This project aims to add a livepatch subsystem to dynamically update kernel code. Having a way to patch bugs or security vulnerabilities without restarting the whole machine would be very useful, especially on servers, which make up the majority of FreeBSD usage. Patches will be delivered via kernel modules, utilizing ELF headers and CTF/DWARF metadata to accurately resolve internal symbols. The patching mechanism will redirect control flow by inserting trampolines at the prologue of target functions. To ensure system stability, patches will be safely applied using a stop-the-world consistency model via smp_rendezvous, with safeguards to prevent the modification of critical routines like the SYSINIT routines. Stack trace analysis will also be explored to more accurately detect function quiescence.
sbi is an open-source Python package used for simulation-based inference. It provides an interface for running algorithms that are used to identify model parameters that are consistent with data. Currently, this project uses “stringly typed” values for its functions' arguments. Even though stringly typed code is flexible and easier to implement, it comes with a set of drawbacks. Using stringly typed code leads to a suboptimal developer experience with limited IDE support and subtle bugs that are hard to identify and fix. This project aims to improve the developer experience and mitigate these issues by updating arguments in functions to use strongly typed code. In addition, it plans to create a pattern for sbi contributors to follow when defining new functions and classes that would otherwise use stringly typed arguments.