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.
Convolutional Neural Networks require large receptive fields in order to track long-range dependencies within an image, which in practice involves large kernels or long sequences of convolutional layers at the cost of losing efficiency. The problem can be mitigated by using Equivariant Transformers. Attention layers can directly replace the convolutions, so they will be able to attend to a larger receptive field than regular convolutions. In addition, the equivariant part of the model can replace the manual augmentation applied on every batch during training.
The minimum constituent parts of an overall Software Bill of Material (SBOM) – referred to as NTIA’s minimum elements – are three broad, interrelated areas (Data Fields, Automation Support, and Practices and Processes). These elements will enable an evolving approach to software transparency, capturing both the technology and the functional operation. The purpose of this project is to check if an SBOM document contains the minimum required data fields such as the supplier name, component name, component version, unique identifiers, dependency relationships, author of the SBOM, and timestamps.
1. Add etcd adapter and redis adapter to improve compatibility 2. Implement the pycasbin-on-cpp to improve performance and add RBAC API to benchmark the casbin(go version) 3. Introduce Django's various components to make pycasbin easier to use
Chromium’s multi-process architecture requires a mechanism for safely communicating between its processes. This requirement is addressed by Mojo - an IPC (inter-process communication) framework that uses the Mojom IDL (interface definition language) to describe interfaces, collections of messages and data structures. The goal of this project is to improve security by introducing a new fuzzing technique - snapshot fuzzing, as an improved alternative to existing fuzzing techniques.
Adding a database abstraction layer for better code maintenance, then using this new layer to add Multi-Tennancy support for the API using data segregation method by creating one database per admin, also adding configuration capabilities to the admins using the new Multi-Tennancy support and finally changing the front-end to be able to use all these new configuration options.
Switching to Conscrypt, simulating the security APIs becomes much more high-fidelity and it achieves the goal of Robolectric to make it similar to an Android environment. Currently, Robolectric uses BouncyCastle as the Java Cryptography Extension (JCE) security provider. Starting in Android P, Android switched to using Google Conscrypt as the security provider. To be more consistent with Android, Robolectric should update the default security provider to Conscrypt. As it is using the BouncyCastle, this means that whenever the JCA APIs are used in a Robolecetric test, BouncyCastle will be used by default. Officially, In Android the default JCE provider is Conscrypt. This is a Java wrapper over BoringSSL. The goal is to have Robolectric switch from BouncyCastle by default to Conscrypt. The Conscrypt module uses BoringSSL, a native library that is a Google fork of OpenSSL and which is used in many Google products like Google Chrome for cryptography and TLS. Conscrypt uses Java code and a native library to provide the Android TLS implementation as well as a large portion of Android cryptographic functionality such as key generators, ciphers, and message digests. Conscrypt is relatively selective and focuses on the most important and widely-used algorithms. Conscrypt also supports the curves in Elliptic Curves crypto operations and it is much faster than BouncyCastle as it is optimized native code. But BoringSSL doesn't have official releases and makes no guarantees around API or ABI stability.
Large digital designs are prone to consume lots of power and thus, a tool for power analysis is needed. There are two types of power analyses: static, which is more of an estimation that ignores circuit operations, and dynamic, which simulates the circuit behavior in conjunction with switching power. These tools are Verilog gate level-simulations and SPICE simulations, respectively, but the former can be inaccurate while the latter is computationally demanding. IRSIM, a tool intermediate between these two simulation tools, simulates the circuit as a network of transistor capable of turning ON and OFF, serving as a tradeoff between speed and accuracy in dynamic power analysis. The goal of this project is to develop and enhance a command-line interface compatible with up-to-date transistor components in the IRSIM library to ensure the analysis accounts for various power domains.
This project in Lpython and LPython is a Python compiler. It is in heavy development, currently in pre-alpha stage. Some of the goals of LPython, my project will add three features in compiler.
Add rust loader support for Metacall, allowing user to load rust scripts dynamically and embed rust code into other languages. This can be done by generating stubs before compiling rust code and dynamical loading. The information needed to generate stubs can be obtained by using rustc API. After that, the user can do following things: 1. Load rust scrips. 2. Inspect loaded functions. 3. Invoke loaded functions in other languages. 4. Eval rust scripts.
When doing license detection, ScanCode uses the licenses and rules in the ScanCode LicenseDB. The goal of this project is to extend the capabilities of ScanCode license detection to include licenses that are external to LicenseDB, such as proprietary licenses to be kept within an organization. The two main components of my approach are adding a new command line option and creating license index caches for these external licenses. The new command line option will enable the user to specify the directories of the licenses and rules that they’d like to use. The second part of the approach is modifying ScanCode toolkit internals to work with this new command line option, and to handle the creation and maintenance of indexes for any new license sets. Most of these changes involve refactoring existing methods to take in the directories specified in the command line input, which are then used in generating a LicenseScanner object so that these new licenses are cached properly.
Krita as a drawing application is expected to be able to read and write to many different formats for interoperability with many different programs and use cases. SVG is a common file format that Krita is able to read but not fully save as. Currently Krita only supports exporting a single vector layer as SVG. SVG 1.1 and SVG 2 both offer the same functionality for embedded raster images. Considering that svg 2 is not recommended by the World Wide Web Consortium and Krita also only currently supports importing of svg 1.1 so that will be the version we support for exporting as well. This project proposes the ability to export as SVG 1.1 with support for both raster and vector layers.
The project aimed to build a playground for Modern Fortran which enables users to run their code online. It will be offered as an extension to the official fortran-lang website where users can experiment with their code and play around with supported libraries. The playground also offers an interactive tutorial for Fortran newcomers, giving them an overview of the language syntax and features.
This project has three objectives: - To improve RTEMS BSP libraries by creating a new GPIO API and ADC API. Currently RTEMS has a GPIO API, but it has limitation of not being generic enough. The new APIs aim to create portability and simplicity for these fundamental functionalities for RTEMS BSPs. - To implement GPIO and ADC functionalities for STM32F4 BSP, which currently is lacking those. STM32 HAL and LL drivers will be integrated to add new features to the BSP. - To add networking capability for STM32F4 BSP and other STM32 chips by porting lwIP networking stack.
Toolkit for Multivariate Analysis (TMVA) is a multi-purpose machine learning toolkit integrated into the ROOT scientific software framework. The pythonization work proposed here is vital to facilitate the transition from C++ to python to write analysis code. The goal of this project is to enhance the Python interface to make it more “pythonic”, i.e. easier to use. This project aims to simplify complex workflows and enhancement of the python interface, greatly reducing the amount of code that has to be written, including pythonizations for TMVA GUI and Hist functions and converters for PyROOT NumPy arrays to convert RTensor from and to PyROOT NumPy arrays.
This project aims to add event and venue management features to the Talawa app for community organizations. After completion of the project the Talawa app will - allow users to create their own events, - limit the number of attendees to their events, - allow venues to be reserved from being used for other events, - allow attendees to register for events with or without an invitation, - assign tasks to members and - notify the users about event updates.
To increase the Supply Chain Security for Jenkins X. I Integrated Jenkins X with Sigstore to sign the pipeline artifacts. Integrated with Tekton Chains to sign the pipeline activities. Generated SBOMs for vulnerability checks and analysis.
The main goals of this project are to improve the current set of Django benchmarks in djangobench by integrating them with Airspeed velocity and running them regularly and load test different ASGI and WSGI servers using locust to compare their performances
The architecture of the GHC compiler in its current state is anti-modular. Designed with GHC-the-program as the sole consumer in mind, it is very difficult for newer tooling to reuse its components. These problems extend to the inclusion of new backends such that implementations for various target platforms forked GHC frequently. The first step to improving the current design is the isolation of the different components and separation the codebase in layers for different purposes, described in the classic book "Domain Driven Design". This is already partly done, and in this project I join the existing effort by working on the next remaining subsystem: GHC's Core pipeline. In order to achieve my goal, I will proceed by using an incremental bottom-up approach: Starting at the bottom of the module hierarchy, I will push references to upper layers module-by-module up in the callstack until they are completely removed from each component. For the entry points of each in-scope component, I will then provide component-specific configuration types and corresponding initialization functions. The in-scope components are specific configurable tasks of the optimizer, and the optimizer as a whole. With this work completed, there will be significantly less references to the ubiquitous global states used throughout the whole compiler, namely the DynFlags and the HscEnv type, and significantly fewer imports of modules from upper layers, e.g. the driver.
Scala Native is an ahead-of-time and prevalent compiler for Scala. The traditional compilation is to compile Scala into Java Virtual Machine(JVM) bytecodes, which are executed by JVM. Scala Native compiles Scala into LLVM intermediate representation(LLVM IR) rather than JVM bytecodes. This property decreases the overhead of JVM and improves compilation performance. However, one of the most criticized aspects of Scala Native is its slow compilation efficiency and long build time, especially for large projects. Therefore, the optimization of Scala Native is urgently needed. The aim of this project is to build benchmarks to evaluate the performance of the Scala Native linker, and explore feasible solutions to accelerate the building task of Scala Native. Three aspects are going to be exploited: speeding up the optimizer, introducing incremental compilation, and changing the compilation and linking procedure. As a result, we expect to create benchmarks for evaluating the performance of Native Scala, and to reduce the build time by at least 20%.
The requirement of this project arises because currently each donation made to NetBSD electronically from PayPal and Stripe are handled manually using Request Tracker and tickets. The person handling the tickets needs to extract the donation details and enter them into the acknowledgement form and send it to the donor. Further the donor can decide if they want to be listed on the public list of donor and inform by a mail. This process involves manual intervention which may result in error and/or delay. Therefore, if an automated system can be made that handles all these tasks, it will speed up the process, reduce errors, and also save time and energy of the person who performed all these tasks. The primary goal of this project is to develop a system that automates all these processes : acknowledgement of the donor, storage of donation details in the database(to be created) and updating the public list of donor on the official NetBSD website based on the response received form the donor through the online feedback form.
The idea is to create a Video Editor, a web-based application that takes markdown files, PDFs or any asset file as an input and separates those images and text, and converts them into a video or presentation. In technical terms, we can do this by making a video editor in React or some other framework that will take a file like writeup.pdf or another format. Then on the UI side, you have options to put text in blocks. A block will contain text, a time interval in the video and an image we will show at that time interval. That’s how we can make multiple blocks after submitting the data. We will call the backend REST APIs in Django or flask, which will take those data blocks containing time intervals images and text. And convert that text into speech and ultimately combine all those into an MP3 or any video file, which the user can get after the request is complete.
AF_XDP is an address family that is optimized for high performance packet processing. AF_XDP redirects raw network packets to user mode through the XDP program. AF_XDP, like DPDK, can be used to bypass the Linux kernel to gain high-performance processing network packets. DNSDist acts as a load balancer and often needs to process and forward packets. Therefore, in order to forward DNS requests DNSDist needs the raw network packets processed by the Linux kernel network protocol stack, read its request, and send the same request to the downstream DNS server again through the Linux kernel network protocol stack. The repeated processing of the same or similar data by the Linux kernel network stack is an unnecessary overhead for the server deploying DNSDist. This overhead can be effectively avoided by bypassing the Linux kernel through AF_XDP.
The goal is to add Apache Geode support for the Apache Gora project. Apache Gora currently supports a wide range of data stores. But, Apache Geode is a data management platform that provides real-time, consistent access to data-intensive applications throughout widely distributed cloud architectures.
The goal of this project is to add CAN Framework and DCAN peripheral support for BeagleBone Black System on Chip in RTEMS. CAN protocol is a robust, reliable and multi-master serial communication protocol used to achieve real-time message transfer between devices within the CAN network. RTEMS being a real-time operating system, CAN peripheral support would increase the potential to meet real-time demands. BBB has two CAN 2.0 A, B (ISO 11898-1) controllers with 1 Mbps data transfer rate and DMA support. It also has inbuilt RAM which can hold 64 CAN messages. There is a loopback support also, which can be used for debugging purposes. By adding driver support for CAN modules, will enable the use of this potential hardware. With the help of the Am335x reference manual, TI’s starterware firmware and CAN specification I could understand the initialization and working of the CAN module. With the help of existing RTEMS supported CAN drivers I could understand the CAN framework and develop the support for CAN modules for BBB in RTEMS. I chose this project because I started learning embedded systems from BeagleBone Black and developed firmware from scratch with few peripherals and shell support https://github.com/slpp95prashanth/Beaglebone-mBootloader/tree/cpsw. As SoC and RTEMS are open source computing platforms, I would like to contribute to this project and learn more about RTEMS operating systems.