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.
The Virtual Brain (TVB) is a scientific simulation platform that provides all means to generate, manipulate and visualize connectivity and network dynamics of the brain networks. Researchers in Computational Neuroscience use brain network models to understand the dynamic behavior of the healthy and diseased brain, as measured by various neuroimaging techniques such as fMRI, EEG, and MEG. TVB is currently the only neuroinformatics project providing a platform for researchers to work together on modeling studies using brain network models with realistic connectivity. The modeling of the simulations requires datasets generally hosted on data storage platforms like Zenodo, OpenSourceBrain, EBRAINS, etc. One has to download the dataset manually, unzip it and then use it inside the web GUI. Instead of manually downloading and unzipping the data, the project's goal is to have a dedicated framework to manage the downloading and unzipping the dataset from remote sources. Right now, we are focusing on the Zenodo platform, but there are other platforms like OpenSourceBrain and EBRAINS for which we would like to extend the downloading functionality.
Currently, the entire lib_ccx library is written in C with only some parts in Rust. Since using C is incredibly difficult to get right, the entire library can be rewritten in a modern programming language like Rust. This project aims to convert a small portion of the library which has the least dependencies, to Rust.
The aim of this project is to make it easier to use MaveDB datasets for clinical use, as most of the MaveDB datasets are not annotated in a way that allows them to be combined with other genomic data. Datasets in MaveDB will be mapped to the human genome using the GA4GH Variant Representation Specification (VRS). This can be achieved by mapping sequences using alignment algorithms, transforming the results into VRS objects, and validating the results.
Road safety is of utmost importance, and avoiding distracted driving is a critical aspect of maintaining safety on the road. One of the major distractions for drivers is the use of mobile phones while driving, which can be hazardous. Thus it becomes particularly important for mobile apps like enviroCar that aid in driving to offer a hands-free experience to avoid distracted driving. This proposal aims to stabilize and extend the functionalities of enviroCar : Voice Command project, which offers hands-free interactions to the drivers. While the main focus of the proposal remains to implement voice control on every app functionality and stabilize the bot for handling different situations, it also proposes the addition of newer functionalities like a better voice assistant UI, support for Deutsche, and CI/CD pipelines for the backend.
The task is to make cpimport support parquet files as input or design a general framework to add new input formats. Considering cpimport finish its workflow by two stages, read and parse, so I plan to solve this problem from these two stages. For read stage, I will use some external library to help finish reading like `parquet-cpp`, `arrow` and so on. By using parquet-cpp, I can directly read parquet file and by using `arrow::table` I can store data in table format. Later, in parse stage, I plan to use table format data and parse it to insert data into target table. After finishing the task, cpimport can handle parquet file input or other poplular formats like arrow, avro and successfully insert data into the database.
The project will involve the creation of a new package that will provide an interface to query for chemical species and enzymes using the PubChem API. This will then be integrated into the existing library Catalyst.jl to improve upon its functionalities. This will prove in Improved accuracy in identifying chemical species and enzymes in reaction networks. By accessing the vast amount of data in the PubChem database, Catalyst.jl will be able to provide more accurate identification of chemical species and enzymes in reaction networks, reducing ambiguity and improving the quality of results.
The LHAPDF C++ library plays a crucial role in the Large Hadron Collider (LHC) programme by providing it with Parton Distribution Function (PDF) data for both experimental and theoretical calculations. The library's reliability and stability are essential to ensure that the information supplied to the LHC programme is accurate. To ensure that all aspects of the LHAPDF calculations are thoroughly tested, this project aims to implement continuous integration (CI) tests, in GitLab and Cron. These tests will be scalable and will run on a schedule to guarantee the stability of LHAPDF-established behaviours to a high degree of precision. Data from these tests will then be fed into a dashboard on the LHAPDF website, which will work to provide the developers with a bird’s-eye view of the library’s status and performance. This testing and visualisation is aimed at providing the necessary confidence when making new releases and analysing current metrics.
The goal of this proposal is to enhance the Agora Vote Android application by implementing a modern and intuitive user interface using Jetpack Compose and Material Design guidelines, including support for Material You and dynamic color theming. We will also integrate CI/CD pipeline automation and share election results with visualization, improving the overall user experience. The project will take approximately 175 hours to complete, and the expected deliverables include a fully functional and visually appealing Agora Vote Android application with modern design elements, automated release management, and visualized election results.
My objective for GSoC 2023 is to elevate our Mobile Wallet to become a benchmark implementation of a cutting-edge and reliable mobile wallet application, designed specifically for fintech companies. The plan is to enhance its capabilities by seamlessly integrating the newest version of Payment Hub EE, implementing Mifos' recently launched design library, updating the wallet framework to utilize Mifos' Android SDK, refactoring the existing Java codebase to Kotlin, and aligning the overall architecture with the principles of the Open Wallet Foundation Framework. These initiatives will help us create a robust and secure Mifos Pay (v1) that is fully prepared for deployment to our valued users.
This proposal aims to increase code coverage on the DRM core helpers with meaningful tests. Unfortunately, it is impractical to have 100% coverage on all core helpers in such a small time frame, so I will focus on the drm_format_helper.c, which makes the conversion between color formats. Parallel with developing the tests, I will improve the kernel-doc when needed, create blog posts about the process, and study the DRM subsystem. Moreover, with the knowledge gained, I will improve the xfrm functions to work with multi-plane formats.
In this project, we will expand metrics to help users observe the running status of pgmoneta and each server at any time. Additionally, a large amount of numerical data is not convenient for users to intuitively see patterns between data. We will design Grafana dashboard to visualize the collected Prometheus metrics.
My project idea is to extend the Flutter version of Pocket Paint with further functionalities, such as more tools like eraser, line, fill, spray can, and cursor. My expected total time for this project is around 350 hours, and my goal is to implement 1-2 fully tested tool per month.
The wrongsecrets project is structured in two modes the standalone app and the CTF mode. Here we will focus on OWASP/wrongsecrets-ctf-party and how to improve it in terms of infrastructure and deployment.
Scan8 is a distributed scanning system for detecting trojans, viruses, malware, and other malicious threats embedded in files. The system will allow one to submit a list of URLs or files and get the scan results in return. Currently the user interface of this project is outdated and does not support real time data updates from the database. The aim of this project is to resolve the problem of real-time data orchestration by integrating websockets and by updating the user interface to make it more user-friendly
This project aims to create async SFTP client API's for libSSH. Currently sftp_write is the only way of uploading files over SFTP using libssh but sftp_write is a synchronous write. Providing an asynchronous api for upload will make the upload process much more faster. A high level API which will internally use the low level async API for uploads and downloads will also be created which will make uploads/downloads easier for the user and more efficient since the async API is used internally. The set of deliverables for this project will be : a low level async API for writing, a high level API for upload and download, tests for the created API's, benchmark code to analyse performance of the API's, documentation for the created API's.
Project Abstract The project proposes to add new probes to the Plugin Health Score tool. Originally started in 2022 as a part of a GSoC project, this tool determines the health score of a plugin. Probes are the heart of the tool. To extend the work started last year, I propose adding new probes to make the tool more valuable and feature-complete. Project Description Jenkins is an almost two-decade-old open-source project with over 1000 repositories. Plugins bridge the gap between Jenkins and different environments. A project as mature and large-scale as Jenkins requires active involvement from active maintainers. In general, probes serve two purposes within the context of this toolset: To collect the data to compute the score of the plugin systematically. Based on the computed score, the health of the plugin can be determined. Based on the score future contributors, maintainers, and adopters decide which plugin(s) they want to invest their time in. Project Deliverables Designing of the probes Identify the key features and functionality of the plugins. Define the metrics that would contribute to the Plugin Health Score. The more probe criteria the plugin meets, the higher the health score of the plugin. Deciding the probe’s interaction with other probes Determining how the probe would contribute to the score. Adding unit test cases for each probe and scoring implementation. If time permits, I will add integration test cases too. The final delivery would be 10 new probes to the Plugin Health Scoring System. These probes will contribute to calculating the overall health of a plugin. By the time the project ends, the tool will approximately have 24 probes in all (10 new + 14 existing probes) Proposed Implementation Plan - Build each probe, implement it, score it and write its test cases. - Define interaction of probes with each other. - Define execution order of each probe. Stretch Goals - Adding metrics probe - Writing integration test cases
Many members of Google Developers Groups are available on Meetup . So I want to develop a platform which will make developers easily to get all upcoming meets and last 7 day meets . All previous events photos will be available on the app. Maps will show the concentration of the developers globally . User can show all updates on events on the app itself.
The project aims to add new algorithms for computing the greatest common divisor (GCD) of polynomials in the sparse representation in order to improve the speed of many parts of sympy such as matrices, solvers, integration, and simplification functions. Currently, the slow speed of polynomial GCD impacts many operations in SymPy, leading to heavy performance penalties and avoiding the use of domain elements in some algorithms. By improving the speed of polynomial GCD algorithms, many parts of SymPy could become faster, and the use of GCD could become more widespread. This project could significantly enhance the overall performance and usability of SymPy.
My proposal aims to extend Pydra's worker classes to handle a wider range of systems by utilizing PSI/J, which offers a unified API for various schedulers. The objective of this project is to create a Pydra worker class capable of submitting and monitor jobs on different HPC systems, such as Theta, using PSI/J. Furthermore, I intend to use Bokeh to construct an interactive web-based dashboard that will monitor the jobs being submitted and executed by the Pydra worker. The expected outcome of this project is a Pydra worker that can use PSI/J to submit and track jobs on various HPC systems, an updated Dask worker, as well as a jobs monitoring dashboard. The proposed methodology involves designing and implementing the Pydra worker class, evaluating its functionality and performance on various systems, comparing it to existing Pydra workers, and constructing a Pydra dashboard using Bokeh to monitor the jobs. Finally, I will document the usage and installation of the Pydra worker with PSI/J, as well as the Pydra dashboard, and provide users with examples and tutorials. The project timeline includes a community bonding phase from May 4 to 28, followed by an extended coding period from May 29 to September 17.
The implementation of a pgr_ksp() function that can calculate K shortest paths for various scenarios is essential for many applications. This project aims to implement a pgr_ksp function that can handle four more different scenarios that are one-to-many, many-to-one, many-to-many, and combinations of (source, target). By implementing such a function, we can efficiently and accurately find multiple shortest paths for different scenarios and improve the performance of various applications that rely on this functionality.
The aim of this project is to implement an http4s Ember WebSocket client, a pure functional WebSocket client in Scala and integrate it with other libraries in the Typelevel ecosystem. WebSocket is a computer communication protocol that enables two-way communication between a client and a server, which is widely used in numerous applications including messaging and real-time notifications, as well as GraphQL subscriptions and executing commands in a Kubernetes Pod. An Ember implementation of the WebSocket client would benefit from the ability to cross-compile to multiple platforms (JVM, ScalaJS and Native). It would also potentially achieve high performance due to Ember being built on fs2 and thus can take advantage of highly optimized fs2 runtimes.
This project aims to improve the P5.js library by fixing the issue flag on GitHub, adding new features, developing new examples for typography documentation, and interviewing creative coders for feedback. The goal is to enhance the functionality and versatility of P5.js, and ensure that it remains a valuable tool for creative coders and graphic designers.
The overall UI design of Submitty can get a little overwhelming for the general public. Submitty is feature-rich but lacks simplicity for non-technical users navigating the application. The autograding feature of submitty is an important and mature feature allowing instructors to assign points for various checkpoints in the student-submitted code. All the autograding details are contained in a config.json file The autograding configuration is however a little difficult task for non-technical users. They have to make sure that the format is correct and that all the fields are valid, which can be overwhelming. Hence a GUI page can help more people be accustomed to designing their own configuration files. I am willing to introduce some more features in the GUI which will allow richer and greater engagement with the configuration file for the instructors. Additional features Add test cases automatically for programming/non-programming courses. Add plagiarism check of 2 types: 1) student vs student 2) student vs internet Verify if the config file created is valid or not Add a verification process for the input form text field Edit an already existing configuration file with the GUI interface. Deliverables GUI for technical and non-technical interface Plagiarism checker for all categories Additional features implementation (as discussed above) in the GUI Documentation and tutorials for all implemented features
d-SEAMS currently uses an embedded Lua interpreter to provide user interactivity in tandem with YAML inputs for selecting workflows. The project seeks to replace this interface with a Python interface. This is expected to take place in two stages: - Replacing the Lua Interpreter with Python - Binding to C++ classes and functions directly With both of these milestones completed, feature parity will be kept with the existing code while also providing much more flexibility due to the Python library formed in the second deliverable.