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.
Developing a native Swift-etcd client aims to seamlessly integrate etcd, a distributed Swift key-value store into Swift applications. This project aims to enable developers to have efficient communication with etcd servers via gRPC API, by targeting authentication, key-value operations, watch operations, and lease management.
In evanix we explored making the scheduling of Nix builds more controllable. in particular, we look into implementing constraints such as –max-builds and –max-build-time, which ensure that build operations remain within manageable limits while maximizing throughput. Here the scheduling problem is framed as a mixed integer linear programming(MILP) problem. The input is a graph G=(V,E), where each vertex v represents a Nix package with a cost w(v) and a value p(v). packages that are classified as transitive dependencies—those required solely for other packages carry a value of 0. In contrast, packages that are requested for direct building are assigned a value of 1. This value structure reflects the prioritization of building requested packages over their dependencies. Our approach aims to identify a set of vertices or packages following the precedence constraints that maximizes the value or the number of packages built with value 1. It is crucial that a vertex or package can only be selected if all of its dependencies are also selected. An edge in the graph represents a dependency, with the indegree of a vertex denoting the number of packages that depend on it and the outdegree representing the number of dependencies of the package. We also developed a linear regression model to predict build times based on input derivations, enabling us to incorporate this information into our solver when it’s unavailable in Hydra. This predictive modeling greatly enhances our ability to estimate build durations for packages not built by Hydra, particularly those outside of Nixpkgs. By integrating these predictive insights with our MILP-based scheduling strategy, we aim to create a more robust nix build scheduler.
The Audio Overlay Filter aims to provide the functionality of replacing specified sections of an audio stream with other input audio streams. I will be designing and implementing the filter along with the necessary documentation for it to become a part of FFmpeg's libavfilter library.
The problem here is to migrate from gitbook to some other tool which provides us with the feature of generating website from some easy to use markup language like markdown in which the current gitbook is hosted. So, I propose to solve this using antora for website and using asciidoc as markup language for it as it fulfills the main requirments of having a website and ebook(epub). It also have option to customise the UI which could be used to make antora website look more attracting and I have listed why I used this in my proposal.
This project integrates mfsBSD into the FreeBSD release tool set, creating an additional target of mfsBSD images (.img for disc and .iso for optical images) into the `/usr/src/release/Makefile`. Until now, mfsBSD only existed outside the FreeBSD release tool chain, and only the -release versions have been produced. With this project, mfsBSD images are now available at the official FreeBSD release page, and you can also build mfsBSD yourself by invoking `cd /usr/src/release && make release WITH_MFSBSD=1`, which will then create `mfsbsd-se.img` and `mfsbsd-se.iso` at `/usr/obj/usr/src/${ARCH}/release/`.
ENIGMA currently lacks third-party integration with various digital distribution platforms such as Steam, Xbox, or Origin. First-class support for these services would make it easier for Indie developers to publish ENIGMA-created games. Developers would like for it to be easier to monetize their games and enable them to release bigger and better updates to their users. An integrated architectural layer will be created between Steamworks ENIGMA's extension APIs and Steamworks SDK. ENIGMA's Asynchronous system will be updated. Currently, ENIGMA's Networking system is not stable so Steam Networking features will be postponed for later for now I will add support to these APIs: Management, General, Overlay, Leaderboards, Achievements, Cloud, and Social.
Pylops has been developed to solve large-scale inverse problems. Keeping in mind the memory size of a single machine, there is a need to perform the operations in a distributed fashion. The main goal of this project is to use the mpi4py package to exchange messages between different processes across distributed memory. The main outcomes of this project are to develop a DistributedArray class using mpi4py to broadcast or scatter numpy/cupy arrays and perform basic operations like sum, product, dot-product, element-wise product, etc in a distributed fashion. Additionally, MPI functionality will be added to BlockDiag, VStack, and HStack, and the code for forward, centered, and backward finite difference stencils will be updated using Distributed Arrays. Lastly, at least one of the CG, CGLS, and LSQR solvers will be modified to use Distributed Arrays. This will benefit the Pylops Codebase as integrating mpi4py into the codebase will enhance the operators' performance and prevent exceeding memory on a single machine.
The goal of this project is to develop a deep learning model that can accurately recognize various categories of objects in digital photos, and generate corresponding keywords that can be automatically assigned and stored in digiKam's database for each photo. This will improve the efficiency of organizing and searching for photos based on their content. In addition, the facial recognition engine will be improved to increase its accuracy and reduce its inference time. The results of this work will be merged into the master branch, allowing for more reliable and effective facial recognition capabilities in the digiKam application
Overview: In the current scenario, the Knative Eventing Kafka Broker's data-plane communication with Apache Kafka for consuming and producing records is done via the Vert.x-Kafka-client library which is basically a wrapper for communications with Apache Kafka inside the Vert.x threading model. Objictive: This project idea aims to implement the Knative Kafka Broker data-plane communication with the native Apache-kafka-client library working on Java 19 and evaluate OpenJDK 19's Project Loom and leverage its virtual threads for efficient and concurrent communication with the Apache Kafka cluster.
Java Pathfinder (JPF) is a Java virtual machine that can run compiled Java programs as well as model checking it. It is also an extensible software analysis framework for Java bytecode. As it has been created for about two decades, supporting new Java language features is of vital importance for its wide adoption. JPF community has taken steps to add Java 11 support, but there are still some unsolved issues. In this project, I plan to add better Java 11 support for JPF. This includes more comprehensive Java bytecode support, especially for invokedynamic, more JDK API support, and some bug fixes. It will fix all 13 failing tests JPF faces now on Java 11 and enable more programs to run on JPF.
The goal of the proposed project is to extend the existing remeshing functionality in the polygon mesh processing (PMP) package with the adaptive remeshing based on the work by Dunyach et al. (2013). The existing implementation isotropically remshes surfaces in three steps: first, edge splitting or collapsing depending on their length relative to the target edge length; second, edge flipping to improve vertex valence; third, tangential relaxation to improve the vertex distribution. The planned extension with the adaptive remeshing involves expanding the edge splitting and collapsing rules, and introducing a new formulation of the tangential relaxation; in addition, feature edges must be addressed. Apart from implementing those three necessary functionalities in CGAL, the contribution to the project would include creating tests, examples, and documentation.
Shardingsphere federated query engine provides support for SQL statements. In the GSoc period, I have to add support for more MySQL SELECT statements so that more SQL statements can be converted into SQLNode. This can be achieved by: 1- Analysing the SQL statement I have to add support of, 2-Figure out components & logic required , 3- Make changes in SQL federation engine optimizer files , 4- Optimize parser files , 5- Make changes in TEST files to ensure test is passing successfully. After the support for More SELECT statements queries is added, The users & developers will be benefitted by utilising more SELECT queries for MySQL .
I aim to deploy OWTF on AWS for easier use by users and to ease its development for developers. Also, I will improve its Docker installation, which I have been working on. I also want to add a new plugin to scan the cloud storage of any web service according to the OWASP web security guide.
The objective of this project is to design and implement a landing page for Pocket Paint on the Android Kotlin platform. The landing page will feature a gallery view where users can preview their saved images and quickly select one to continue editing or start a new drawing. By having a clear and organized landing page, users will have an intuitive and seamless experience with Pocket Paint. The landing page design will be inspired by the existing landing page in Pocket Code, ensuring consistency and familiarity for users. With the implementation of this landing page, Pocket Paint will become a complete app, providing a more comprehensive and efficient drawing experience.
GOAL OF THE PROJECT: 1) Create beginner-friendly and easy-to-understand examples/demos for all widgets of GTK 4.10 and Libadwaita 1.3 to help newcomers understand how to use them effectively. 2) Provide ready-to-use code snippets of the widgets/APIs covered, making it easier for developers to integrate them into their projects. 3) Cover GLib/GIO and Libportal APIs and create relevant examples to help developers understand how to use them in their applications. 4) Create demos while taking UI and UX design concepts into account to showcase how to make aesthetically pleasing and functional user interfaces. 5) Cover GNOME HIG Patterns to ensure that the examples and demos follow the GNOME Human Interface Guidelines, making them consistent with other GNOME applications and user-friendly for users. 6) Implement Search function in Workbench 7) Implement the Keyboard-Shortcuts feature in Workbench to ease the development-workflow Overall, by providing detailed examples and demos for these APIs and widgets, developers will be able to learn how to use them more effectively, resulting in more efficient and user-friendly apps. The project would be very beneficial to GNOME and its community in the following ways: 1) Showcase GNOME platform capabilities 2) Provide an alternative to lengthy tutorials and dense API references 3) Provide quick and ready to use snippets for GNOME Developers 4) Help on-board new developers and lower the barriers to enter the community 5) Cover the widgets that lack documentation in the official documentation
VDB is a volumetric, sparse and hierarchical data structure which can be used for volumetric rendering, simulation and computational solid geometry (CSG). This project aims to add a VDB as a new entity for volumetric data into BRL-CAD. Additionally, the VDB structure would be used to render volumetric data with ray tracing.
Physically plausible inertial parameters like the mass, center of mass, moments of inertia etc. are required for an accurate simulation. Since parameters like moments of inertia are difficult to visualize, a user may tend to enter wrong values leading to incorrect simulation. Therefore, having the calculation of moments of inertia integrated into Gazebo itself would make the workflow much more smooth. The plan is to use existing mesh processing libraries to automatically calculate moments of inertia from link collision meshes and introduce an attribute to SDFormat for the <inertia> tag that enables the feature.
High-performance computing (HPC) data centers tend to have hundreds to thousands of nodes in their clusters. The use of “extreme-scale” distributed systems has given birth to a new type of bug: scalability bugs, bugs that depending on the scale of a run, and thus, symptoms may only be observable in large-scale deployments, but not in small or median deployments. The symptom is not observed unless ~1000 nodes are deployed, making scalability bugs challenging to reproduce and fix. The goal of this project is to build a dataset of reproducible scalability bugs. To achieve this, studying the bugs in detail to understand the root causes, behavior and impact on the performance system and craft workloads designed to trigger the functionalities of the system under different configurations (e.g.different numbers of nodes) is needed to reproduce these scalability bugs. Having a dataset of reproducible bugs can help in developing better testing and validation strategies for scalable systems to ensure that they work as expected under different scales. Also to provide a resource for researchers and developers to study and address scalability bugs and contribute to the improvement of the reliability and efficiency of scalable distributed systems.
In this project, I am going to make a neural network which is going to predict the probability that one satellite will collide with another. With this information, I am going to compute what area of the earth may be affected by this collision.
MLFlowClient.jl lacks of updates regarding new features coming from the original Python package. Some effort is needed to ensure new version methods. My plan is to implement that novel features using pure Julia, increasing compatibility; and also new functionality to allow communication with MLJ.
Many applications of point set surfaces work with noisy point sets, requiring a denoising operation to reconstruct the original surface. This project will implement constraint-based point set denoising-- an iterative, anisotropic denoising algorithm presented by Yadav et al. While denoising algorithms exist in CGAL, this method focuses on preserving sharp geometries during the denoising process. The final deliverable for this project will contribute to CGAL's Point Set Processing package.
This project is dedicated to streamlining and enhancing the CircuitVerse development experience. Our primary objective is to simplify the setup of the development environment and streamline the coding process, ultimately making it more efficient. Furthermore, we aim to bolster the quality of our test cases and optimize the continuous integration (CI) workflow, which will, in turn, reduce the time required for code reviews by our maintainers. -- Throughout this project, our key objectives include: 1. Integrating the Ruby Debugger 2. Incorporating Solargraph Language Server Protocol (LSP) and Crafting YARD Documentation 3. Integrating Vite Rails for Improved Development Workflow 4. Incorporating RBS in the Project and Implementing Static Type Checking in CI 5. Implementing Undercover CI for Enhanced Code Coverage Analysis 6. Enhancing Unit Testcase Coverage 7. Adding Missing Integration Testcases 8. Enhancing the Remote Development Platform (GitHub Codespaces, Gitpod) 9. Improving the Docker Development Setup 10. Enhancing Setup Documentation for Developers
In short, this proposal aims to export more pola-rs bindings to R beyond existing ones offered in r-polars, and make such bindings as efficient as possible. Pola-rs is a highly efficient data manipulation library written in Rust, and it can significantly improve the performance of data pipelines. It would be especially helpful for computationally demanding analysis if such library is accessible in R.
The proposed project aims to address the sustainability challenges faced by open-source software projects by using an agent-based modelling and simulation approach. Open-source projects often face issues such as limited resources, difficulty in attracting and retaining contributors, and communication breakdowns, which can hinder their growth and sustainability. To address these challenges, the project will simulate various scenarios and identify the factors that contribute to the success or failure of open-source projects. The project will provide a framework that enables simulating different scenarios to assist project maintainers in making informed decisions that promote sustainability. This approach can offer a more detailed and context-specific understanding of the challenges open-source projects face and develop effective strategies for maintaining their sustainability.