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>This proposal consists of a few tasks that implement new features for Kapitan which I believe will add value to the software. Task 1: dependency management With this feature, kapitan users will be able to fetch sources via HTTP[S] and/or git during compilation into specific targets. This will allow them to manage online dependencies much more easily.</p> <p>Task 2: support for Helm chart import This will allow existing Helm users to import their charts into kapitan projects and render the charts together with the values set in the kapitan inventory to compile into a target. This integration will make it easy for users to switch to kapitan from Helm.</p> <p>Task 3: kapitan binary Kapitan exists as a pip package to be used in CLI and as a Docker image. Users have pointed out that having a portable binary for Kapitan would be very helpful. This task aims to meet such needs by packaging kapitan into a static binary with the use of third-party build tools.</p> <p>Task 4: json schema validation for k8s Kapitan, just as it has its own channel in k8s slack community, is used by a large number of k8s users. This feature enables pre-checking of compilation output of k8s configuration files.</p>
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.
Gesture-based music generation has existed for some years now, thanks to software such as Wekinator. However, they use machine learning methods that have been overtaken by recent Deep Learning innovations, and therefore limit the studies that can be carried out on musical creativity and sound/movement interaction. The aim of this project is to use these modern Deep Learning methods to generate music driven by motion capture. The framework consists of 3 distinct modules. Firstly, user gestures are detected using landmarks generated by MediaPipe by Google. Secondly, these landmarks are used to recognize the gesture performed by the user, and generate Open Sound Control (OSC) signals. Finally, the OSC signals are converted into music using Max/MSP. In addition, new gestures can be dynamically added to the framework, with just a few examples, and mapped to new sounds. Deliverables: - Experiment to estimate the appropriate delay between a gesture and the resulting sound/effect. - Framework based on LivePose or Pose2Art using only the gestures predifined in MediaPipe, able to interface the chosen camera and the sound-card - Model based on MediaPipe holistic model to classifiy dynamic gestures - Famework to map gestures to sounds through OSC signals. - Few-Shot Learning-based model to dynamically add new gestures
<p>This project focuses to improve yt's test framework. At present, yt's Python code coverage is only 25% (unit and answer testing) and the test runtime is approximately 45 minutes. The aim of this project is to increase code coverage and reduce test runtime.</p> <p>First, I propose the use of <a href="https://coveralls.io/" target="_blank">Coveralls</a>, which is a tool to monitor the code coverage and is free for open source repositories. This would not only help in analyzing the key areas that need immediate attention for coverage but will also help in maintaining higher code coverage for future developments.</p> <p>yt's test suite could be divided into three areas, namely, Python unit tests, Cython test cases and answer testing. I will enhance the yt test suite by writing test cases for the flows that are not being tested currently. Runtime of tests could be improved by optimizing (or reducing) answer testing and image comparisons tests for visualization and volume rendering modules. This project also focuses on streamlining test cases for different geometries and data styles to improve the runtime of tests. Furthermore, the runtime of test suites varies on Linux and OSX, thereby giving us a scope of improvement.</p>
Prerequisites: Ubuntu and ROS 2 development environment, no need for specialized hardware. Necessary programming skills: Familiarity with C/C++/Python, CMake, ABI/API. Difficulty level: Medium. Potential mentors: Tomoya Fujita Expected size: 100 hours to 150 hours. Expected outcome: A ROS 2 command line interface ros2cli with doctor sub-command and ros2_documentation. Detailed description: Currently, the ROS 2 doctor subcommand, ros2 doctor, is lacking a lot of useful information, such as ROS environment variables, RMW-specific environment variables, and configuration and service information (number of endpoints, QoS compatibility status, etc). This information is really important and useful for debugging issues with ROS 2, and would greatly improve our ability to support issues reported by our user community. In other words, adding this new information to our existing ROS 2 Doctor command would accelerate community communication and make bug reports much more precise! Aligned with ros2cli development, this project also targets the implementation of improved documentation on how to create an issue report with a new issue template. Reference pull requests: Add default github issue templates, add: get clients, servers info
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 \
The study of urban morphology relies on clever abstractions of the built environment into computationally tractable models. One such model, the street network, is a graph whose edges are streets and nodes are street intersections. Network analysis tools are often tailored for street networks with the purpose of routing. In shortest path computations, network data must carefully reflect not only urban infrastructure but also the intricacy of transportation policies–such as multiple lanes and traffic direction. From the perspective of urban morphology, these features add noise to the geometric order of cities. Perpendicular two-lane streets cross in four intersections, producing a dummy city block, for example. Street networks carefully processed to answer pressing accessibility questions are not suitable for morphological analysis. We would like to develop source-agnostic functions to process street network data for meaningful morphological analysis. The final network should be, at least, free from multiple nodes representing the same intersection and multiple edges representing the same street. This processing must rely on inherent network properties such as node connectivity and edge lengths, but not on auxiliary data such as OSM tags and building footprints. The functions will be collected under pysal’s momepy module, added to an existing toolbox of scalable urban morphological analysis.
This project adds proper role-based access control to istSOS4 by making the web administration interface reflect the permissions already enforced in PostgreSQL through Row-Level Security (RLS). Right now, the backend enforces access correctly, but the UI does not — every user sees the same controls. This project fixes that. Each role (administrator, editor, viewer, sensor) will only see the pages and actions they are allowed to use. It also simplifies user and policy management by removing the current two-step workflow. Creating or updating a user will automatically apply the appropriate policies, reducing configuration mistakes and making the system easier to operate. To support real deployments, the project adds basic observability and debugging tools. A permission matrix shows what each role can do, and audit logs record access-related events. In addition, small utilities like permission explanation, access simulation, and change impact preview help admins understand and verify changes before applying them. The project also explores integration with external authentication providers (OIDC) so istSOS4 can work with single sign-on setups, including Grafana, without changing how permissions are enforced. Overall, the focus is to make permissions visible, predictable, and manageable for administrators.
The objective of this project is to create a comprehensive Python tutorial on G-API, a graph execution framework for OpenCV. The tutorial will cover fundamental and advanced concepts related to G-API, such as defining and executing graphs, developing custom operations and kernels, and utilizing numpy inter-op. The anticipated result is a series of new tutorial chapters integrated into the OpenCV documentation, ideally structured in a similar format to the existing documentation. This tutorial will enable users to leverage the power of G-API more effectively, along with optimized image processing tasks and improved performance. The G-API framework, developed by OpenCVQ, is designed to streamline image processing algorithm flow. Its primary objective is to create graphs that can support multiple backends, resulting in lightweight and fast image processing tasks. For instance, when running the algorithm flow on a GPU, optimized video memory access can reduce system overhead and enhance computational speed. To use G-API effectively, it is essential to (1) understand the framework's overall architecture and features, (2) compare its processing algorithms to those of other common frameworks, identify the unique benefits of each G-API function, and (3) combine these advantages and new features to enhance existing tutorials.
Verilator, an open-source Verilog emulator, is a well-established and community-supported hardware verification tool. It is widely used in developing and testing RISC-V CPU RTL designs. Rocket, CVA6, BOOM, and most other RISC-V RTL designs in the RISC-V Chipyard toolkit lean on Verilator to emulate their respective designs. A common requirement in hardware verification is the ability to access the value of hardware elements and registers during live emulation. The Verilog Procedural Interface (VPI) is an interface that enables this ability. It is defined under the IEEE 1364 and IEEE 1800 standards. Two of the functions provided by VPI are “vpi_get_value” and “vpi_put_value”, these are the sole function that allows C/C++ code to access Verilog scalars during live emulation. Currently, accessing elements within an array requires the use of iterators and consecutive calls to these functions. This poses a high-performance cost when attempting to validate the contents of large arrays. However, IEEE VPI standard does define “vpi_get_value_array” and “vpi_put_value_array” functions, which allow C/C++ code to access verilog arrys with a single call. These functions are unimplemented in the latest version of Verilator and depending on their implementation, may be used to access arrays with less memory utilization, fewer instructions, and faster emulation time.
CAPA is the FLARE team’s open-source tool to identify program capabilities using an extensible rule set. Each rule is matched against features that CAPA extracts from a program. Extracted features include file-level features such as strings, section names, imports, and exports and function-level features such as API calls, string and byte references, instruction mnemonics, and number constants. CAPA uses feature extractors, called "backends", to extract features from supported file types (PE, ELF, and .NET) and architectures (32- and 64-bit x86). Each backend is built around an existing tool or library that provides file parsing and disassembly capabilities. CAPA uses this to extract features. CAPA currently implements backends using Vivisect, IDA Pro, and dnfile. Ghidra is a popular open-source disassembly framework with a robust API to access its analysis. Programs can interact with a wealth of information that includes parsed file formats and disassembled code. The goal of this project is to develop a Ghidra backend for CAPA using Python 3 (via Ghidrathon) and Ghidra’s scripting API. Users should be able to invoke CAPA such that it uses Ghidra’s analysis engine and/or invoke CAPA from within Ghidra.
This project develops an AI-powered desktop application for real-time traffic monitoring and intelligent automation. It detects vehicles, pedestrians, and traffic violations (e.g., Red-Light jumping, Improper Stopping Over Crosswalk at RedPedestrian Right of way Violation Detection) across multiple intersections, providing actionable insights for smart city traffic management. The system leverages YOLOv11 for object detection, trained on a combination of synthetic and real-world traffic data. Synthetic scenes are generated using CARLA, ensuring robustness under diverse and challenging traffic conditions. Detection models are optimized with OpenVINO for deployment on edge devices such as CPUs, integrated GPUs. A desktop dashboard built with PySide6 (Qt6) provides live video feeds with detection overlays, multi-camera support, and performance metrics. Multi-object tracking is implemented using ByteTrack for persistent identification of vehicles and pedestrians. To enhance scene understanding, Vision-Language Models such as Mistral is integrated, generating concise textual summaries of traffic patterns and contextual information for detected violations. Real-time analytics, IoT integration with MQTT, and visualization via InfluxDB and Grafana enable actionable insights for urban planning and automated law enforcement.
OCSMesh is a Python package designed for generating unstructured meshes tailored to ocean modeling. However, its current workflow, particularly the Digital Elevation Model (DEM) processing and JIGSAW mesh generation steps, remains highly time-consuming and not well-optimized for High Performance Computing (HPC) environments. To address this bottleneck, I propose introducing parallelism into the most computationally intensive stages of the workflow: DEM processing and JIGSAW-based meshing. My approach involves leveraging parallel computing libraries such as Dask and mpi4py to scale these operations across multiple cores and nodes. For the preprocessing stage, several components are already optimized for single-node performance and can be extended to work efficiently in an HPC setting. Regarding JIGSAW meshing, I plan to implement a domain decomposition strategy, partitioning the domain into smaller subdomains that can be meshed independently in parallel. These subdomain meshes will then be seamlessly merged to form the final unified mesh. This parallelized workflow is expected to dramatically reduce mesh generation time, enabling more scalable and efficient processing for large-scale ocean modeling tasks. I aim to integrate mpi4py support into the key functions across the codebase, while using Dask specifically for raster windowing and DEM data handling.
<ol> <li><p>The new admin tools will identify the data quality issues in the database and allow Open States admins to know about the current status of quality of scrapers and to manually fix or modify the data quality issues or mark them as exceptions. These tools will also provide admin the right to consider the requests posted by the users to report any wrong or missing information on openstates.org. This will supports Open Civic Data Backend with important features like,</p> <ul> <li>Common Status Page for all states containing current status of different parameters</li> <li>Sub pages for status of specific sessions/states etc.</li> <li>Name Resolution Tool</li> <li>Merge Tool</li> <li>User Feedback Tool</li> <li>Data Quality Issues & Exceptions Tool</li> <li>Retirement Tool</li> <li>Advanced filters to sort data accordingly</li> <li>Fast search queries using Django-ORM</li> </ul> </li> <li><p>Pupa Conversion of Scrapers from Billy and Fixing bugs & updating scrapers for different states.</p> </li> </ol>
I would like to be a part of drupal.org in GSOC. The project Decoupled menus for Drupal. Which is the concept of making Drupal combined with New technology react. The two use cases which were used in the description were much interested. I was learning with the react over the past 10 months. So I would like to solve the problem in a good manner like combining the react with PHP or Python. So, First of all, they asked us to build a menu section that should be globally active around the other pages. This can be done by the react components. Which I had the idea of doing it. In the second use case, they asked to create a menu(s) that changes from page to page like the "Content Moderator Shortcuts" menu to the "moderator" role. Which we can implement with React router dom. But the main task of this objective is to combine the react with drupal. While we know Drupal still serves as a backend repository, front-end frameworks can talk to the database via API calls. By making the Make a stand-alone front-end and using drupal to create APIs which interact with the database. Then consume the API through HTTP AJAX or whatever mechanism React Js contains. Yeah, while coming to symphony it's been a task for me to learn it for using it as a framework. I have already had a little experience with the laravel framework. I am keen interested and fully fledge to be a part of this project.
<p>Zulip provides powerful utility for bots and integrations, but parts of the system (like embedded bots) are still work in progress. To encourage more users to use the bots and integrations, and to also foster a better development experience with bots and integrations, this project aims at implementing better UI for the users to browse through available bots with verbose description, provide more developer-friendly interfaces for creating bots, and other related tasks to improve the bots system.</p> <h4>Improve the UI to Encourage Bot Usage</h4> <p>Display a list of available bots for all users and show accompanying descriptions or help messages. This sub-goal will be aiming at improving the UI to show more information about the bot.</p> <h4>Encourage Error Handling for Bots</h4> <p>Propose a way to raise custom errors from the API layer instead of leaving the error message from the server as is (e.g. {“result”: “error”, “msg”: “foobar”}) and requiring the developers to parse the error message to handle cases of error.</p> <h4>Create Standard for Bots Handling Commands</h4> <p>Support standard commands while keeping our layer of bot as thin as possible and allow standardized metadata to describe the behavior of our bots.</p>
Can we make ChatGPT write chaincode for us? Automated programming for other blockchain platforms is an already emerging topic, but Fabric has not been really addressed yet. This is an experimental mentorship with equal weight in research and hands-on coding, with the following goals. - To review existing examples and approaches of automated programming for smart contracts of other platforms (i.e., Solidity). - To explore the technically feasible options of automated chaincode programming for Hyperledger Fabric (incl. ChatGPT) and select one for further work. - To formulate a chaincode specification style which “seems to work well enough” on a set of representative examples with automated programming. (We don’t know yet what will work; One-shot or iterative? Requirement set or Behavior-Driven Development (BDD)? Conversational or formal specification? And so on.) - To create support for translating the specification partially or fully to runtime verification code, which can wrap the chaincode implementation. On the last point: starting from a specification is a tried and tested way to create verifier code either manually or automatically and is much easier to do correctly than creating the implementation correctly from a specification. We plan to keep this last point “classic”: i.e., no ChatGPT here. Specification-based verification criteria are usually amenable to development time verification, too (with static analysis, model checking, etc.).
The proposal outlines a comprehensive plan to enhance the model's accuracy and efficiency, coupled with new user interface (UI) integrations. First, the optimization of machine learning and statistical models will focus on Exploratory Data Analysis (EDA), feature reduction, feature engineering, and employing better imputation techniques for handling missing data. This will streamline the process and improve model performance. Additionally, fine-tuning a rule-based system will involve adjusting and normalizing feature weights, alongside providing users with tailored recommendations based on our analysis. Another key objective is the integration of new datasets. Currently, each dataset requires different handling, and by incorporating a new dataset, we aim to deliver more refined insights. To address data imbalance, techniques such as minority class upsampling and additional data generation methods will be applied. This ensures the model can better handle unbalanced data distributions. Fraud detection is also a critical focus, with plans to identify suitable datasets and initiate the development of robust fraud detection capabilities. Lastly, improvements in federated learning will be made to ensure data privacy and efficiency, allowing the model to learn from decentralized data without compromising individual data security.
<p>IMPACT User-friendly QA platform for a given DBpedia resource and specifically about pandemic in real-time.</p> <p>GOALS To improve the DBpedia Sparql for real-time monitoring of pandemic situations near the users and the interested country by the users. Compile pandemic data and wikidata for answering users' questions by query databases, and support research and development in the healthcare field related to model predictions and vaccine development.</p> <p>DESCRIPTION As Google engine can answer any question, DBpedia Sparql can query databases and answer questions using Wikipedia resources. The COVID-19 pandemic is an ongoing global pandemic, and humans would need to co-exist with the viruses. We should compile the public wikidata related to coronavirus and learn from them. The aim of this project is to update DBpedia Sparql tool for answering questions related to wikidata and specifically about the coronaviruses. Thus, the improved DBpedia Sparql tool would provide better understanding of the coronavirus pandemic for the public, and serve as a platform for research and development in the public healthcare field.</p> <p>WARM-UP Git repo: <a href="https://github.com/guang-zh/coronavirus_info_app.git" target="_blank">https://github.com/guang-zh/coronavirus_info_app.git</a></p>
<p>Inevitably new and prospective Haskell users will attempt to obtain editor/IDE integration for Haskell but unfortunately they are much more likely to fail than to succeed due to the less than ideal state of the tools.</p> <p>Haskell downstream tooling is simply in a bit of a bad place at the moment. Things have always moved fast in GHC land but recently things got a lot worse for tools when the release frequency increased from every-two-years to every-six-months.</p> <p>As if that weren't enough, Cabal -- the main Haskell build tool -- is almost ready to switch over to the long awaited Nix-style new-build commands. This switch brings with it a major change to how tooling has to interact with the build system.</p> <p>Bad tooling is a major source of frustration for new and experienced Haskell users alike. This proposal will substantially improve the reliability, performance and maintainability of tooling efforts.</p> <p>This proposal consists of three main areas:</p> <ol> <li>Improvements in GHC to reduce friction for downstream tooling efforts</li> <li>Work on cabal-helper to enable easy new-build support</li> <li>Integration of the above into Haskell IDE Engine</li> </ol>
<p>Project Details: YooHoo, is a interactive chat engine, which supports text, audio, video chats and file sharing. It is to facilitate one-to-one chats, group chats, create events and manage them online(assign tasks and schedule deadlines etc). It has also got a integrated set of bots, for mainly connecting with wiki.debian.org, packages.debian.org etc to provide instant help for queries, suggest apps etc. It also include provision for creating new bots using custom codes. The main aim of YooHoo is to create a collaborative environment for those who are working on Linux systems. With its in-build bots it can provide live assistance to users, suggest the best apps available for his needs, get latest releases and news, which can improve user experience a lot.</p> <p>Benefits to Debian: Will help to provide automated help to its users (by the bot) as well as ask new queries, report bugs etc, thus bridging the gap between a normal user and Debian system.</p> <p>Why Debian?: Well, Once you start exploring her, your curiosity never ends. Of all the other distros I have used, I learned more on Linux by using Debian. She is simple, minimalist and is highly educative in a learn by doing approach.</p>
Oppia Android's release process currently relies on a 17-page manual document that release coordinators follow step-by-step, covering everything from cutting branches and building binaries to signing, deploying to Play Console, and writing changelogs. This is slow, error-prone, and has caused QA testers to miss builds due to Play Store sync issues. This project replaces that manual process with six GitHub Actions workflows backed by Kotlin scripts that handle building, Cloud KMS signing, Play Console deployment, Firebase App Distribution for QA, LLM-powered changelog generation, and automated weekly alpha releases. All scripts are designed with interface-based abstractions (CloudSigner, PlayConsoleClient, VertexAiClient, GitHubClient) so they can be thoroughly unit-tested with fakes, requiring no real GCP credentials in tests. Security is handled through Workload Identity Federation (keyless auth) and Cloud KMS HSM-backed signing, ensuring the private key never leaves Google's hardware. Deliverables: 6 new Kotlin scripts with full test coverage, 6 GitHub Actions workflows, updated wiki documentation (playbook + manual fallback reference), and an end-to-end demo of the complete release cycle running through CI.
<p><em>The aim of this project is to implement a backend for museums & exhibits that utilizes Physical Web technology. </em>The backend will allow visitors to access information about exhibit pieces without the need to install any apps. Physically, this will be accomplished using Eddystone beacons located near each piece. We focus on developing the software used with the beacons.</p> <p>To achieve this, we will create an Android App that allows museum curators to configure Physical Web beacons they want to deploy and upload the content that will be served. The app will support combinations of text, images, audio and video - it will use Google Drive for its storage backend. The app will also allow the curators to create a map of the exhibition & beacons - also stored on Drive.</p> <p>Once activated, the beacons will direct visitors to the URI of a webapp that we will also develop. The webapp will run on a server that connects to the Google Drive folder created by the Android app. This webapp, run on the museum’s servers, will use the map along with Web Bluetooth technology to learn the user’s location (by listing nearby beacons and their signal strength) and display to the user the content most relevant.</p>