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.
Data Cleaning is one of the important and time-consuming steps in the Data Science and Data Analytics field. There are numerous methods, models, and algorithms for data cleaning processes that might be categorized under imputation, outlier detections, formatting, and visualizations among others. The process of evaluating these methods for a given dataset is challenging considering the volume of the dataset and the time/space complexities of the methods. Automation of the performance evaluation process can lead to a significant reduction in human efforts and time consumption with an unbiased comparison environment. The imputeTestbench package provides a benchmarking tool for automated performance evaluation and comparison of various imputation methods for time-series datasets. In its present form, the package is capable of handling time-series and temporal datasets. Imputation plays a crucial role in the fields of genetics and genomics. The aforementioned package can be very helpful if it can be modified to handle genetic or genomics datasets. It has huge potential in handling genetic/ genomics datasets and introducing parallel-processing and high-performance computing concepts. Considering these as a motivation, the goal of the project is to develop a new R package, modifying the imputeTestbench package for Genomics applications with better computational capabilities and will be named 'imputeTestbenchG'.
I propose to work on the creation of a DMA-BUF backend for waycrate’s libwayshot screen capture library. Presently libwayshot’s method of screen-capture requires copying from graphics memory to system memory via CPU using the shared memory methods of the wlr-screencopy protocol. This method has too much overhead for uses like high resolution streaming: any further transforms and processing of the image will either be performed on CPU (inefficient) or require another copy back onto graphics memory. There is a better way to do this. The DMA-BUF (short for Direct Memory Access Buffer) is a Linux kernel framework that allows for efficiently sharing buffers of memory between multiple graphics devices or subsystems. Using the DMA-BUF export mechanisms in wlroots we can completely avoid downloads and uploads between graphics memory and the CPU, thus allowing for increased efficiency and performance. This will be especially noticeable on higher resolution screen-captures where individual frame buffers become too large to be efficiently dealt with on a CPU compared to how they can be handled on the GPU. The Deliverables for this project are: Complete implementation of a high-performance DMA-BUF based screen capture backend in libwayshot, Documentation for using it.
<p>The aim is to enable multiple web-apps generations by implementing <strong> queue data structure</strong> for the series of requests triggered by users from the open-event platform. This would prevent loss of requests from the user and enable the creation of event for every request and provide a web-service for direct generation of event sites from the orga-server(eventyay). In the present implementation, we have transformed websites generated through open-event-webapp to be <strong>Progressive Web App(PWA)</strong>, due to which service workers are already enabled. Therefore we can now move to further enhancement like push-notifications of bookmarked events by any user, also we need to improve the user interface for the <strong>dark theme</strong> enabled recently to project. The present testing suite requires some more tests for the functionalities like direct linking of tracks and rooms so the aim is to write <strong>mocha unit tests</strong> with selenium webdriver for the recently added features and the proposed ones. The travis build for the selenium tests run for around 20 minutes, which is quite large so the aim is to <strong>parallelize the build</strong> so that multiple builds can be performed at the same time and runtime can be decreased significantly.</p>
ArduPilot flight logs are currently analyzed manually, making it difficult to understand why crashes or unexpected behavior occur. Users have to inspect multiple signals across time, which requires experience and is not reliable for most people. A Python tool that runs locally and takes a .BIN log as input. The data is aligned across time and processed to extract signals such as attitude error, battery behavior, GPS error and other signals. Physics-based checks detect sustained issues based on flight behavior, while a Hidden Markov Model observes patterns over time to filter out short disturbances. Results are treated as reliable when both agree over a consistent duration. An LLM based agent coordinates the workflow by running the analysis steps and combining their outputs into a clear explanation, while all calculations follow rule-based logic. The analyser adapts to different firmware versions by reading parameters and detecting configuration related issues by comparing them with expected ranges from the ArduPilot codebase. It outputs what happened, when it happened, and why, along with linked telemetry evidence and possible fixes. Deliverables include a complete Copter focused diagnostic pipeline, ML integration, dynamic parameter lookup, structured output generation, and a packaged command line tool with documentation.
<p>The internet today is rich in image-content, from entire websites like Instagram and Pinterest dedicated to curating and displaying images, to Facebook and Reddit that have large amounts of content in image form. Non-visual users find it challenging to navigate and use these websites for their intended purpose. The information in images, whether on the internet or stored locally, is also inaccessible to non-visual users. NVDA or NonVisual Desktop Access is a free, open-source, portable screen reader for Microsoft Windows. It already includes an OCR that can recognize text within images, however, it lacks any functionality to describe image content and allow users to interact with the various objects within images. This project aims to overcome these issues through two modules:</p> <ol> <li>A machine learning module to generate descriptive captions for images on the user’s screen or those manually inputted by the user.</li> <li>An object detection model that draws bounding boxes around recognized objects and outputs the object label when the user’s pointer enters a bounding box. The outputs of both these modules could be presented to the user using NVDA’s existing mechanisms such as voice or braille.</li> </ol>
<p>The solution will consist of an Android app, that will read the input provided by the user, and generate an interaction model, which can be read by DroidBot, and used for automating the appropriate view.</p> <p>Firstly, for every new page, a layout will be generated. The dumpWindowHierarchy method can be used to dump the layout to a file, and this file can be read to understand the events associated with it. This will be useful later, when the input events need to be reconciled.</p> <p>Touch input events will be recorded using the getevent tool. Simple touches and gestures will be differentiated. Only events that are contained within the layout area will be processed by the system.</p> <p>Since getevent isn't reliable for keypress input, it cannot be used. Instead, an IME that logs text input will be implemented. This reduces logical complexity by not having to parse getevent logs for keyboard input, when keyboard layouts can vary wildly.</p> <p>The input events will be reconciled with the UI, by performing the input actions on the innermost element that the X and Y values of the input were contained within.</p> <p>Interactions can be sent to droidbot either as a script, or by directly deserializing the UTG class.</p>
The Meshery documentation docs.meshery.io (https://docs.meshery.io/) is a critical resource for users and contributors. Currently built using Jekyll, the site faces limitations in build speed, scalability, and long-term maintainability. Hugo, a modern static site generator, offers significantly faster build times, better content organization, and an improved developer experience. This internship focuses on migrating the entire docs.meshery.io (https://docs.meshery.io/) site from Jekyll to the Hugo framework, using docs.layer5.io (already implemented in Hugo) as a reference architecture. The migration will involve porting all documentation content, assets, layouts, and configuration while preserving URLs, SEO, contributor workflows, and existing auto-generated documentation files. Expected Outcome: i. Revamp of documentation set information architecture. Alignment with Diataxis framework. ii. Updated contributor docs. iii. All self-documenting aspects accounted for: a. Compatibility tests of Meshery Adapters. b. End-to-end tests of Meshery UI. c. Integration of Meshery Catalog and all designs. d. Publication of community discussion forum activity per category. e. Integration of Meshery Models (Integrations)
Blockchain technology has a wide range of day-to-day applications ranging from electronic voting to supply chain management to financial transactions to healthcare management, energy management etc in a distributed and a decentralized environment. The enterprise blockchain provides transparency and immutability in a permissioned setting. The consensus protocols play a crucial role in establishing trustworthiness within these systems, facilitating secure and reliable operations across various sectors. The seamless integration of Byzantine Fault Tolerance (BFT) further fortifies the trustworthiness of enterprise blockchain. To achieve high security and scalability this project implements the BiniBFT consensus for Hyperledger Fabric, which was successfully innovated and designed after careful research through the CLP 2023 project, BiniBFT - An Optimized BFT on Fabric. This mentorship project highlights the pivotal role of blockchain and BiniBFT in revolutionizing the reliability and security of day-to-day operations across industries, offering a glimpse into the transformative potential of decentralized technologies in shaping the future of sustainable digital ecosystems. The project will start with the implementation of BiniBFT consensus. Both the versions of BiniBFT namely BiniBFT with Random Polling, and The Time-Weighted BiniBFT Consensus protocol will be implemented. The documentation phase will happen along with the implementation to have better clarity for users.
Virtual niche simulations are a powerful tool for testing ecological theory, and nicheR provides an integrated, R-native framework for ellipsoid-based virtual niche construction, prediction, and data generation. This project will deliver a Shiny graphical user interface for nicheR, making these tools accessible to researchers regardless of their programming background. The app will guide users through a complete virtual niche workflow across six tabs: data input, niche design, prediction, bias preparation, data sampling, and reproducibility. Throughout, contextual messages will explain the ecological meaning of key parameter choices, ensuring users understand the theory behind what they are building rather than just clicking through steps. A key feature is that every interactive session generates a fully reproducible R script, so users can transition seamlessly from the GUI to scripted workflows. Deliverables include a fully functional Shiny app packaged within nicheR with a run_app() launcher, test cases for each module, and two vignettes. By lowering the technical barriers to ellipsoid-based niche modeling, this project expands access to rigorous, theory-driven tools for ecologists, conservation practitioners, and students across the R community.
OWTF's current architecture has four systemic bottlenecks: workers that sit idle between single-task fetches, a FIFO scheduler with no priority or adaptive feedback, fragile plugin execution with no retry or timeout control, and an outdated tool ecosystem missing industry-standard scanners. This project replaces the flat task queue with a priority-based adaptive scheduler using a min-heap, where tasks are scored by plugin weight, risk factor, target priority, and a real-time feedback boost that re-prioritizes the queue when vulnerabilities are discovered. The worker model is upgraded with batch fetching, async pre-fetching, dynamic scaling, and target-affinity batching to eliminate idle gaps. A resilient execution harness adds configurable timeouts, retry with exponential backoff, subprocess isolation, and structured logging to every plugin run. Five modern tools are integrated using a self-contained plugin pattern: Nuclei, httpx, Subfinder, Katana, and ffuf. Deliverables: working adaptive scheduler, optimized worker pool, resilient plugin harness, five new tool plugins, HTML reporting with CVSS severity grouping, and comprehensive benchmarks showing measurable improvements in scan time and coverage.
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.
<p>Git has historically had many components implemented in the form of shell scripts. This was less than ideal for several reasons:</p> <ul> <li>Portability: Non-POSIX systems like Windows don’t play nice with shell script commands like grep, cd and printf, to name a few, and these commands have to be reimplemented for the system. There are also POSIX to Windows path conversion issues.</li> <li>No direct access to plumbing: Shell commands do not have direct access to the low level Git API, and a separate shell is spawned to just to carry out their operations.</li> <li>Performance: Shell scripts tend to create a lot of child processes which slows down the functioning of these commands, especially with large repositories.</li> </ul> <p>The goal of this project is to complete the conversion of the remaining parts of <code>git submodule</code> to C, namely, the <code>add</code> and <code>update</code> commands. If possible, I intend to even get rid of the shell script called <code>git-submodule.sh</code> entirely, which currently calls <code>submodule--helper</code> to perform most of the business logic, and instead make <code>submodule</code> a proper builtin in pure C.</p>
<p>Casbin is an authorization library that extends its features to implement Access Control Lists, Role-Based Access Control, and Attribute-Based Access Control models in various programming languages to its clients. Casbin's Core Engine is written in GoLang. Casbin-CPP has obvious benefits of speed and efficiency compared to its implementation in other languages and thus, benchmarking is vital for the project to stand out from the rest. Python is the most versatile as well as the most used programming language and has huge community support. Casbin-CPP has the potential to support new PyCasbin to compound the benefits of both languages through language bindings and extension libraries. Currently, the project uses Microsoft Unit Testing Framework for C++ for testing and Microsoft’s Azure DevOps pipelines for CI. CTest is truly cross-platform and can be configured using GitHub Actions for consistent and better CI.</p> <p>Project Ideas are as follows:</p> <ul> <li>Modernizing the project with C++17 standard and Google’s benchmarking tool</li> <li>Implement Python bindings for Casbin-CPP using pybind11 library</li> <li>Implement testing based on CTest and set up workflows for Continuous Integration through GitHub Actions</li> </ul>
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.
CrashDragon plays a critical role in transforming VLC crash reports into actionable fixes, but current gaps in API consistency, auth-sensitive behavior, and frontend completeness introduce friction in triage and integration workflows. This project is a continuation of prior work and focuses on improving reliability without breaking existing functionality. The approach includes: Reviewing current API and frontend behavior to identify inconsistencies between public routes and /api/v1. Improving the Go backend by standardizing API response contracts, tightening validation, and hardening auth-sensitive mutation paths while preserving backward compatibility. Completing missing frontend surfaces and aligning Vue service-layer logic with typed API contracts to eliminate fragile response handling. The project will be delivered through incremental, review-driven changes with strong regression testing and CI validation to ensure stability. Deliverables: Consistent and well-defined /api/v1 API behavior with improved validation and error handling. Hardened authentication and mutation route reliability. Completed frontend views (stats, symfiles) with contract-aligned data handling. Expanded backend regression tests and improved documentation. Final implementation report and follow-up issue roadmap.
One of the key use cases of blockchain integration is asset bridging: in essence, "locking" an asset (typically, a native coin or token) in a smart contract on its authoritative ledger and making available corresponding, newly minted (wrapped/shadow/...) assets on another. By now, bridging is supported by quite mature solutions in the cryptoworld; however, the same is not true for "consortial" distributed ledger technologies. At the same time, such functionality can be expected to become an important requirement in the not too distant future - Analysing the implementation approaches of standard "token models" (ERC20, ERC-721, ... - as far as this has been already done) in native Fabric chaincode and creating conceptual mappings between standard Ethereum token types and Fabric-native assets (including, but not limited to, the different authentication and authorization approaches). - Creating a brief review of the bridging approaches and mature technologies widely used in the cryptoworld. - Performing a requirement analysis for bridging assets from Fabric to Ethereum-based networks (and back), taking into account that the parties performing the bridging have to be explicitly given permission to do so by an authority and may be subject to regulatory requirements. - Based on the available open-source components, designing and prototyping a Fabric-Ethereum bridge fulfilling the requirements As the proposed project bridges multiple fields, creating a centralized solution.
<p>The emergence of serverless computing moves cloud/edge to the next generation of resource sharing: function as a service. The innovation makes developer released from provisioning, updating, and managing servers under flexible scalability and fault tolerance. Also, the most influential outcome is no computing cost when idle, which is also known as pay as you go model.</p> <p>However, the performance is under critical to be improved, i.e., more servers required in existed serverless platform, high and not predictable round-trip latency, especially under high concurrency and keeping dependable.</p> <p>Here come some places to improvement, including shortened path, performance improvement on invoker, serialization elimination, and scheduling. In the first step, the picked-up topic: <strong><em>work-stealing and priority-based scheduling and direct connection for streaming capabilities</em></strong> will be a great and valuable choice.</p> <p>Goal on this project</p> <ol> <li>Work-stealing scheduling on load balancer.</li> <li>Direct connection for stream support.</li> <li>Priority-based work-stealing scheduling.</li> <li>Comprehensive tests to avoid bugs on concurrency and distributed failure.</li> <li>Performance tests and optimization.</li> </ol>
This project focused in converting the concept of Magic ePaper App into a feature-packed, cross-platform app for personalized ePaper display powered by NFC. Central to it is a robust image editor, developed on the basis of the pro_image_editor package, offering users simple yet effective tools for painting, text styling, and embedding emojis, as well as tuned image adjustment controls. Key achievements encompass the creation of a sophisticated image processing pipeline, complete with advanced dithering filters such as Atkinson and Floyd-Steinberg. Additionally, a dynamic color quantization system was designed, adeptly adapting to the specific palette of the chosen hardware. Importantly, support for a new range of Waveshare displays was seamlessly integrated by harnessing their native SDK; this was accomplished through a Flutter Method Channel coded in Kotlin. In addition to the fundamental editor and image pipeline, new functionality was added directly into the edit experience, such as a flexible Barcode Generator, Customizable Design Templates, and an XBM Export capability. I also established the groundwork for internationalization (i18n) and added out the CI pipelines with GitHub Actions for auto-building and running Integration tests. The project is now an agile and accessible tool that enables users to quickly create dynamic, green content for ePaper badges.
Federated Learning (FL) is a machine learning (ML) approach that allows models to be trained collaboratively and distributedly without sharing individual data points. WebGPU, a modern web standard and API, provides low-level, high-performance access to a device's GPU through web browsers. It aims to enable developers to create complex graphical applications and experiences on the web by utilizing modern GPU hardware for efficient graphics rendering. Due to their extensive usage and customized optimizations, current Federated Learning (FL) systems frequently concentrate on certain device types, such as smartphones or Internet of Things (IoT) devices. Nevertheless, FL's adaptability to other device kinds may be limited by this device-centric optimization, necessitating substantial coding and redesign work to modify FL systems for diverse device types. Because developers wind up building different and fragmented codebases for each device, this method violates software engineering principles of code reusability, making maintenance more difficult and impeding the effective deployment of FL. In this proposal, a novel WebGPU based federated learning network for heterogeneous device network is proposed. The proposal aims to deliver a working federated learning system supported by web browsers along with additional features.
Konveyor provides a unified experience of tools to help organizations modernize their applications at scale, transitioning them to Kubernetes and cloud-native technologies. Recently the Konveyor community began the development of a Generative AI approach for application modernization called Konveyor-AI. Konveyor AI accelerates application migration by discovering migration incidents in the source code and providing LLM-generated fixes in a diff view presentation. When proposed changes are accepted, it provides real-time updates on the number of incidents. The presentation side for this work is currently serviced via an IDE extension for VSCode. We aim to expand Konveyor AI by developing an IntelliJ plugin. Our first step involves integrating the static code analysis tool, analyzer-lsp, into the IntelliJ plugin. We plan to create a common module for interaction with analyzer-lsp, which can be used in multiple IDE plugins, starting with VSCode and IntelliJ. Currently, the IntelliJ IDE uses the Konveyor CLI tool, Kantra, for analysis and transformation, but we need to replace Kantra with analyzer-lsp to optimize real-time updates. Expected Outcome: Define and implement a new module or library to facilitate integration of analyzer-lsp into multiple IDEs. We will start with VSCode and IntelliJ to begin.
<p>Brief Explanation</p> <p>Qt is an open source cross platform framework facilitating GUI applications development, for mobile, desktop and embedded devices. Although the framework is written in C++, it brings with it a meta-language (or modelling language), QML. To accelerate UI development, QML provides the Qt Quick Controls module with ready made widget types, each supported by a C++ class, like Button or Switch, ready to be styled and modified at our project needs. The module is currently on version 2.4 but there is no support for Calendar in the latest version, to be more specific, the Calendar was lastly provided in version 1.4 of the Qt Quick Controls module that was released with the Qt 5.3 version.</p> <p>Expected Results</p> <p>The Qt Calendar widget is updated, modified accordingly and ported into Qt 5.12 and Qt Quick Controls 2 current version following the QtQC2 module standards and supporting all features like styling. The Calendar, ideally would have a Template type where from properties like background and/or contentItem can be set for style customisation & switching support. Also, it should be possible to be instantiated as a standalone QML type and be styled locally for regular usage.</p>
<p>In mathematics and computer algebra, automatic differentiation (AD) is a set of techniques to numerically evaluate the derivative of a function specified by a computer program. Automatic differentiation is an alternative technique to Symbolic differentiation and Numerical differentiation (the method of finite differences). Clad is based on Clang which provides the necessary facilities for code transformation.</p> <p>ROOT is a framework for data processing, born at CERN, at the heart of the research on high-energy physics. Every day, thousands of physicists use ROOT applications to analyze their data or to perform simulations. ROOT has a clang-based C++ interpreter Cling and integrates with Clad to enable flexible automatic differentiation facility.</p> <p><code>TFormula</code> is a ROOT class which bridges compiled and interpreted code.</p> <p>The project aims to add second order derivative support in <code>TFormula</code> using <code>clad::hessian</code>. The PR that added support for gradients in ROOT is taken as a reference and can be accessed <a href="https://github.com/root-project/root/pull/2745" target="_blank">here</a>.</p> <p>Optionally, if time permits, this project will also convert the gradient function into CUDA device kernels.</p>
PETSc, the Portable, Extensible Toolkit for Scientific Computation, is for the scalable (parallel) solution of scientific applications modeled by partial differential equations (PDEs). Besides its native API in C it has bindings for Fortran and Python. PETSc also contains TAO, the Toolkit for Advanced Optimization, a software library supporting MPI and GPUs through CUDA, HIP, Kokkos, or OpenCL. While most of the Fortran interfaces can be generated automatically from the C-API, functions with "complex" arguments such as procedure pointers, pointers to arrays, and strings require the manual creation of interface code on both the C and the Fortran side. Moreover, due to the discrepancy of features between C and Fortran, a one-to-one translation of APIs leads to Fortran interfaces that don't leverage the capabilities of modern Fortran. Examples include overloaded functions for different types in Fortran, for which a C-API requires VOID and an explicit type argument and arrays, for which the length is part of the type definition in Fortran but requires a second argument in the C-API. This project aims to improve the automation of generating Fortran interfaces by leveraging modern Fortran features such as BIND(C) and ISO_C_BINDING along with annotation strategies to reduce the need of manual generation of interfaces. The improved system will enhance both usability for end-users and maintainability for developers.
This is the tentative proposal submission for the Geant4-FastSim - Building an ML pipeline for fast shower simulation. This proposal discusses a detailed approach to implementing the Kubeflow End to End Pipeline for the existing framework. The proposal consists of a synopsis discussing how the proposed approach was thought and what were the key insights that motivated the steps mentioned. It further discusses the task that will be encountered throughout the Project timeline and the Major Deliverables that would mark the completion of the project. The Major tasks have been visited in detail in the proposal and these are used to determine the objectives for the weekly progress timeline in the project. The proposal tries to cover up all the adopted methodology's significant detail and come up with the most ideal way to tackle each and every task. Deliverables: End to End Deployed ML Pipeline on Kubeflow Meta Logger component throughout the pipeline to store and analyze the results Experimenting with existing and new algorithmic approaches that might improve the performance, throughput of the modeling pipeline Creation of a connector component for the transition from training phase into the inference phase. Iterative development of the Pipeline into a generalized workflow that is capable of scaling to newer versions of data as well support the integration of newer algorithmic experimentation Well documented results and analysis for motivating additional focus on the pipeline as well motivating the use of this pipeline for different projects \