Explore Projects

enviroCar Mobile is an Android application for smartphones that can be used to collect Extended Floating Car Data. The app communicates with an OBD2 Bluetooth adapter while the user drives. This enables read access to data from the vehicle’s engine control. The data is recorded along with the smartphone’s GPS position data.The driver can view statistics about his drives and publish his data as open data. The latter happens by uploading tracks to the enviroCar server, where the data is available under the ODbL license for further analysis and use. The data can also be viewed and analyzed via the enviroCar website.

<p>My GSoC project in 2019, on the Adaptive Cloth Simulator, was an exploration in adding support for parametric on-the-fly remeshing for Blender's Cloth Simulator in order to provide high-resolution-equivalent fidelity at reduced computational cost. During GSoC 2021, I will utilize the insights gained, as well as previously fleshed-out core ideas, to stabilize this feature for production. This will involve introducing a new mesh structure, fixing bugs and regressions, refactoring to integrate well with the latest Blender updates, etc. As a stretch goal, I would improve Blender's cloth caching system to introduce support for Adaptive Remeshing.</p>

<p>Project Information Nomos and Monk are the two leading scanners FOSSology uses for license detection and Copyright for scanning copyright,url,emails and holders name. FOSSology approach is to detect licenses with either a large (large: 2500 regexes) dataset of regex patterns (nomos) or a full string comparison against license full texts (large: ~400 text) (monk). Atarashi license scanner implements multiple text statistics and information retrieval algorithms. ScanCode Toolkit is a very established license scanner similar to Nomos or Monk. It is a simple python based command line scanner that runs on Windows, Linux, and Mac. It implements a number of different approaches and integrates these into one application for identifying and classifying license relevant content in packages. The basic idea is to use the command line interface from the ScanCode package in order to be called right from the FOSSology application. FOSSology will pass a single file and take the result from the ScanCode command line call. Scan result will include license name, the SPDX key, Score, Copyright and Holder name, Emails and Urls present in the given code and as per requested by the user.</p>

<p>VulnerableCode has a large number of pending tickets that require adding more data sources of known vulnerabilities (aka. importers). As importers sit at the heart of VulnerableCode, the primary goal is to improve their efficiency and implement as many of them (at least 15) as possible.</p>

<p>We come up with models that give the effective and efficient visualizations as recommendations to the given input. Current visualization tools require the user to manually select attributes and analyze the data. For someone who has limited time and domain,this gets challenging if there are millions of attributes to derive insights. To overcome this problem, we automate the process with deep models</p>

<p><strong>Nuitka</strong> has support for many built-ins, e.g. len already, which means dedicated C code, compile-time evaluation, type shapes produced (in this case an int), but there are some notable exceptions, e.g. enumerate where we know types too, that are still missing but definitely can have high-performance impact on some loops. Not having that means that enumerate using loops are loosing out on many optimization opportunities. This project aims to identify and optimized missing built-ins to achieve complete support for ultimately all C built-ins.</p>

<p>The aim of this project is to add support for HEIF/HEIC files in FFmpeg. High Efficiency Image File Format (HEIF) specifies the storage of individual images, image sequences and their metadata into a container file conforming to the ISO Base Media File Format (ISOBMFF). This format has increasing usage in mobile devices.</p>

<h3>Module for Approximate Bayesian Computation</h3> <p>Approximate Bayesian Computation (ABC) algorithms, also called likelihood free inference techniques, are a family of methods that can render virtually impossible models to feasible scale. Additionally, the ABC approach has proven to be successful over likelihood based methods in several instances and is conceptually linked to recent and very innovative Deep Learning developments such as Generative Adversary Nets. We propose to implement a module for ABC in PyMC3, specifically Sequential Monte Carlo-ABC (SMC-ABC). Our work will signify a meaningful increase in the spectrum of models that PyMC3 will be able to perform.</p>

<p>Shogun is a powerful machine learning toolkit. The project has a long history and a huge codebase. Some parts are very outdated and not well-designed. Polishing the codebase and bringing Shogun to modern design will make it much easier to developers, and as such make the project more attractive for scientists to implement their work in. This GSoC project aims at re-designing Shogun’s data representation and some APIs, including features, labels and preprocessors, and bringing novel un-templated data classes with support for lazy evaluation to Shogun. By the end of this project, we expect an improvement of maintainability, stability, and beauty to the codebase of Shogun.</p>

