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.
I am proposing the use of Convex Inner Approximations to plan the trajectories. The Convex Inner Approximation method finds kinodynamically feasible trajectories that guarantees collision avoidance. It also finds the trajectories in fewer iterations and as a result is much faster than traditional obstacle avoidance constraints.
Problem: A popular way of taking notes while mapping is by taking pictures. But in order to efficiently use those notes, the pictures should be shown on the map where they were taken. The lack of this capability makes it difficult to utilize iD in mapping party and similar environments. I plan to solve it by building a feature to upload geotagged pictures and a way to edit those pictures' properties. I plan to deliver the following - add drag-drop handler - process/analyze the image format - add rendering code and CSS for the thumbnails of the images - allow edit of picture properties
Improve bézier rasterisation in Krita. Optionally disable floating-point precision when making pixel arts. Make specialised algorithms for common shapes like ellipses.
I will be performing a holistic security assessment of Submitty. Patching once a potential vulnerability is found and documenting the flaw. Development of CI tools to automate the process of checks and validations will be done so as to prevent vulnerabilities from popping up. Considering the three major user roles of Instructor, TA and student, I'll be performing a thorough scrutiny of the implementation of authorization. I'll be bolstering the configuration standard to prevent security risks posed due to misconfigurations. At the end of the project, Submitty will be more secure along with having stronger mechanisms to catch vulnerabilities at an early stage and thus making continuous integration more reliable.
We study the sampling of correlation matrices from a given probability density, which has applications in various scientific, engineering and business areas (biology, finances,...). This problem is technically difficult due to the constraints of correlation matrices (entries in [-1,1], positive semi-definiteness). The current methods can only scale to a few tens of dimensions. This project aims to provide efficient C++ implementations for new geometric-flavored algorithms to sample correlation matrices (Arakelian, Chalkis 2021) and integrate them into VolEsti, an open-source high-performance software for sampling, volume computing and geometric statistics. Our main tasks consist of implementing a new class of convex bodies to represent the space of correlation matrices and geometric operations for performing two random walk sampling algorithms (the accelerated billiard walk and Reflective Hamiltonian Monte Carlo algorithm) over those convex bodies. These tasks can be supported by the already existing geometric facilities of VolEsti and the theoretical results found in related works. We will focus mainly on building an optimized C++ code to achieve better scalability for those algorithms and carry out intensive experiment and benchmark with other competitors to justify our efficiency. The expected duration of this project is 175 hours spread over 7 weeks of coding period (June 13 - July 29). The C++ implementation obtained by the end of this project will expand VolEsti towards an all-in-one high-performance statistic tools for research and business uses.
When using CoreDNS to serve DNS traffic over TLS/HTTPS certificates have to be managed (created and renewed) manually. The goal of my project is to automate this task, using the ACME protocol. If successful, CoreDNS can be hosted on a domain, such as dns.example.com, and automatically obtain a valid certificate (for example from Let's Encrypt) and it will also automatically be renewed before it expires, reducing toil for CoreDNS operators.
QEMU-NVMe is an important tool for developers to experiment with new features in the NVMe stack. However, its emulation performance has failed to catch up with the ever-increasing speed of modern storage devices. The goal of this project is to improve QEMU's NVMe emulation performance so that it becomes comparable to virtio-blk. We intend to implement the following optimizations: (1) Add Shadow Doorbell Buffer support to reduce doorbell writes. (2) Add Submission Queue Tail Doorbell register ioeventfd support. (3) Add iothread support to run emulation in a separate event loop. (4) Add Submission Queue Tail Doorbell register polling.
FlashFill is a program synthesis framework for generating string-processing programs from input-output examples. This project aims to implement FlashFill in Julia and integrate it with DataFrames.jl. Such a package would be a valuable tool for Julia users handling tabular data, providing an easy way for data-cleaning and data-wrangling. It would also lay the foundations for implementations of further open-source program synthesis frameworks in Julia.
This project is a practical application under the umbrella of the MLGO framework. While the previous work focuses on inlining and eviction policy of regAlloc, the project will explore a new application of MLGO on the priority policy of regAlloc, which could be a potential alternative to the manual-maintained heuristic.
The project aims to extend GCC’s static analyzer to support reporting warnings for “misuse” of POSIX FD APIs such as double-close, leakage, access mode mismatch etc. by implementing the state machine that checks such misuse. Also, the project aims to add three attributes for use on functions that work with file descriptors.
The most efficient algorithm to sample from a log-concave distribution, that volesti supports is the Hamiltonian Monte Carlo with leapfrog integration. The leapfrog method is an Euler method that in each step evaluates the gradient of the log-probability density function of the target distribution. To sample from a log-concave distribution volesti currently requires a function that evaluates this gradient as an input. However, there are plenty of applications that require sampling from a distribution where the gradient of the log-probability density function is unknown. This project will address this problem and will provide to volesti routines of automatic differentiation of a multivariate function. Then, a function that evaluates the log-density will suffice to sample from the target distribution.
The project idea aims to reduce power consumption on Flotta-device agents on small factor edge devices at several levels. OS toolings would be implemented to get data about the energy consumption at the CPU level of the device agent using a Custom Kepler monitoring system and a power meter. After the confirmation of the data, these parameters would be passed to the control plane via metrics using Prometheus as Internal Prometheus TSDB is already used by the flotta-device agent, Required research on variation in energy consumption and performance with the number of workloads and resources allocated to them would be done and the obtained findings is to be summarised in a blogpost. The research part would be helpful for the development of better ideas for workload allocation and containers for Flotta, and IoT based container workload projects in general. Two energy profiles would be developed namely Flotta-PowerSaving Mode and Flotta-UltraPowerSaving Mode which would aim to turn - off specific kernel modules and operations which are not feasible and are unnecessary for running container workloads at low energy, The data from the research would be integrated with these for determining the ranges in which it would operate.
Microsoft Teams is unquestionably the most popular and frequently used closed source team collaboration system in the world. Many administrators and users of open source Rocket.Chat team chat will have needs to bridge between their open source users and legacy users still on Teams. This project will create a Rocket.Chat App that will act as a bridge between Rocket.Chat and Microsoft Teams. Users on one system should be able to chat with the other through shared channels. Rich interactions including DM, emojis, embedded graphics, shared youtube links and so on should also be supported. A Teams Bridge Rocket.Chat App will be published on Rocket.Chat Apps Marketplace together with documentation for how to use it.
Working on to improve the current UI of the FOSSology project and bring it to completion. Fixing the known issues of the REST API and exposing new API endpoints to the frontend in order to introduce more functionality. Also adding API docs using SwaggerUI for better API testing and implementing them to the frontend.
Currently, Casbin uses golang built-in map structure to maintain policies in the main memory and persist the policies via adapter abstraction. If policies data grows, however, the growing cost of main memory resources and bad performance make the memory management strategy not tolerable anymore. We need to find a better way to manage the casbin in-memory data when data grows. From my point of view, our main goal is to reduce the cost of memory as well as keep good performance handling policies read and write requests. In order to achieve those key goals, we can introduce an experimental tuple storage to get charge of storing those policies, turning the policies management strategy from memory-oriented to disk-oriented. We can even make a better abstraction of the storage layer so that we can use different engines (row, column) for the different workloads. In general, we can take the following parts into consideration to achieve our goals. 1. API for upper layer. 2. workload optimizer. 3. Buffer Pool management. 4. Indexing. 5. Data Storage Structures. 6. Transaction if necessary. And in the end, the deliverables will be : A Casbin built-in embedded disk-oriented tuple storage engine. The Engine should contain : 1. Carefully designed API for upper Casbin internal module. 2. Storage management. Include file organization and page layout. 3. Buffer pool management. 4. Index management. 5. An workload optimizer for the upper layer. 6. Transaction part if necessary.
The ultimate purpose of this proposal is to expand the GNOME community and make it more inclusive for everyone who wants to be a part of it, as well as to make this a successful endeavor. I hope that by completing this project, we will be able to promote transparency in our community, empower our contributors, and assist the larger community in recognizing the contributions of all contributors. The project includes simplifying the process for members to add themselves and blog posts, UI/UX improvements, populating the FAQ page, creating wiki pages, replacing old jQuery with modern ES6 JavaScript, alongside deploying it to make it visible for public view. The project would include entire pages, wikis, documentation, and features, allowing us to complete development which will aid the release of this project.
The goal of the project is to integrate the HLP1 engine and Penumbra: Overture in ScummVM. The deliverables for the project are the following: Replace file handling and implement game detection. This step includes integrating the save system and loading assets. Replace graphics functionality. Integrate external libraries. Replace input system and get the game in a working state (without audio). Replace audio libraries. Remove standard library usage.
The Geat4 toolkit lacks numerical integrators that preserve energy over the long course of simulations. Specifically, the g-2 physics experiment at Fermilab seeks to uncover whether a yet undiscovered force influences how the spin of the muon behaves.To do this it measures the polarization of the muon to seek new physics over thousands of revolutions in its custom accelerator ring. To replicate this in Geant4, the toolkit must track muons for 5,000 turns with near-perfect energy conservation and no drift in particle momentum.This necessitates the use of symplectic integration schemes to maintain the level of accuracy and precision required in the calculation. Hence this projects aims to implement the following symplectic methods in the toolkit: 1.) The Leapfrog Algorithm 2.) Boris Algorithm 3.)ESSRK method for non-separable Hamiltonians.
This proposal aims to add new features to the Hackage server, mainly include package sorting, user info update and user notification emails. It's planned that first a week is needed to read the codebase, then about a month to implement the three features above, and add some additional interesting feature if time permits.
This project aims to develop a JNI interop package, which allows to access Java APIs (on Both Android and JVM) from Dart code, and a wrapper generator which, given Java sources, generates JNI wrapper code in C and dart, thus enabling the programmer to use Java APIs from Dart idiomatically.
The objective of the project is to implement a new state-of-the-art 3D Object detection model (PV-RCNN++) in PyTorch and TensorFlow and train it on large-scale datasets such as Waymo to reproduce the original author’s results. The expected outcomes of the project are: • Implement PV-RCNN++ training and evaluation with PyTorch. • Train and reproduce results on the Waymo dataset. • Port the PyTorch implementation to TensorFlow and ensure results can be reproduced. • Proper documentation about model usage and config customizations with tutorials and examples. The implementation plan is as follows: • Using OpenPCDet implementation as a reference, implement PV-RCNN++ in PyTorch and benchmark on Waymo Open Dataset. • Using this implemented PyTorch model as a reference, implement each corresponding layer in Tensorflow and test it. Convert the PyTorch model to TensorFlow and verify the metrics on the Waymo dataset. • Once verified, train the model from scratch in TensorFlow and verify the results.
I am applying for the project 'Fitbit Web API Subscription and Nutrition API Extension' from RADAR-base. The main problem is updating the code concerning integrating Fitbit API through Kafka-connect and I am going to solve it through Java backend development skills. There are three deliverables at least: 1)complete implementation for Fitbit Subscription API, 2)support for Fitbit Nutrition API, 3)extend time-series data support for heart rate and sleep.
Building and maintaining a website is an essential task for any business or organization. This project aims to ease the workflow of getting a website up and running by developing reusable Gatsby Components which are easily plug-able to create Gatsby websites with ease.
This study aims to show the capabilities of QML especially QCNN for classifying the HEP image datasets. QCNN can be completely quantum or can be a hybrid with classical. The aim is to implement both. We will use quantum variational classification instead of the final FC classical layers in the quantum setting. This will give more depth about the quantum power that can be used in the near-term future. I summarize the required deliverables that will be achieved before the official end. Implementation of some chosen classical ML models as a baseline using TensorFlow. Implementing QCNN for fully quantum and hybrid architectures including different data encoding schemes (angle, amplitude encoding etc.). Jupyter notebooks will be used as a testing environment but the final python modules will have a .py extension. These notebooks will then be extended as a form of documentation for beginner contributors. Comparison of classical ML baseline models with QCNN and documenting the results.