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 primary objective of this proposal is to: 1. Enhance the user interface for new designs in Tailwind, thereby optimizing the user experience. In order to achieve this, we will be developing APIs for BLT Flutter, which will provide greater flexibility and scalability to our system. 2. Additionally, I plan to implement an independent blockchain, which will enable us to create our own cryptocurrency, BACON coin. This will allow us to incentivize our testers whenever they receive likes on the bugs they post, thereby driving greater engagement and participation on our platform.
During my project, I will successfully implement a module for Correlation-Tensor Magnetic Resonance Imaging (CT-MRI) in DIPY, which provides advanced diffusion acquisition techniques for characterizing healthy and pathological brain alterations. This implementation is significant because DIPY previously provided limited modules to process this type of diffusion MRI data. By expanding DIPY's capabilities, researchers and clinicians can now gain unique insights into tissue microstructure, making DIPY a more complete and useful tool for a wider range of MRI data users.
Goal: ○ To add a Terraform module for SkyWalking deployment to facilitate users in conveniently spinning up a cluster for demonstration or testing. ○ To allow users to customize the Terraform provider according to their needs, making it feasible for them to use it in their production environment. ○ To mainly focus on the support for AWS in the Terraform module for SkyWalking deployment. ○ To provide a hassle-free solution to users where they only need to provide their access key/secret key, and the Terraform provider does the rest of the work, which includes creating VMs, creating database/OpenSearch or RDS, downloading SkyWalking tars, configuring the SkyWalking, and starting the SkyWalking components (OAP/UI), creating public IPs/domain name, etc.
Teuthology commands, in general, require a bit of a learning curve and usually requires someone who's a veteran with teuthology to help out, this can interrupt the productivity of the engineering team. The complexity of teuthology can lead to new users scheduling bad runs that can hold up the queue and block other jobs. By creating an API and integrating it with Pulpito, developers can directly schedule or kill jobs without SSH-ing into teuthology through the website. The API will have endpoints based on the teuthology modules, and widgets for login, logout, scheduling and killing job(s) will be added to Pulpito.
The goal of this project is to make the Rust language available on the GNU/Hurd operating system. Currently, there is no official Rust support for GNU/Hurd, which limits developers' ability to build high-performance, safe, and concurrent software on this platform. The Rust language is increasingly being used in fundamental libraries such as librsvg and python-cryptography, so it is crucial to have a compiler for Rust on GNU/Hurd. The Rust compiler is portable, but its runtime library, libstd, needs to be ported to GNU/Hurd. This involves telling Rust how to call standard C library functions, which can be generated from libc C headers using the bindgen tool. The proposed solution involves creating a new Rust target for GNU/Hurd by investigating the system calls and interfaces available in GNU/Hurd and adapting Rust's code generator to generate code that uses these interfaces. The project aims to optimize Rust's performance on the GNU/Hurd platform by identifying performance bottlenecks and implementing improvements where necessary. The deliverables of the project include the Rust-GNU/Hurd toolchain, which comprises the Rust compiler and libraries, documentation, and optimized performance of Rust on the GNU/Hurd platform. The project also includes researching the GNU/Hurd system, identifying the system calls and interfaces that Rust will need to use, and creating documentation for the Rust-GNU/Hurd toolchain.
This project aims to enhance the functionality of the pgr_withPointsDD function in pgRouting by improving the 'driver_side' optional parameter, adding a result column and normalizing the output. And all overloads will be implemented(Single vertex & Multiple vertices). The pgr_withPointsDD function modifies the graph to include points and using Dijkstra algorithm, extracts all the nodes and points that have costs less than or equal to the value from the starting point. The edges extracted will conform to the corresponding spanning tree.
Blender supports video editing through its video sequence editor. While the editor allows users to load videos and audio files, computing the audio waveforms for the audio tracks can take a really long time when working with large files (multiple gigabytes). This makes for a degraded user experience. This project will reduce the time taken to see the waveforms by: ● Processing multiple audio sequences in parallel in the background, ● Only computing the waveforms of sequences that are visible in the user interface Once these initial speed ups are achieved, I'll explore improvement opportunities lower down the audio processing stack.
The project aims to set up a code coverage metric with additional unit tests to test the GWT client code. We will be using Jacoco a as code coverage metric and writing the Junit tests to unit test the GWT client code.
The proposed project aims to enhance the ns3-ai module, which provides interfaces between ns-3 and Python-based ML frameworks using shared memory, with a focus on performance optimization and expanding the range of supported data structures. To achieve this, the project will introduce APIs for additional data structures like vector and string in shared memory IPC to reduce the interaction between C++ and Python. Additionally, the project will provide examples demonstrating how to implement ML algorithms within ns-3 using C++ and open-source frameworks such as TensorFlow and PyTorch. The project will also improve the current examples and documentation and integrate new examples, such as LTE handover. Overall, the project aims to expand and accelerate the capabilities of the ns3-ai module, enabling users to simulate and analyze large-scale networks with greater efficiency and flexibility.
Link Time Optimization (LTO) enables GCC to dump its internal representation (GIMPLE) to disk so that a single executable can be optimized as a single module. The current implementation creates an assembly file, and the assembler is used to create the final LTO object file. This project aims to create Link-time-optimization (LTO) object files directly from the compiler to improve compile time performance significantly by bypassing the assembler. The GCC's LTO infrastructure has matured enough to compile large real-world applications. Thus, this project will significantly reduce their compile time once completed.
The International Neuroinformatics Coordinating Facility (INCF) is a non-profit organization dedicated to advancing the field of neuroscience and neuroinformatics. They strive to establish and promote standards and best practices that are open, fair, and citable. INCF provides resources and support to neuroscience researchers, labs, and partners worldwide. Their work encompasses a wide range of projects, including predicting Alzheimer's onset, detecting cancer cells through image processing, mapping the brain in 3D, developing connectomes, and analyzing EEG data. Our proposed project aims to create a comprehensive dashboard showcasing INCF's impact on the global neuroscience and informatics community. The dashboard will highlight important metrics such as research progress and the number of lives impacted and saved.
This project aims to enhance the SPDX Online Tool by improving its functionality and efficiency for license submissions. The project proposes adding features such as automatic creation of pull requests and .txt test files, improving error handling, adding unit tests and GitHub API interaction tests with mock, and creating a base reusable Django app to reduce development efforts. The objective is to streamline the license submission process, reduce manual effort, save time, and enhance productivity. The project proposes clear deliverables such as generating a .txt test file, differentiating exceptions from license submissions, adding or fixing unit tests, and improving error handling. The project will contribute to the open-source community and will provide a learning experience for the software engineering student working on the project. The choice of SPDX as the organization to work with is motivated by its mission to create a standard format for communicating the components, licenses, and copyrights of software packages and its strong community of developers, contributors, and users committed to driving innovation in the field of software licensing.
Virtio-net device uses Control Virtqueue(CVQ) for changing device parameters. For some devices, such as vDPA, its CVQ is passed from Guest’s driver directly to Host driver, which makes it difficult for QEMU to track the status of these devices. To solve this problem, QEMU introduces Shadow Virtqueue(SVQ) for vdpa device, which shadows the CVQ via QEMU instead of being assigned directly to Guest. During QEMU Live migration, to restore the vdpa device in the destination VM to the state in the source VM, SVQ can use CVQ’s interface and send the state as regular CVQ commands. Due to some CVQ commands for vDPA are missing at present, this project aims to achieve support for a subset of CVQ commands, including VIRTIO_NET_CTRL_RX family commands, VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET command, VIRTIO_NET_CTRL_VLAN_ADD command, VIRTIO_NET_CTRL_MQ_HASH_CONFIG command and VIRTIO_NET_CTRL_MQ_RSS_CONFIG command for vDPA.
The objective of the project is to develop a Chrome extension with the purpose of identifying fraudulent information, thereby enhancing online safety and fostering greater productivity for internet users. The project entails a series of stages, primarily focused on the utilization of Natural Language Processing methodologies. During this season, a context detection functionality will be integrated, leveraging the capabilities of the GPT-3 API to provide users with comprehensive insights into news articles, empowering them to make well-informed decisions. The final output will be the updated web service and extension, which will be ready for publishing. The project also aims to enhance the SSL validator and Security Header to ensure maximum security. To achieve this, the codebase will be migrated from Manifest Version 2 to Manifest Version 3, and the model must be integrated into the Chrome extension. The final product will provide users with a reliable tool to identify fake news and ensure that they receive accurate information while browsing the internet.
The primary objective of this project is to enhance the testing framework and testing ideology by utilizing mocking techniques. The intention is to get rid of the existing binary rpm packages . This project aims to mock all the 132 binary rpm packages used exclusively for testing purposes in the rpmlint repository, which will significantly improve testing speed and facilitate easy testing development. To achieve the project's goals, I will collaborate with my mentor and devise a strategy for mocking the binary packages using the pytest framework. The deliverables for this project include a redesigned testing framework that is more efficient and reliable than the existing one. Additionally, the project aims to mock all the existing binary packages, which will help streamline testing processes and accelerate software development. Deliverables: 1. Coming up with redesigned testing framework using mocking strategy. 2. Mocking all the existing binary packages
The world of JSON Schema is immense. JSON Schema tooling exists in countless languages across a variety of uses (data validation of course a noteworthy and prominent one). Implementing the JSON Schema specification(s) in a fully compliant way is not without challenge, meaning as a user of JSON Schema it is important to understand how a particular implementation may deviate such that one can make constructive tooling choices or help implementations improve. Bowtie is a recently created tool to aide in this task, helping to surface the conformance of various JSON Schema tools with the specification by running them against a set of known correct test cases and regularly rendering the results to a web page. But it can do more! Expected Outcomes: Enhance (or replace) Bowtie's simplistic current UI so that it most easily answers "what do various implementations say about each test case" -- making it snappier and more featureful Add support for further JSON Schema implementations by creating Bowtie harnesses in additional languages Teach Bowtie to compare not only True/False validation results but also the full JSON Schema standardized output formats
This project aims to simplify the contribution process to GitLab by creating a detailed report for developers using both local and cloud-based Integrated Development Environments (IDEs). The report will identify areas where the process can be improved, and the mentee will work to address 20% of the identified gaps. The ultimate goal is to enhance the contribution experience and make it more inclusive to a broader community of developers. The project can be broken down into 3 parts Research and analysis: Aims at conducting a user research to understand the contributors journey to Gitlab. A user can contribute to gitlab in many ways through Development, Documentation, UI/UX , translation etc. main work would be to identify the contributors journey in each of those. Addressing gaps in the contributor journey Creating a list of identified gaps and discussing a way to tackle those gaps. Improving the Onboarding process Contributing to Gilab can be overwhelming, this aims at identifying the hurdles that a new contributor faces and come up with an idea to improve the process.
Mifos Mobile is an android application designed for client use, which facilitates user authentication, account information viewing and editing, as well as internal transactions and repayments. In my proposal I've mentioned 4 additions to the current Mifos Mobile application. 1. Replacing the current API layer from self-service Fineract APIs to Open Banking APIs 2. Providing the user 24/7 customer chat support using RocketChat 3. Integrating external payment system, Mojaloop via the Payment Hub. 4. Covering all the screens with UI tests using Espresso. The proposed enhancements to Mifos Mobile application are expected to have a significant positive impact on the user experience. By replacing the existing API layer with Open Banking APIs, clients will be able to enjoy seamless and more secure transactions. The provision of round-the-clock customer chat support through RocketChat will ensure that users receive prompt assistance whenever they require it. Integration of Mojaloop through the Payment Hub will enhance the application's payment capabilities, and it's reach. Lastly, the coverage of all screens with UI tests using Espresso will improve the overall reliability and robustness of the application, leading to increased user satisfaction.
Summary of the Development of Dubbo Admin Dashboard UI Pages: Firstly, I analyzed the specifications of the previous code in order to facilitate subsequent development and maintenance.Secondly, I optimized the functional modules that had already been implemented, and further upgraded some functions to make them more user-friendly.Finally, and most importantly, I analyzed the requirements for the new function, read through interface documents, implemented the interface, performed data joint debugging, and ultimately completed all functions and tested their functionality.
In Just-In-Time compilers we often choose a low optimization level to minimize compile time and improve launch times and latencies, however some functions (which we call hot functions) are used very frequently and for these functions it is worth optimizing more heavily. In general hot functions can only be identified at runtime (different inputs will cause different functions to become hot), so the aim of the reoptimization project is to build infrastructure to (1) detect hot functions at runtime and (2) compile them a second time at a higher optimization level, hence the name "re-optimization". There are many possible approaches to both parts of this problem. E.g. hot functions could be identified by sampling, or using existing profiling infrastructure, or by implementing custom instrumentation. Reoptimization could be applied to whole functions, or outlining could be used to enable optimization of portions of functions. Re-entry into the JIT infrastructure from JIT’d code might be implemented on top of existing lazy compilation, or via a custom path. Whatever design is adopted, the goal is that the infrastructure should be generic so that it can be used by other LLVM API clients, and should support out-of-process JIT-compilation (so some of the solution will be implemented in the ORC runtime).
This project’s goal is to improve the accuracy of Fossology’s copyright detection system using machine learning. This functionality was originally implemented in 2021 to improve the two-step process of copyright detection used by most copyright detection software; using Regex and then human intervention. The machine learning approach uses Named Entity Recognition (NER) and Part of Speech (POS) tagging to figure out which statements contain copyright and which do not. I’ll be working on improving all parts of the project; starting from the dataset & preprocessing, then working my way to the NER hypothesis until the machine learning model used and the final integration.
This project aims to modularize Fineract, an open-source financial services platform, by creating independent Java libraries that can be used be used by developers. Fineract manages clients, transactions, accounts, and other financial activities for financial service providers. It is designed to be robust, reliable, and customizable, allowing for integration with third-party systems. As the software has evolved over time, it has become increasingly complex and monolithic—leading to the need for this project.
The project this document proposes is that of implementing the hash map structure described in high level detail in the article Hash Maps That Don’t Hate You (https://blog.toit.io/hash-maps-that-dont-hate-you-1a96150b492a), an elegant variation over standard open addressing hash tables that, instead of storing the Key-Value pairs themselves in the array backing the hash table, it stores indices into yet another insertion-ordered backing array. This allows us to have our cake and eat it too : we get insertion-order iteration while still maintaining most of the desirable performance guarantees expected from hash tables, with reasonable implementation complexity. Deliverables: A build of truffleruby with a Hash implementation as described in the article, supporting all standard Ruby Hashes operations (as of Ruby 3.1) and hopefully faster and\or more memory efficient than the current implementation of Hashes in truffleruby.
Mifos Mobile is an android application built on top of the MifosX Self-Service platform for end-user customers to view/transact on the accounts and loans they hold. Data visible to customers will be a sub-set of what staff can see. The project aims to update and improve the technology stack of a self-service Fineract API system by migrating to Open Banking APIs, implementing Hilt for dependency injection, and adopting MVVM-Clean architecture with Navigation Graph and Coroutines. The project also requires integration with an external payment system such as Mojaloop or mPesa and unit and UI testing. The deliverables include an updated and efficient project with improved functionality and performance, Github workflows, and continuous integration and delivery.