<p>ElixirBench platform is a proof of concept that already showed its value, the key deliverable is to bring it up and running for nightly performance monitoring for significant Elixir projects. Given a project in the Github, it will be possible to activate the benchmark service and to automatically monitor the performance of the new released versions by setting up a bench/config.yml file and the benchmark scripts to be run for that project.</p>

<p>Addin system of MonoDevelop/Xamarin Studio (<a href="http://www.monodevelop.com/download" target="_blank">http://www.monodevelop.com/download</a>) is very flexible and allow the developers to add or extend any feature in the IDE .CBinding addin allow the developers to use C/C++ for writing the solution. However, there are still many features that are missing, some of them are :-</p> <p>1) Ability of the CBinding to use compilers present on Windows (GCC/MSVC/MinGW32), this will also require support for CMake as that's the only project format CBinding currently has .</p> <p>2) Implement support and switching between various Toolchains available in CMake.</p> <p>3) Detect missing dependencies (libclang, CMake etc) and prompt the user to install them.</p> <p>4) Adding various refactoring features .</p> <p>There are many other things that can be done to make it even more better like improving project and file templates, improving code completion, adding a test suite etc . Since old "MD1" project system is no longer supported so it can also be removed.</p> <p>Main purpose of this proposal is to come up with an idea to implement some of these features and make changes to the existing ones.</p>

<p>WS-Trust is a WS-* specification that provides extensions to the WS-Security specification. WS-Security provides the basic framework for message level security in web services. WS-Trust builds on that base to specify a framework for broker trust across different security domains. It specifically deals with the issuing, renewing, and validating of security tokens, as well as with ways to establish, assess the presence of, and broker trust relationships between participants in a secure message exchange. This project focuses on implementing the WS-Trust specification for the WSO2 Identity Server 6.0.0 by simply integrating with Apache CXF.</p>

<p>Adding CNN based classifiers and dectors to the OpenDetection framework. This requires implementation of training methods and detection methods for both classifiers and detectors with Caffe backend. The main deliverables are:</p> <ul> <li>Brief Report on existing algorithms for object detection, which can be used as guidelines for future contributions in OpenDetection. <a href="https://github.com/gautamMalu/opendetection/blob/algo_report/ObjectDetection.md" target="_blank">Something on these lines </a></li> <li>Basic Utility functions for Caffe interfacing.</li> <li>Implementation of base trainer class for CNN based methods.</li> <li>Implementation of base trainer class for CNN based classification methods.</li> <li>Scripts for data preparation for classification.</li> <li>Implementation of base detector class for CNN based detection methods.</li> <li>Implementation of classifiers methods for various CNN architectures (Alexenet, VGG-16, ResNet).</li> <li>Implementation of detector method based on pre-trained detector methods (faster-RCNN, YOLO).</li> </ul>

<p>LilyPond's internal representation of chords is limited. As of now, it can mostly only represent the individual notes themselves that make up the chord. In addition to a chord's specific notes, there are numerous musical characteristics that define a chord. The goal of this project is to design a representation of chords that carries not only information about the specific notes, but other musical and semantic information important to the chord as well.</p>

<p>Session Restore is important as a key feature of Firefox. Many people rely on it to re-open a tab from the past or recover from an unfortunate power outage. This project's goal is to make the process snappy and blazing fast.</p>

<p>Netlink is a network protocol that is used to communicate between the kernel and the userspace. For example, iproute use netlink in order to configure the network stack (interfaces, addresses, routes, etc). It is also used by the kernel to report hotplug events to the userland. The goal here is to add support in strace to decode netlink packet structures in order to be able to debug and discover netlink messages.</p> <p>In 2016, the base ground work was done, now it can be extended to support more netlink family protocols.</p>

<p>Shogun is an amazing machine learning toolbox with good set of algorithms available. Since the project is old, the code base is huge and it's old. A major refactor of code is required to make the development process better and improve the user experience. This can be done by making Shogun support plugins which requires all of the code to be migrated to the plugin framework. I also aim to develop a new parameter framework to improve the syntax of the API which is exposed to the user via SWIG. This would also make installing Shogun much easier (which is an important priority of Shogun community) as base library will be small and most of the features will be enabled by installing plugins for the base library with their own dependencies.</p>

The recent efforts of the `scala-wasm` project have made it possible for Scala to use the WebAssembly Component Model binary format as a compilation target. Although, the implementation has not yet been finished, it is already possible for developers to run Scala code on Wasm runtimes. In order for the Scala language to succeed in the Wasm ecosystem, core libraries which rely on platform APIs must be ported to the Wasm/WASI platform. The goal of this project is to prototype porting the core parts of the Cats Effect and FS2 libraries to the Wasm/WASI platform. The CE runtime prototype will be single-threaded and based around `wasi:io/poll`. The end result is expected to be similar to the (now-replaced) single-threaded LLVM runtime which used a `libuv`-style event-loop. The FS2 porting effort is going to focus on `fs2-core` and the `network` and `file` APIs from `fs2-io`. As a part of this project, a standalone reimplementation of java.nio.file API will be developed as a separate library. Planned Deliverables: 1. A working prototype of Cats Effect's single-threaded runtime compiling and running on Wasm/WASI free of glue JavaScript code. This prototype will serve as a basis for an upstream implementation. 2. Prototype port of the core FS2 module and the fs2.io.file and io.network APIs. 3. A standalone library reimplementation of JDK file APIs for WASI. Initial scope of the implementation will be adjusted to the needs of the fs2.io.file port. 4 An extensive documentation of the project. 5. A report regarding implementation details and findings discovered over the course of the project which will help with further porting efforts of Scala compilers and other platform-dependent libraries. 6. Wasm test environment and CI created for this project can upstreamed to sbt-typelevel so that it can be used in other projects.

Historically, rustup has relied on $RUSTUP_HOME (defaulting to $HOME/.rustup) and $CARGO_HOME (defaulting to $HOME/.cargo) as monolithic directories for configuration, state, and data. In coordination with the Cargo team, this proposal aims to migrate `rustup` to use the standardized XDG Base Directory Specification on Linux. To achieve this safely, we will transition from a "dual-directory" approach to a "fine-grained" directory approach, unblock Cargo's own XDG migration, and establish a strict backward-compatibility protocol for existing installations.

The OpenPrinting ecosystem includes several utilities for driverless printing, protocol implementation, and printer management, including projects written in Go and Python. These polyglot projects currently lack fuzz testing, making them prone to undetected bugs and security issues. This project proposes integrating such polyglot OpenPrinting projects, namely ipp-usb, goipp, pycups, and pyppd, into OSS-Fuzz to enable continuous, large-scale fuzzing. The work will include evaluating current unit tests, improving coverage where lacking, identifying suitable fuzzing targets based on test coverage and risk, developing fuzz harnesses, and integrating the projects into OSS-Fuzz. This effort will help expand OSS-Fuzz coverage across OpenPrinting projects, further strengthening their overall security and reliability.

This project aims to enhance the performance of the LLAMA2 model by fine-tuning it specifically for Jenkins data, thus enabling users to access Jenkins knowledge through a user-friendly interface. By leveraging data from Jenkins documentation and other relevant sources, the model will be refined to better understand and respond to domain-specific queries. The project involves conducting data preprocessing, fine-tuning the LLAMA model, designing a simple graphical user interface (GUI), and integrating the refined model into the system. Through testing and user feedback, the project aims to ensure the robustness and usability of the system. The deliverables include a system architecture design document, data preprocessing/refining documentation, a user-friendly GUI, a fine-tuned LLAMA2 model, testing reports with results, and a maintenance plan/documentation. The project will empower users to interact with Jenkins knowledge more effectively, thereby enhancing the accessibility and usability of the software.

This project aims to develop a blockchain-based funding platform. At its core, the platform utilizes a proportionality formula to determine the amount of funding each proposal will receive. It also allows the creation of secure funding vaults and enabling users to submit proposals for funding tokens. User experience is a key focus of the platform, with features like stepper based forms designed to enhance engagement and accessibility. The platform uses session-based authentication to ensure secure access for the users. It also includes a personalized "My Activity" page which provides each user with a personalized interface to track their interactions and contributions within the platform. Users can create dedicated spaces for creating multiple funding vaults tailored to specific communities. This feature allows for more targeted and relevant funding opportunities.

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.