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.
Transformer-based models are gaining more and more traction in many fields, including physics. However, they are particularly known to require enormous computational resources. Moreover, as the data and the complexity of models grow, so does the computational resources required to operate and train. Supplying this increasing demand might be unsustainable in future. Large Hadron Collider (LHC) data is a good example of this phenomenon in physics with the large amount of data it produces especially in the high luminosity phase of the LHC. Quantum machine learning might be a viable solution to this problem by decreasing the time complexity of the computation significantly. I propose implementing a proof of concept Quantum Visual Transformer model to classify a synthetic dataset of jets produced via Pythia8.
The use of superpages in modern hardware and operating system yielded important performance benefits. Unfortunately, allocating superpages can often fail due to a high rate of external fragmentation in physical memory. Thus external physical memory fragmentation in modern operating systems has once again become a serious issue. This project aims to design and implement several anti-fragmentation mechanisms for the FreeBSD kernel. At the time of writing, the FreeBSD kernel has no memory compaction mechanisms or any way of quantifying physical memory fragmentation. The first major goal is implementing several fragmentation metrics for the page allocation code. The second major goal is designing and implementing a runtime physical memory compaction mechanism. When invoked, this mechanism would identify sparsely populated and fragmented physical memory regions and rearrange the pages to eliminate any "holes" in the region. Aside from explicit invocation, a background daemon would monitor the relevant fragmentation metric and trigger the memory compaction mechanism should the value drop below a certain threshold. The last goal will introduce a passive anti-fragmentation mechanism for the demand paging mechanism. The key idea is to enhance the page placement code to use contiguous spans of pages instead of allocating random pages.
The users of IHR fall under the category of students, educators, professionals, network operators, policymakers, and researchers. The goal of this proposal is to visualize the internet resources through Internet Yellow Pages (IYP), which acts as an end-to-end solution for stakeholders to work on. Currently, IYP has data related to AS, IXP, Peer ASes, Sibling ASes, Countries, URLs, etc. The data can be visualized through tables, charts, and graphs (wherever possible) so that users can access much information. For example, a lot of information can be visualized about an AS including its Prefixes, IXP, Peer ASes, Sibling Ases, etc. I propose to develop a search page for the Internet Yellow Pages which is self-exploratory. The search page would let the user select either AS, Country, and IXP and correspondingly render tables, charts, and graphs to visualize the entity.
This project mainly aims to improve the overall code quality of O3 by enhancing the component test coverage. It also expects a well written documentation explaining the test strategy and best practices which other developers can follow for the future development of O3. Following this documentation will ensure that the quality of o3 is maintained and developers can have the confidence in their developed features.
I plan to enhance the RIoTPot by adding new emulated protocols (HTTPS, SFTP, SNMP). I also plan to increase RIoTPot's ability to evade being detected by tools like Nmap by adding high interaction support. I will implement reverse proxies in the middleware to route the requests to corresponding dockers that contains libraries used by real-life IoT devices (such as Apache httpd). The protocols with high interaction support include SSH, TELNET, HTTPS and SFTP. My timeline for these improvements is as follows: by June, I plan to add low-interaction protocols. In July, I will implement proxy routing for container traffic. From July to August, I will integrate high-interaction protocols and write documentation.
An important part of the analysis pipeline of high energy physics experiments is the generation of expected data from first principles. For decades, sophisticated monte carlo simulations have been performed, which are computationally very expensive and therefore pose one of the major bottlenecks in data analyses at CERN experiments. In recent years there has been an effort to explore the application of novel deep learning techniques to speed up the simulation by means of generative models. With the rise of Noisy Intermediate scale Quantum Computing (NISQ), the question comes up, if quantum machine learning can enhance existing methods. In this project we therefore explore the applicability of quantum machine learning to event simulation by means of a quantum Generative Adversarial Network.
The aim of the project is to read industrial meter with Deep Learning frameworks and OpenVINO .The project is divided into two parts. In the first part of the project, we created a deep learning-based solution to read industrial meters. We achieved this by first detecting meters in the frame with the EfficientDet-d0 model, then doing semantic segmentation of meters with UNET (with a Resnet50 backbone) to obtain a segmentation map with which we calculated readings, and for inference we use the OpenVINO runtime. In part two of the project, we further optimize the solution pipeline to support multiple camera inputs with OpenVINO-toolkit functions like AsyncInferQueue and other performance hints, along with a web-based GUI with HTML,CSS, JS, and Flask web framework.
The Human Neocortical Neurosolver (HNN) is open-source, computational neural modeling software that allows us to examine the cellular- and circuit-level basis of brain responses. HNN requires the hand-tuning of a large set of parameters until a close fit between simulated and recorded data is attained. This hand-tuning can take a substantial amount of effort thus it is in the user’s best interest to automate the process so that parameters can be optimized in a time efficient manner. The goal of this project is to develop optimization functions that will perform a wide search over the parameter space to arrive at faithful simulations. HNN is currently being used to develop or test hypotheses about underlying circuitry that gives rise to cognitive processes of interest. Developing a robust algorithm for parameter optimization has the potential to illuminate avenues for the diagnosis and treatment of multiple brain disorders and diseases, cognitive impairment, and psychiatric disorders. Finally, contribution to HNN’s codebase will aid researchers who use the tool in yielding important constraints to the development of theories about the origins of human brain responses.
The project aims to implement a High-level library for HTTP requests. The library would allow Fortran programmers to make all standard HTTP request methods (GET, HEAD, POST, PUT, DELETE, CONNECT, OPTIONS, TRACE, and PATCH). This project will use fortran-curl, a set of Fortran bindings to libcurl, under the hood. The outcome of this project is that consuming HTTP web services from Fortran applications would become significantly easier than ever before. Expected outcomes: Implemented a minimal but working capability to make HTTP requests from Fortran and parse data from the response body and headers
Developed the Drupal-Chatbot Module, delving deep into the Drupal ecosystem to create a module and block from scratch. This collaborative effort with a mentor and fellow developers led to the establishment of a user-friendly chatbot interface for Drupal documentation and contributor on-boarding. This interface provides interactive guidance for navigating intricate documentation, making it easier for new contributors to engage, and ultimately contributing to the accessibility and innovation of the Drupal community.
Introduction: The main idea of HAPIS Refurbishment is to have a simple functional application that is able to connect those who need something with those willing to offer it through an android mobile application where the user can simply fill in a form or view the list of seekers & givers any place in the world. Things offered can fall in any category such as food, clothes, electronics, books...etc. We will use the technology of Liquid Galaxy in order to visualize all Humanitarian actions all around the world by viewing on the LG the number of people currently offering something, or seeking something as well as some statistics such as the number of successful donations that happened either locally or globally. Controlling the LG would be through an android tablet application. Deliverables: - The mobile application fully functional - The tablet application fully functional and published on the Play Store under the Liquid Galaxy LAB account - Full documentation and code on GitHub
The objective of this project is to create a standalone Elasticsearch tool that can handle taxonomic-related requests. This tool helps to expand the Ensembl beta’s search functionality to include and support searching based on taxonomic information. In particular, to provide the users a list of close relatives when a given species is requested and it is not part of Ensembl (yet), return the list of species available given a taxonomic clade instead of a species name, or find a species even when a (homotypic) synonym is provided instead of its current scientific name.
The proposal introduces parallel backend based on `dask` for MDAnalysis package. Potentially, it will allow researchers to run analysis of the molecular dynamics trajectories much faster, depending on their access to HPC facilities, hence increasing the speed of obtaining valuable insights from large-scale molecular simulations. Briefly, the proposal aims to re-write protocol for `MDAnalysis.AnalysisBase.run()` method to use a scheduler-based approach. This is supposed to be done with gradually increasing complexity, covering each steps with respective tests to ensure backward compatibility: - simply re-write the protocol without adding additional complexity such as multiple processes - add multiple cores for a single node At this point, a mid-project checkpoint is set. - introduce cluster support that allows user to run analysis in an HPC environment with a `dask` backend - (optional) add tests for subclasses of the base class, and mark those that don't support such parallelization - (optional) add example jupyter notebook showing that a large-scale molecular dynamics trajectory can be analyzed in a parallel fashion much faster than before
The TLS Encrypted ClientHello (ECH) extension enables clients to encrypt ClientHello messages, avoid leaking sensitive fields, like the server name Indication(SNI), to the network. This project aims to implement Encrypted ClientHello (ECH) extension in GnuTLS.
This project aims to improve Keploy CLI workflow to make the user experience smooth. Since the UI has been deprecated, we need to make sure that the CLI is fully functional and easy to scale and modify in the upcoming years. For that, we need to have a stable API with the correct design decisions, since backwards compatibility for big projects is a must. The secondary goal of this project is to make the developer experience smooth as well. Keploy works, but the code is all over the place, unit test logic is embedded with actual code, there are lots of internal context on functions that should be better documented, etc. The last goal is to make it easy for the maintainers of the project to accept contributions from outsiders. Currently, one of the maintainers needs to manually test the changes locally to ensure that no regression has been caused. We need to automate this process, requiring stricter unit tests (which would only be feasible for newcomers if we have the framework in place).
The CVE Binary Tool helps the users to determine if their system includes any known vulnerabilities or not. This project idea focuses on creating a GitHub Action for cve-bin-tool which will produce CVE reports in the GitHub Security Tab and will be able to split the issues on the basis of triage. It will be smart enough to scan dependency lists of various languages and suggest version upgrades in the form of pull requests. Also it will produce reports in the form of html and pdf by default in the Security Tab. The GitHub Action will be configurable through yml config file and will be able to scan repositories and SBOMs.
Matching papers to reviewers based on topics is a crucial task for the Neurons, Behavior, Data Analysis, and Theory (NBDT) journal. However, the current automatic reviewer assignment tool that uses SciBERT embeddings, cosine similarity, and linear programming may not capture the semantic meaning of the text accurately. This project aims to address this limitation by finetuning SciBERT on the relevant corpus of data and selecting the appropriate optimization objectives. SciBERT can learn from both the left and right contexts of words and has a vocabulary that is more suitable for scientific texts than BERT. The project will involve creating a training dataset, pre-processing it, generating the appropriate features, selecting and fine-tuning SciBERT, generating the word embeddings from the fine-tuned SciBERT and choosing the appropriate optimization objectives (Contrastive Learning, Learning to Rank Diversely, and LambdaRank) according to the dataset obtained and the subsequent evaluation of its performance. The expected outcome is an improved tool that more accurately matches papers to reviewers for the NBDT journal and can potentially be useful in other domains as well.
The main goal of this project is to improve the user experience of Zulip Terminal by porting features from Zulip web which are not already implemented in ZT. The features to be implemented include supporting unsubscribed streams, direct message side panel and custom profile fields, while also improving unread cycle algorithms and topic matching.
This project aims to develop a user-friendly interface for configuring and managing popular VPN protocols like WireGuard and OpenVPN on Linux servers within the Cockpit web interface. By simplifying the process of setting up and managing VPNs on Linux servers, this project will enable users to easily and securely connect to their servers. I will collaborate with the Cockpit community to develop the necessary backend functionality and user interface features for the project.
MS-DIAL is a data analysis tool for metabolomics and lipidomics that supports data processing from import of mass spectrometry raw data to statistical analysis and peak identification by means of MS/MS spectral matching. MS-FINDER, a partner program of MS-DIAL, can predict molecular formulas, metabolite classes and structures for unknown spectra using in silico fragmentation. The aim of this project is to implement these MS-FINDER functions in MS-DIAL and develop its GUI to run the functions and display prediction results. That will enable more comprehensive data analysis using MS-DIAL.
The necessity of having an application for the automated generation of input files for computational chemistry codes is evident. The ccinput is an open-source command line tool and a python library. NW Chem is a popular, open-source software used in computational chemistry for many different areas. It’s free, easy to install, and can perform the vast majority of calculations any chemist might need. Therefore, I propose contributing to ccinput by adding a possibility to generate input files for NW Chem for main calculations.
Clang supports source-based coverage that shows which lines of code are covered by the executed tests. It uses llvm-cov to generate coverage reports. llvm-cov currently generates a single top-level index HTML/TEXT file. This causes rendering scalability issues in large projects. This project adds a new option `-show-directory-coverage` to llvm-cov which enables the generation of a hierarchical report mirroring the directory structure and solve scalability issues.
The Creative Commons (CC) legal tools are composed of three parts: a legal code, a deed written in simple language, and a machine-readable layer. Unfortunately, the machine-readable layer has not been updated in some time and contains unresolved issues. To address this, the task at hand is to extend the CC Legal Tools App to generate deterministic RDF/XML files for all of the legal tools. This will bring the machine-readable layer up to date with current specifications and ensure that the legal tools are well-organized and consistent, also the end result will be an improved user experience and a more reliable and efficient system for those utilizing the CC legal tools.
RooFit uses RooWorkSpace to manage its models. Currently, the syntax to interact with RooWorkspace is completely different from Python syntax, which makes the code less intuitive & harder to manage. The project aims at making the interaction with RooWorkspace more Pythonic. Pythonization RooWorkspace is done in two main steps: 1.) Writing a C++ plugin for the RooWorkspace factory 2.) Writing Pythonizations This is followed by making unit tests, writing documentation & writing tutorial for the new Pythonic interaction. The deliverables for this project are: ● Develop a Pythonic alternative to RooWorkspace::factory() ● Pythonization of special operations of RooWorkspace along with support for creating Histfactory p.d.f.s using the JSON I/O ● Write unit tests to check the functionality of Pythonic code ● Make tutorials to demonstrate the usage of new functions in Python & improve documentation for HistFactory