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.
NetAnim is a tool used to visualize a node's movement and messages between node's. The current NetAnim module implementation has one severe limitation-It requires events from the node's and the net-devices, and to do so it hooks on several callbacks. The goal of this project is to refactor NetAnim so that each module willing to use NetAnim will have a NetDeviceAnim class responsible for communication with the NetAnim module, enabled only if NetAnim is active. This will break the dependencies and will allow more flexibility for out-of-tree modules and modules migrating to the AppStore.
FakeNet-NG is a tool that is used to simulate the internet which is useful in malware analysis. Currently, FakeNet-NG displays its output by either printing it to the console or writing it to a log file. However, malware with a lot of activity can generate long FakeNet logs. To save analysts from having to read or grep long FakeNet logs, this project aims in providing a user-friendly interface for viewing the output of FakeNet-NG in a more organized and detailed manner. It would also be supported with features like search, filter and copy which would further help the user in generating effective malware reports.
Haptics, as a multidisciplinary field, has applications within the Medical, Consumer and Entertainment domains, to name a few, and despite their widespread presence in our phones to provide the user with a vibrotactile feedback response (a subset of haptics), haptics have very minimally been explored by artists as a tool for authoring immersive arts. The proposed project aims to create low-cost affordable haptic devices with one or mutliple degrees of freedom and authoring tools for artists to implement into their artwork immersive haptics and interactive audio. In the near future, artists can then use the proposed toolkit to benefit from Haptic floors being deployed into immersive art spaces like the Dome at SAT. The authoring tools Feelix, a ”haptic authoring tool developed to support the design and integration of force feedback and shape change in user interfaces”, and ForceHost, a toolchain that uses the functional sound synthesis and processing programming language FAUST that compiles firmware for audio-haptic applications, will be extended for use with the DeformableHapticSurfaces, a work-in-progress and open-source toolkit for interactive multi-linear DoF deformable surfaces, to create and demo the proposed immersive haptic and audio interaction toolkit. Support for audio input will also be added into Feelix potentially with ForceHost as an input modality so that ForceHost developed tools can interface their audio with the Haptic floor.
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.
Parameterized packages will provide users with a simple way to configure many aspects of packages, à la Gentoo USE flags. This project will add two new values to the Guix package record, "parameters" and "parameter-transforms" which will let package maintainers declare alternative versions of packages that will be built with or without specified features. For example, a user running Guix on a server may choose to build their packages without X11 and Wayland support, and they will now be able to do so easily with the help of these parameters. This project will also implement the logic and user interface for parameters, and specify a number of parameter symbols to serve as examples.
The project aims to enhance the experimental PGP/GPG encryption support in LibreOffice by addressing several shortcomings, such as the need to select recipients anew for every save and the difficulty in finding the right keys. The project will also focus on developing smart searching, traversing, and filtering capabilities for large keyrings, as well as adding asynchronous querying for improved performance. The plan involves several steps, including understanding the current implementation of PGP/GPG encryption support, implementing recipient selection for PGP/GPG encryption, developing smart searching, traversing, and filtering capabilities for large keyrings, adding asynchronous querying for improved performance, and finalizing the project.
The vhost-user-vsock Rust application emulates a virtio-vsock device in an external process and provides the hybrid VSOCK interface over AF_UNIX introduced by Firecracker. The goal of the project is to extend this application to support sibling VM communication.
The animint2 Documentation and Bug Fix Project will make the animint2 reference documentation more accessible, fix errors in the documentation, and reduce the number of bugs by at least one.
Calorimeter is one of the most important components of the Large Hadron Collider (LHC) experiments, detecting energy loss of particles after collision. However, current Geant4 simulation of showering process in the calorimeter is inherently slow for large amounts of events, especially after High Luminosity Upgrading in the future. Therefore, generative models and other machine learning techniques can be used to accelerate the Geant4 simulation. This project aims to improve the performances of the current VQ-VAE Transformer for particle showering and explore architectures beyond (VQ-)VAE and/or Transformer, including new position embedding, hierarchical attention, an-isotropic attention, Fourier Transform linear mixer, and etc. We expect to provide deliverables including notes of extended numeric experiment and integrating new models into the project code.
Playground 2.0 is an updated version of the Rocket.chat's Playground, which is an app development platform for creating custom apps and integrations. The new version includes several features to accelerate the development process and make it more visual. The first feature is the addition of an example section, which includes a collection of templates that can be used as a starting point for app development. This will save time and effort for developers who are new to app development and help them get started quickly. The second feature is the implementation of a project concept where multiple screens can be grouped, saved, and revisited at a later time. This will enable developers to work on different parts of the app separately and easily switch between them. The third feature is the use of the flow concept from https://reactflow.dev. This will allow each project to be represented as a flow, with each screen represented by a block. Actions can be connected to other blocks to visualise the app's lifecycle. This will make the development process more visual and easier to understand. The last feature is the ability to "compile the flow" and run it as a demo. This will allow developers to quickly present a mock or app to validate its usefulness. This will save time and effort for developers who want to get feedback on their app quickly. Overall, Playground 2.0 is an app development platform that makes the development process faster, more visual, and easier to understand. It includes several features that will help developers create custom apps and integrations quickly and efficiently.
In an effort to improve current resource utilisation and optimisation, the Tor team is developing a new version of their pipeline (v2.0). This update involves transferring much of the data related to Tor nodes and bridges from files stored on a single server's disk to two separate databases: Postgres and Victoria Metrics. The main objective of this project is to design a RESTful API service using the `actix_web` framework that is going to be integrated in the new pipeline v2.0 to support data retrival from the two databases. In particular, the focus will be on designing the new APIs, its requests, and response formats. The project will also involve defining appropriate endpoints and data models, ensuring scalability, performance, and security. The final goal is to achieve a web service that is going to extend/replace the current onionoo protocol used by stakeholders interested in the status of the Tor network and its individual nodes.
The project aims to develop a Python-to-Python conversor for LabOP-written Laboratory protocols to be executed by Hamilton Machines using PyHamilton as a the main bridge. The project will benefit scientists by providing open-source protocols for replicating experiments through an open-source software stack. PyHamilton is an open-source Python package that allows its user to control Hamilton liquid handling robots without its native software constraints. The Protocol used as model is a DNA purification protocol and its integration with LabOP came to fruition with the goal of making the protocol as reproducible as possible since the translation process can be done in different ways by different sites using distinct machines.
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.