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.
Multi-output Gaussian processes (MOGPs), a type of Bayesian nonparametric models, have recently gained strong attention from researchers, and become an active research topic in machine learning’s multi-task learning. The advantage of multi-output GPs is its capacity to simultaneously learn and infer many outputs which have the same source of uncertainty from inputs. This provides a useful and practical approach for various applications in different fields. The creation of new sampling methods and the advance in computing power have paved the way for the development of Bayesian models. Different software frameworks have been built to facilitate this probabilistic programming approach. Among those, PyMC is one of the most popular frameworks with a large and strong community. PyMC provides friendly interfaces that allow users in academics and industries to perform both parametric and nonparametric Bayesian data analysis. For Bayesian nonparametric models, the Gaussian process module in PyMC supports various mean and kernel classes. However, the current GP implementations in PyMC are limited to single output. This project aims to add support for multi-output GPs in PyMC. This feature would significantly extend the capabilities of this important module and benefit the PyMC community.
Wiki Education Dashboard (the Rails app that powers Programs & Events Dashboard) is a complex web app for keeping track of contributions to Wikimedia projects. It's widely used by the global Wikimedia community for edit-a-thons, classroom wiki writing assignments, and a variety of other initiatives. This project aims to look for areas of improvement in the javascript side of the dashboard. A major part of this would be replacing older dependencies that are no longer maintained with newer ones, reducing the bundle size, while also making the codebase in line with the rest of the JS ecosystem. This project will also involve rewriting some of the legacy code in a more modern way, making it more approachable to a wider audience of developers and contributors.
The Chrome DevTools Protocol (CDP) serves a variety of automation use cases by providing programmatic access to Chrome. These include data collection, website testing, form submission and PDF generation. This project aims to address the absence of an actively maintained client library for Haskell, leveraging its type system to provide a strongly typed interface for utilizing Chrome.
Implementing version management for TUF’s python reference implementation. The implementation does not currently have a way to migrate TUF repositories or clients to a new TUF version that has breaking changes. This project will be the implementation of a proposal for coordinating specification versions between a repository and a client to prevent interruptions in access to updates after a major version change to the specification.
This proposal regards mapping histogram data to its underlying function; both of which can be represented as sequences and hence a transformer can and will be used to represent the mapping. This project involves both generating functions and histograms to use as a dataset and implementing and training a transformer to perform the mapping.
The proposed project is an approach to the problems of sustainability and collective cognition within small open-source organizations, proceeding in three phases: an analytical model for such collective cognition, a multi-agent simulation, and a web-based implementation and auditing system for such organizations.
Currently, User have to face complex workflow for simple use cases (such as “adding a book”) with lots of repetition of data. This project aims to design and implement simple yet powerful editor for such cases which will abstract away bookbrainz specifics from a user by introducing a new “book” template/interface which will wrap over existing edition entity with useful defaults and pre-configured relationships. This will also allow experienced user to create multiple entities and link them in same workflow.
For simulating a system that contains many variables and/or equations, traditionally computational engineers tend to focus on utilizing an appropriate method with realistic time and space complexity. The technique of model order reduction (MOR), however, aims at approximating the original model with reduced number of variables and/or equations and still keeping sufficient accuracy. MOR is especially useful in various industries, for example thermal-fluids engineering, micro-electro-mechanical systems and control, where large-scale simulations have to be performed. The methods of model order reduction can be classified into several classes including proper orthogonal decomposition, reduced basis, balanced truncation, etc. Several MOR libraries have been well developed in MATLAB and Python. For instance, pyMOR is a Python library that relies on the application of reduced basis methods to parameterized partial differential equations. MATLAB's model reducer supports pole-zero simplification, balanced truncation mode selection methods and so on. In Julia, the main package that enables symbolic modeling is ModelingToolkit.jl, whose key features consist of automatic transformation and structural simplification, but it needs further works on fast ML approximate transformations. So this project is targeted on implementing MOR methods as extended features for ModelingToolkit.jl. Besides implementation of methods of model order reduction, the expected deliverables will include documentation which shows both the improved simulation time and accuracy penalty for the application of different MOR methods on test problems from various disciplines.
This project aims to shrink BlackParrot multicore to have a minimal variant called TinyParrot multicore. The main goal of this project is to get very low resource ASIC tapeouts. The deliverables of this project are: **Provide Minimal ISA support: This will be done by parameterizing the FPU logic (all the FP pipes, register file, and bypass paths). **Shrink the size of caches: The cache size will be reduced to 1kb of data. **Logic saving optimizations: The optimizations are planned to be done through Yosys. Yosys supports optimization passes and runs them while synthesis.
Add new selection features, improve the speed of the existing compiler and render, and fix bugs for animint2 package. New Features: •User-configurable selection styles. Implementing by modifying the D3 aesthetic. •Make data visualizations with large data sets compiled faster, by introducing dependency on data.table. •Move the computations of updating axes/legends after changing the currently displayed data subset to the renderer. Optimization: •Upgrade to d3.js version 4
This project is about finishing the Binary Buffer system's API to read and write arbitrary data into a byte buffer, along with using this system to implement serialization and deserialization of all game state into a Binary Buffer in the EDL compiler.
I will be adding new UI elements and improving the existing UI system to easily visualize and transform various geometric shapes and UI elements interactively without affecting the existing performance.
I intend to propose an approach to transfer the messaging protocol of the application from the naive push protocol. The push protocol has many disadvantages and so we need to migrate to either pull protocol or hybrid protocol. The hybrid model that we will try to use in this project is the First-Push-Then-Pull protocol. We can either choose the pull protocol or go with the hybrid protocol.
The Timeline is one of the most essential parts of a video editor. This project aims to improve the Timeline of Pitivi by adding some enhancements and fixing long overdue bugs and other issues. Currently 1/4th of the total open issues are from Timeline component. With this project we are planning to fix some of the major bugs and also add some new features.
The aim of this project is to create healthcare examples using Keras. I plan to implement new tutorials for: 1. Diabetic Retinopathy detection using SOTA EfficientNet model. 2. Pulmonary disease diagnosis using cough sounds by creating a feature extraction pipeline and a Deep CNN model. 3. Skin lesion segmentation using Semi-supervised contrastive learning.
Implement IPv4 to IPv6 address synthesis (RFC6052), and Pref64://n discovery using domain name "ipv4only.arpa." (RFC7050) so packets will utilise the NAT64 in an IPv6 only network. Currently, Chrome cannot access an IPv4 literal when the network is IPv6 only (such as when an IPv4 address is directly written in the search bar) because it cannot utilise DNS64. In order for the packet to use NAT64 in the network, Chrome will now append the IPv4 to IPv6 translation prefix (Pref64::/n) to the IPv4 address.
Problem : Optimize Parallel Programs by employing Non-Determinacy based optimizations. Plan : 1. Perform static code analysis to identify program points for potential code optimizations. 2. Implement the optimizations as passes which will transform the source of the previously chosen program points. Following are the list of optimizations that are planned. a. Non-deterministic Loop Invariant Code Motion b. Loop interchange/reordering c. Non-deterministic Vectorization d. Non-deterministic Memory to Register 3. Evaluate the generated code for the optimizations against the benchmarks. 4. Documentation and Report a. Document the details with respect to the assumptions in the optimizations. b. Document the relevance of the optimization across the chosen benchmarks. Deliverables : a. Analysis to decide on the program segments to perform optimization b. Optimization passes on the previously chosen code segments. c. Optimization bench marking d. Documentation towards theory and implementation of optimizations
Each learner that comes onto Oppia’s platform has a different level of experience and comprehension within a given subject and some of them have trouble identifying which topic they should start within the Oppia Classroom as a result, Learner Diagnostic Tests will allow the learner to test their knowledge and get a set of recommendations from where they should begin learning.
The project implements the Pitch Shift effect for the Mixxx DJ Software Application. The Pitch Shift effect raises or lowers the original pitch of an audio signal. Before the effect was implemented, the pitch could be changed only using the deck's rate slider separately. Unfortunately, the mentioned Pitch Shifter has no wide range and imposes significant restrictions on ways other effects can interact with the sound. In this project, the new Pitch Shift effect is introduced in the built-in effects, which can be used in the effect chain. It implements the wish "Add a Transpose / Pitch Shift effect" for the Mixxx software. Primarily, it allows a user to use a much wider range, than the Pitch Shifter for the deck player and, of course, other useful options like Formant Preservation or semitone chromatic scale mode. Due to the produced latency based on the pitch processing, the production delay has to be handled for the Dry/Wet and Dry+Wet modes to ensure that the original (dry) and processed (wet) signals overlap. The project is expanded by the implementation of the Group Delay handling for the effect chain.
This project tries to integrate data download client functionality into the Gen3 Python SDK & CLI, to provide a single tool for interacting with Gen3. The project is implemented by using python modules such as multithreading or multiprocessing to enable asynchronous download of multiple files.
I propose working on a new component for IntelOwl this summer - Playbooks which would help people share and run automatically, the exact analyzers/connectors they like on a particular kind of observable. This would help IntelOwl strengthen its community while achieving its goal of helping burnt-out CyberSecurity professionals do their job more easily.
Apothesis is an open-source software that allows the simulation of thin film deposition processes via the Kinetic Monte Carlo method. Thin-film deposition is an important manufacturing step in the production of many opto-electronic, solid-state and medical devices and products, including consumer electronics, semiconductor lasers, fiber lasers, LED displays, optical filters, compound semiconductors, precision optics, microscopy & microanalysis sample slides, and medical implants. The computational simulation of thin-film deposition can offer insight into deposition processes and guide the development of technologies that streamline or enhance the thin film deposition process. Therefore, Apothesis can be a valuable tool for scientists and engineers working in this field. However, Apothesis’ applicability to many problems and popularity is severely limited by the settings (species growth/deposition geometries, processes) that can be specified by the user and the very specific input format (JSON format) that is not widely used in the scientific community. This project aims to improve the I/O operations and generalize them so that users/scientists can easily use it in an extended set of deposition processes.
This projects aims to complete the support for Constant Folding in GCC Rust frontend. It will do so by finishing the already started constant folding port from GCC C++ frontend. It will help gccrs to: - Evaluate const functions. - Specify static array size using const expressions. - Check for overflows. - Support const generics in Rust >= 1.50.0. The current port in gccrs has the following issues which will be fixed as milestones for this project: - Evaluation of non-const expressions inside const expression is not handled properly. - Argument binding for const functions is not supported. - Arithmetic Overflows are not detected. - Constant functions with complex bodies containing conditions and loops are not handled properly. Fixing these issues above will complete the support for constant folding and help the areas which need it in gccrs.
A key challenge surrounding modern bioinformatics is to manage and store the growing amount of biological data with both space efficiency and scalability. Traditionally, biological data are often stored as human-readable flat files or as entries in a conventional relational database. However, a drawback of such approaches is that the space required to maintain these data is becoming increasingly unmanageable, significantly reducing the scalability. Additionally, along with the size of the database, the time to query the database also increases. As stated in the problem statement, on Ensembl, homology data are currently stored as tuples in a relational database, resulting in the whole database being large and hard to scale. A natural way to compactly store the data is to exploit the intrinsic hierarchical structure of homology relationships. We propose multiple hierarchical data structures and formatting methods to improve the space efficiency of homology databases as well as important metrics to consider when designing such data structures and formats. We propose these potential approaches with the application in actual gene homology databases in mind. As part of the project, we will implement the representations using Python and/or C++ and evaluate them using proposed metrics.