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.
AnyCore is an advanced superscalar processor developed at NC State University, designed to be highly configurable across parameters like issue width and pipeline depth. The goals of the project are fixing memory related issues of the core, finishing integration of an open-source Floating Point Unit (FPU), and enhancing the core in areas needed for running a Unix-like operating system.
Description:Kruize Autotune is a Performance Tuning Tool for Kubernetes. . It uses Hyper Parameter Optimization to tune the language runtime layers of a given application. System component metrics can give a better look into what is happening inside them. Metrics are particularly useful for building dashboards and alerts. Kubernetes components emit metrics in Prometheus format. This format is structured plain text, designed so that people and machines can both read it.Following are four common methods of hyperparameter optimization for machine learning in order of increasing efficiency: 1.Manual 2.Grid search 3.Random search 4.Bayesian model-based optimization The aim of Bayesian reasoning is to become “less wrong” with more data which these approaches do by continually updating the surrogate probability model after each evaluation of the objective function. At a high-level, Bayesian optimization methods are efficient because they choose the next hyperparameters in an informed manner. The basic idea is: spend a little more time selecting the next hyperparameters in order to make fewer calls to the objective function. In practice, the time spent selecting the next hyperparameters is inconsequential compared to the time spent in the objective function. By evaluating hyperparameters that appear more promising from past results, Bayesian methods can find better model settings than random search in fewer iterations.So,this project aims at tuning kubernetes applications using bayesian optimization.
Static analysis is used in the Submitty platform for verifying that the student submissions for programming courses contain specific language features. Current implementation of this uses a simple lexical (token-based) static analysis which is not up to date with the newer features in the Python language and it does not fully support C++. In order to expand these checks, the proposed solution for this is to produce and analyze the Abstract syntax tree (AST) of the submitted code. This generated AST can also be integrated with the implementation of the Lichen Plagiarism Detection module. It is also expected to create additional autograding tutorial examples and corresponding continuous integration regression testing by the end of the project.
The Python API CLI is a component of PyDolphinScheduler, but it currently only has two commands, `version` and `config`. This proposal refines its functionality and outlines the timelines and milestones required for refinement and follow-up plans.
This proposal is for an out-of-the box CloudEvents mapper for Ditto which will convert incoming CloudEvents into Ditto Protocol and further look to normalize the payload. This can be done by validating the incoming headers and payload and mapping them to the defined specification. The Deliverables include: 1. Defining mapping specifications. 2. Creating an implementation. 3. Creating Unit tests. 4. Updating the documentation.
The project will be making contributions to the PyProbML repo helping to build demonstrations and reference implementations for probabilistic machine learning models in Jax. This project will involve multiple discrete contributions of varying size and complexity aiming for a particular focus on projects involving: temporal modelling, latent variable modelling, and Bayesian factor graphs. There is also the potential to further develop the contribution I have made to the repo on restricted Boltzmann machines and contrastive divergence. This could include, for example, implementing a Deep Boltzmann Machine in Jax/Flax, demonstrating pre-training with contrastive divergence, and implementing more advanced forms of contrastive divergence such as persistent contrastive divergence.
This project explores the use of image analysis in a two-dimensional spectrum to detect RFI (Radio Frequency Interference) in large amounts of memory-distributed radioastronomical data. As a result, this project aims to supports and develops 1D and 2D memory-distributed convolution within the Heat domain decomposition (or data distribution) scheme.
Data Cleaning is one of the important and time-consuming steps in the Data Science and Data Analytics field. There are numerous methods, models, and algorithms for data cleaning processes that might be categorized under imputation, outlier detections, formatting, and visualizations among others. The process of evaluating these methods for a given dataset is challenging considering the volume of the dataset and the time/space complexities of the methods. Automation of the performance evaluation process can lead to a significant reduction in human efforts and time consumption with an unbiased comparison environment. The imputeTestbench package provides a benchmarking tool for automated performance evaluation and comparison of various imputation methods for time-series datasets. In its present form, the package is capable of handling time-series and temporal datasets. Imputation plays a crucial role in the fields of genetics and genomics. The aforementioned package can be very helpful if it can be modified to handle genetic or genomics datasets. It has huge potential in handling genetic/ genomics datasets and introducing parallel-processing and high-performance computing concepts. Considering these as a motivation, the goal of the project is to develop a new R package, modifying the imputeTestbench package for Genomics applications with better computational capabilities and will be named 'imputeTestbenchG'.
The project aims to extend Gazebo’s mesh loading support by either (A) Using an external open-source library or (B) Writing glTF2 and FBX mesh loaders consistent with the current approach. The new features implemented will be tested using unit and integration tests. In Phase 1, different mesh loading libraries will be collected and compared against each other and with the option of writing original glTF2 and FBX mesh loaders. The comparison metrics include but are not limited to maturity, complexity, integration difficulty, testing difficulty, and required time to implement. The report generated in this phase will be critical for the next phase and the future of the Gazebo’s mesh structure. In Phase 2, the selected approach will be implemented and tested using unit and integration tests with example worlds. Finally documentation will be created for future reference.
The write operation in flash can only change bits in a specific way and the erase operation changes all the bits of a block to 1s. So to modify any bit the whole block needs to be copied to another memory, erased on the flash, and then copied again from the other memory with the change. Due to this “erase overhead” write operations may require copying a lot of data to modify a small amount. Most flash chips support multiple erase-block sizes and flashrom keeps a list of these sizes and ranges for all supported flash chips. Currently, flashrom tries these functions one by one and uses the same function until the operation is completed or an error occurs. Usually, the first function works correctly but this function erases the smallest erase-block so flashrom would have to use it multiple times to complete the erase operation on a large region, which could have been done more efficiently using functions using larger erase-blocks, thus resulting in a transaction overhead. If a large erase-block size to erase a small region is chosen it would result in a larger erase overhead. So the erase-block size should be picked according to the size of the region left to be erased. Also checking in advance to tell if the programmer supports the given erase function and then sorting the supported functions in order of the erase-block sizes can further help the function selection.
ruTorrent Mobile application is a project that started 2 years ago under the organization CCExtractor Development and it's gone quite well, with the user base growing and a number of contributions being made by other developers. The aim of this project will be to implement autodl-IRSSI notification access, add Analytics and Crashlytics for better user experience, expand test coverage to cover most of the codebase and finally make a public release in the Android PlayStore and IOS Appstore.
This project would focus on implementing common designs and UI elements across the Mifos apps to provide a consistent look and feel. Project goals are: 1. Develop a common UI library to ensure a consistent look and feel of UIs for all apps. 2. Define a process for migrating apps to use the library. 3. Develop design guidelines and standards for the apps. 4. Develop base-level widgets, common UI components. 5. Implement screens and workflows to test out on reference mobile app. 6. Document how to use the UI library and how to update the app when the library is updated.
This project focuses on porting Plots recipes for SciML to Makie and adding to QuantumNLDiffEq.jl. Completion of the former would allow users to simply use Makie instead of Plots for various SciML types, while completion of latter involves adding more methods to QuantumNLDiffEq.jl.
This project aims at building an Api based on knowledge panel of Open Food Facts that return client a specific knowledge panel with use of one or two facets its Provides applications with a set of informative or actionable items which are contextual to a specific facet ,the primary goal is to allow high level contributions by users that maybe interested in a particular subset of the database, like a particular food category or a brand, a location, etc...,its reuse the knowledge panel format, which remove the need for the application to change as the server side code change, or to implement specific business logic.
Currently the documentation for the Syntax of the various SQL’s that Polypheny supports has text based format which proves rather hard to read. The goal of the suggested project by Polypheny was to create a mini system which can convert the BNF like syntax in the markdown into a more visual representation in the form of railroad diagrams. With this I would like to extend the project into a large Project to apply the implementation of this Framework to the existing Jekyll Process of rendering so that it shows up as required on the website. I would also like to pursue possible extensions to improve the syntax completion and highlighting in the query console in the Polypheny-UI.
The project aims at helping researchers find journals that require open source code easily. I aim to create a user interface that could seamlessly help users submit, edit and delete journals and a user-management system that could help with admin and user roles. React forms can replace the outdated google forms to sign manifestos by individuals or organizations, which comes with proper authentication and spam prevention. Apart from working on having maximum functionalities integrated, I shall be removing the frontend dependencies like React-Bootstrap to make the project more user-friendly. With that, CI pipelines shall be integrated through Github actions along with E2E tests written with Cypress.
The erddapy package provides a Python interface to the ERDDAP data server API. Currently, most of erddapy's functionality is concentrated into a single class, and the URL building features are implemented in that class along with the data transformation methods that process server responses into Python objects, such as Pandas DataFrames. This project proposes to separate erddapy into core and object (or opinionated) layers. The former will hold the URL building and data transformation functionality, which will be reused by the rest of the library. The latter layer will provide high-level objects that will support a functional API that does not depend on the state of the underlying object (which is the case for the current version of erddapy). This functional API will provide cleaner iterative usage when querying multiple servers and datasets, and new classes implemented in the object layer will support serialization so that they can be pickled and passed on to other processes or machines. To execute this project, I delineate two separate aims: refactoring the URL building and data transformation functionality into a new module containing minimal, standalone functions and reusing those functions in the existing primary class; and implementing an additional layer containing the high-level objects that will provide the basis for the functional API. Overall, this will greatly improve the flexibility and scalability of the package, and will help support its wide spectrum of users.
Our World in Data (OWID) strives to make knowledge of global problems accessible and understandable through interactive geographical data visualizations to see how the world has changed over the course of time. A quick and intuitive view of the world map in relation to population makes it easy for viewers to co-relate the effect and the relative measure's gravity. OWID uses a range of choropleth maps, but size-scaled maps have downsides, primarily because human visual perception associates areas with importance. Furthermore, readily available alternatives use mosaic cartograms, which distort the shape of countries. To solve this problem, in a sentence, the primary objective is to plot a visually conclusive world map by illustrating territories/countries using a method for trading off shape and area. The basic idea of the solution is to distort the size-scaled world map while preserving the shape of countries to generate a population-scaled world map. Furthermore, a manually generated population-scaled world map acts as the reference for optimizing the cost function for better results. Finally, an option to rearrange the cells in the grid to nitpick the details yields the final result of the cartogram.
Currently, lookups could be registered to a Field class which limits the versatility of Django lookups. This project adds support for lookups (building blocks to filter from a database) to be registered and unregistered for a specific Field instance (representing a field of a database table). So Field-instance-specific lookups can now be done in Django!
The project would involve creating a pipeline from data acquisition to simulation to overlaying the visualisation in an extended reality (XR) context. Using the real world camera feed and geolocation from an augmented reality capable device, real world topography would be extracted. This data would then be used to create a simulation using material point method and then the results would be overlayed on the scene. The project would provide a prototype to identify unsafe slopes in the wild.
The Angular team plans to halt Protractor development at the end of 2022. The aim of this project is to set up the WebdriverIO with Github Actions, and complete the migration of the existing e2e tests to WebdriverIO. Also, document the usage of this new tool.
Fuzzing is a useful technique for finding and avoiding programming problems by sending programs invalid sets of non-deterministic inputs. The RcppDeepState package allows developers to perform fuzz testing on libraries that use Rcpp for some specific functionalities. The main purpose of this project is to provide a custom GitHub Action that makes it simple for developers to use RcppDeepState's fuzzing techniques on any R package on GitHub. In addition, improvements to the existing RcppDeepState library will also be implemented in order to proceed with the publication of the package on CRAN.
The ultimate goal of the project is to create a full-stack React component node module of the RocketChat application that would be fully configurable, extensible, and flexible for use. It will allow users to integrate RocketChat into their React web-based applications easily also providing an amazing developer experience while creating in-app chat applications.
The relationship between sampling and optimization has gained increasing interest in recent years. A great number of optimization algorithms that are developed leverage sampling. The goal of this project is to equip the VolEsti library with a Riemannian Hamiltonian Monte Carlo (RHMC) sampler constrained on convex bodies and then use it for the implementation of optimization algorithms. The implemented sampler should return samples from log-concave distributions constrained in polytopes as well as spectrahedra. First of all, the initial implementation will be based on very recent promising research about an RHMC algorithm constrained in polytopes. We will expand on this effort by extending its capabilities to handle Spectrahedra. Afterwards, the above implementation will be used as a subroutine for a Semidefinite Program (SDP) solver. Last but not least, we will also include benchmark tests to compare the efficiency of our code against other state of the art libraries. As a summary, the project's deliverables will consist of the implementation of: an RHMC sampler first constrained on polytopes, then extended on spectrahedra, SDP optimization algorithms that use RHMC and finally testing against other libraries.