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.
NodeCloud is an API for the open cloud and acts as a package to abstract away the specifics of implementation for multiple cloud providers, as a developer it then becomes relatively easier to leverage cloud services without getting bogged down with the specifics of the individual cloud providers. The current implementation of NodeCloud is a core library that supports AWS, Azure, GCP and DigitalOcean cloud services as extensible plugins, along with an automatic class implementation generator that is built by leveraging the TypeScript compiler API. The aim is to extend this plugin functionality built into NodeCloud to include another emerging cloud provider i.e. Alibaba Cloud, also known as Aliyun, is a cloud computing company, a subsidiary of Alibaba Group. I aim to implement the core functionalities of the AliCloud platform in a suitable SDK, implement a code generation module for that and then use that SDK to auto-generate classes, assembled as the alicloud-plugin.
This project entails the creation of a GCBM Simulation Editor for the FLINT-UI. Currently, all of the configurations for running the simulation are stored in a JSON file and uploaded. In this project, the configuration interface with proper labels, interface for running the model and finally downloading the output is to be created. This will enable scientists and researchers to configure the GCBM Run easily using a simple User Interface.
In this project we will implement two types of Robust Portfolio Optimization in the R PortfolioAnalytics package. The first type is robust towards uncertainty in mean return forecast and the second type is optimization with control over outliers in mean return. Our main approach will make use of CVXR package along with the open source solver SCS for the first type of Robust Portfolio Optimization, and the RobStatTM and GSE packages for the second type. The deliverables includes: 1. Design and implement the Mean-Uncertainty Robust PortOpt using the CVXR package and SCS solver. 2. Integrate the CVXR based Mean-Uncertainty Robust PortOpt code into PortfolioAnalytics. 3. Implement the Outliers Robust PortOpt for CSO type outliers by integrating the function covRob() from RobStatTM into PortfolioAnalytics.. 4. Integrate TSGS() function from GSE package into PortfolioAnalytics so that it’s capable of controlling IOA type outliers for Outliers Robust PortOpt.
This project aims to provide unified Grafana dashboards to visualize K8s controller/operator status based on Kubebuilder. In general, users have to design and create their own Grafana dashboards to observe their controllers/operators. It would be great if we can provide a unified and comprehensive one, then users may: 1. easily visualize controller/operator metrics 2. avoid duplicate creation across different teams 3. have more insights given by the rich content in the dashboard Basically, I plan to create a Kubebuilder plugin, that can be simply triggered to provide: 1. dashboard resource that users can easily apply 2. selective dashboards to bring more insight in certain fields Additionally, this project also covers following features collected from the community: 1. dashboard auto-installation when controllers are deployed 2. new metrics to instrument user-defined CR 3. additional dashboard to observe CR/CRD related resources Ideally, the project would provide a full-featured yet simple solution for users to monitor their CRs and relative controllers in detail.
The BlobToolKit, implemented with Snakemake, is a pipeline designed to obtain quality metrics for eukaryotic genome assemblies. BlobToolKit is also capable of detecting contamination, which are DNA fragments in the genome assembly that belong to a different species. Here, I describe how to convert all the Snakemake sub-pipelines to Nextflow sub-workflows using nf-core modules that can be combined into a single workflow or end-to-end pipeline. Converting this pipeline to Nextflow will allow: (1) its integration into the programme’s bioinformatics infrastructure, and (2) an open source nf-core pipeline that can be used by the bioinformatics community.
I am planning to develop a Latex to XML pipeline and adapt the final format to PMC requirements and integrate the pipeline with the current Scholastica platform and explore a standalone platform for NBDT Journal. Deliverables ● Creating a pipeline to convert latex papers into XML. ● Adapting the final format to PMC requirements. ● Integrating with the current Scholastica platform. ● Exploring and prototyping a standalone platform.
This project aims to implement the HTTP-Trace option for login scanner modules. When enabled, the HTTP-Trace option lets the user see every web request made to the server by the module and its respective response. This provides the user with more verbose details, which helps them in better analyzing any errors that may occur when running the module. This additional information can then be used by users to more effectively determine the root cause of any errors encountered when testing login scanner modules, allowing for quicker and more effective debugging sessions.
CodeLabz is a platform where the users can engage with online tutorials and the organizations can create tutorials for the users. The platform is developed using ReactJS front end library and the back end is developed using the Google Cloud Firestore and Google Firebase Real-Time database. This summer I am going to develop and improve tthe User Interface and design the app.
Extension of OpenRAM to provide the automated generation framework of Register File which will be based upon DFF and using standard cells of skywater library and generate spice netlist using api of spice and automatically generate its layout, verilog model and timing characterization. Because the address decoders and muxes from SRAMs are the same for both SRAM and Register File, we will utilize them for DFF-based Register File. We first establish the logic schematic of the Register File and use multiplexer since we don't want to route all of the wires over the array, which would consume a lot of metals and be difficult to automate. For a tri-state multiplexer, we will use tristate for each D FlipFlop because this will use the same data line throughout the array of DFFs for easier and better routing. We would use the spice netlist API to implement this logic in OpenRAM and then we will simulate it then generate the layout of the array and add decoder by reusing from SRAM.
The goal of the project is to develop reusable building blocks for visual exploration of Internet data. The building blocks will be developed in the ObservableHQ platform, which uses the popular visualization library D3.js. The building blocks will be open-source code, published as templates in the ObservableHQ platform. Any user would be able to fork/copy a template and plug their own data, and/or modify it according to their needs. Since the code will be in D3.js, the building blocks can be re-usable by any javascript component, not only in ObservableHQ. The targeted users mainly are Internet researchers and network. There exist various types of Internet data, mainly, tabular data (e.g., ASN or latency value), timeseries (e.g., AS hegemony per day), graphs (e.g., routing graph), paths (e.g., traceroutes, BGP paths). We will create at least one building block that can visualize each type of data. Different types of data need different types of visualizations. We will consider a range of visualizations, such as, sankey diagrams (very useful to visualize relations, paths, etc. in Internet data), graphs, geo-maps, distribution plots (e.g., histograms, violin plots), dendrograms, heatmaps.
qutip-qip currently does not perform optimisation and scheduling at gate-level in quantum circuits. Allowing circuits to be imported from qiskit will allow qutip to take advantage of qiskit’s gate-level optimisation techniques. It will also provide a standard qiskit interface that enables us to use qutip-qip’s pulse-level circuit simulation. The outcome of the project will be custom qutip-qip backends based on qutip-qip's existing simulators and a module that allows qiskit to use these backends.
Implementation of Ferminet with PyTorch. Ferminet is a neural-network-based Variational Monte-Carlo technique that aims to minimize the local energy of the molecule system and finds the electronic configuration with as much accuracy as possible. This project adds support for further ab initio based DNNs in Deepchem and adds second-order optimizers like natural gradient descent and K-FAC into the Depchem's codebase.
The proposed React Native SDK will expose React Native components with a similar functionality of the already known Jitsi Meet Native SDK classes. These Native SDKs are utilising a React Native Component at their core that exposes Jitsi’s functionality for native mobile apps. The React Native SDK classes will communicate directly with the existing core component using props and offer the customisation options known from the native SDK. The deliverables are: - A React Native SDK containing the complete functionality of the native SDKs - A test suite for the SDK - An API reference with examples
Use of Hydra-Space in order to make an asynchronous chess game, so two-player could play from different places so we will use satellites communications. The first idea is to adapt the chess logic using the already existing GNU Chess so we will need to implement the game communications. About the front-end, we will display the Chess game in the LG-rig, just like the LG-Retro-Gaming games (Snake, Pong, …)
This project aims at creating a step-by-step form to help beginners submit a Wikipedia edit request. An edit request is a request for someone to change some text in an article. Edit requests are an important part of Wikipedia. The form created in this project will help the edit requests comply with Wikipedia policy. It will be developed as a Wikipedia user script that shows a form for submitting a Wikipedia edit request, with high-quality guidance and error messages, suitable for use by beginners, and a backend server that the user script will make calls to for validation of source and quote.
This project aims to introduce a new testing strategy so that we encourage Behaviour-driven Development here, at Phoenix — the official web event display of the ATLAS experiment. The whole testing setup of Phoenix needs a complete revamp. Currently, Phoenix as a project comprises 3 packages: phoenix-event-display, phoenix-ui-components, and phoenix-app. And, my goal is to set new benchmarks and coverage thresholds for these 3 packages that will essentially, enforce and encourage testing for the whole of the project with Behavior-driven Development as its sole motivation so that potential issues that may occur in a critical environment can be identified much before they happen. This can effectively help us to troubleshoot problems and bugs so that the changes that will be made in the future to the codebase can be deemed reliable.
Polyphorm is an interactive tool to analyze intergalactic gas and dark matter filaments (together known as 'Cosmic web') using the Monte Carlo Physarum Machine (MCPM) algorithm inspired by the foraging behavior of Physarum polycephalum 'slime mold'. While, PolyPhy will be a Python-based redesigned version of Polyphorm, currently at the beginning of its development cycle. PolyPhy will be a multi-platform toolkit meant for a wide audience across different disciplines. Through this project, we aim to create a website dedicated to this technology. To begin with, we will be incorporating information, guides, purposes, documentation, and much more about all the features that the PolyPhy technology offers us on this website. Interactive interfacing with appropriate linking is also an important part of the website. This project will serve as a platform for people to know about the software with all its details. Our goal through this project is to create an integrated hub for passionate contributors to find out about everything PolyPhy.
1. Understanding the Flow and Discussion: Make a clear understanding of the flow of data between the mobile and the server, Including how the app loads the data. In the process of doing so, it will be much more clear and more precise to figure out ways for implementing a fast offline experience. 2. Implementing the offline save mechanism: With proper knowledge about the exact workflow how the data flow is, the first step I think of storing the data for the already scanned and opened products. This in turn will facilitate the users to look up the already scanned products without the need for an Internet connection. 3. Offline Edit Mode: After being done with the above two works, the 3rd and most important phase will be Carried out. A clean and working mechanism to store the changes locally will be Discussed with the mentors and start the work on the same to store the changes and sync those changes when online and delete the offline changes so as to keep the app as lightweight as possible. 4. Preloading Data: If time persists and the above work is done(which I am sure will be done), add a mechanism to preload the data as cache (as step 2) so as to let the users use the app for popular food items in their country out of the box 5. Testing: After the whole work is done, a clean throughout the testing of the implemented features is to be carried out so as to ensure a steady smooth experience.
The study of dark matter substructures has shown promise in addressing the open-ended and long-standing challenge of identifying the true nature of dark matter. Strong gravitational lensing is a potential way to learn more about dark matter's basic nature by probing its substructure. Deep learning approaches can properly recognize images with substructure and distinguish WIMP particle dark matter from other well-motivated models including dark matter condensates, superfluids, and vortex substructure. The DeepLense pipeline combines state-of-the-art deep learning models with strong lensing simulations based on lenstronomy. The focus of this project will be training and testing deep learning models with various architectures on new dark matter simulations (e.g. WDM and SIDM) in order to update the previous results of classification, regression, anomaly detection, etc. for the DeepLense Pipeline.
This project aims to build a platform to see BIM models and their corresponding metadata both in an android 10’ tablet and on the Liquid Galaxy Cluster. The models will be shown in a scene created with the Unity Engine, that is a game development engine. With the tablet it will be possible to look and interact with the scene using augmented reality. The android app will also allow you to open the scene on the Galaxy cluster and when this option is chosen a new screen will be opened with a controller for the scene. The scene that will be running on the galaxy will be a WebGL scene, so for that a chromium based project will be developed using Node Js. The node app will interact with the Liquid Galaxy using web sockets and in this way it will be possible to synchronize the displays.
This project aims to make the model which would already be trained for the classification of species and detection of alive and dead, trees or birds using transfer learning on the current release model which is based on object detection, only detecting trees and birds, for now, It also involves improving the user interface for working with the multi-class model for a better understating of the species.
In this proposal, I have proposed a fix for some validation issues that have been accumulated. I will be using beam jobs to solve these validation issues and will make sure that they do not occur in the future. There is a total of 12 validation issues that are present in this project and I have explained how will I be working on them. Thanks
This project is an enhancement to the previous work that has been done. Its goal is to make annotation simple and easy while also providing a well-defined manager-nnotator-reviewer framework. The goal of this project is to use Transfer Learning (TL) approaches to make the annotation process easier for the user by offering label predictions. This way, it will be possible to accomplish more with less data and effort. - An analysis of pros and cons of existing work such as BAT, YAMNet and MusicNN. This task will help us understand the drawbacks of the existing implementations and try to avoid them while keeping all the already made advantages. - Enhance the already made database which will be used to store the corrections in order to refine the model. - Research and design of the transfer learning model and an explanation for the architecture. - Implementation of the aforementioned model. - Enhancements of the already made Graphical User Interface providing Mock-up screens. This task includes the design of every addition on every screen in our tool and it should be discussed with the mentors before the implementation. - Implementation of the changes on User Interface and system for the use of the AI-Assistance. - Implementation of the whole AI-Assisting model. - Perform Django lazy loading, testing and Dockerization - Documentation
Gnuastro is primarily written in C because astronomical datasets are large and thus need to be efficient with few dependencies. Therefore, its most commonly used interface are Gnuastro’s command-line programs. However, Gnuastro’s also has an extensive set of installed, dynamic C/C++ libraries, which are the actually beating heart of the programs. On the other hand, many projects today are done in Python, almost excuslively using Numpy for their numerical operations (like data arrays). Python and Numpy are actually written in C, therefore they have very well-defined interfaces for communicating with installed C libraries, using CPython. Since both Gnuastro and Numpy's core data structure are very similar, we plan on building a converter between the two. This will make it possible to perform all data operations using Numpys C-API. This will be followed by adding a low-level wrapper infra-structure which will allow easy usage of Gnuastro’s powerful libraries in Python. Thus, the final goal is to have Gnuastro be an importable module in Python (just like Numpy) and have all the inner data operations of Gnuastro be performed using Numpy's C-API.