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.
The CLUE algorithm is a clustering algorithm written by Rovere et al. in C++, which is used in High-Energy Physics to reconstruct particle showers by connecting hits detected by a calorimeter. This project aims to generalize the clustering CLUE algorithm to N-dimensions, by introducing a new set of coordinates and a new metric, bind it with Python using the Cython or PyBind11 tools and interface it with Pandas DataFrames and NumPy data structures, and finally to test its performance and compare it with other clustering algorithms'. This project will take approximately 350 hours, from mid June to mid September.
Eye tracking can be used for a range of purposes, from improving accessibility for people with disabilities to improving driver safety. However, modern state-of-the-art mobile eye trackers are costly, often bulky devices that require careful setup and calibration, and they tend to be expensive. In this project, therefore, we aim to develop an affordable and open-source alternative to these Eye Trackers. In this project, we improve upon the basic implementation of Google's paper which is able to obtain very good performance using simple CNNs. We implement the architecture and train the model, run SVR experiments, and compare the results with Google's own implementation. We also need to connect them with an android application for data collection, as well as for evaluating the model’s performance in real time.
In this project, I plan to extend PEcAn by building two data ingestion workflows that will improve the modelling capabilities of PEcAn. The first will ingest weather forecast data from ECMWF, and the other will adopt a standard for agricultural management practices such as planting and fertilisation that are required by crop models.
Plugin plays an important role in the Joplin community. As there are more and more plugins it would be good to improve how they are discovered and to improve search - in particular, improve search relevance. To optimize the plugin discovery process, two things need to be done. Firstly, we need a plugin website that allows users to find and download the plugin. Secondly, the built-in plugin search function needs an upgrade to provide detailed information and improve search relevance.
LabelLab is an image analysis and classification platform for Machine Learning researchers. The goal for this year's GSoC is to improve the collaborative and version tracking system of the project by :- Create a ticketing/issue tracking system inside projects (e.g. Similar to Jira). Some changes and restructuring in the pre-existing project activity tracking system. \ Enhance the chat system present inside teams. Migrating this project to V2 embedding.
Since QEMU is gaining introspectable QMP statistics, it will now be possible to fetch more statistics using the QEMU api. This project aims to integrate this into libvirt to report more user specified statistics in as detailed and efficient manner as possible.
The proposed project aims at establishing a port between GHC and [MMTk](https://www.mmtk.io/) -- an external memory management toolkit that provides languages with a set of memory management primitives and garbage collectors. The current existing GHC storage manager (GHCSM) has a sophisticated generational GC; However, it's also optimized and integrated into GHC's runtime, making it difficult to switch to a broader range of collectors. It would be beneficial to generalize GHC's runtime, make it separable from GHCSM, and connect it with a suite of different garbage collections from MMTk. To achieve this goal, we propose to: 1. Refactor GHC's runtime system to more effectively abstract over storage management operations; 2. Introduce a storage management backend using MMTk's trivial no-GC collection plan; 3. Integrate write barriers necessary for generational collection with MMTk; 4. Introduce support for MMTk's semi-space and mark-sweep GC plans.
The Many Lights Sampling project has been a long-standing project over the course of Blender’s development. It is meant to improve Cycles render times in scenes with many lights, so that artists may be more flexible when it comes to creating and lighting environments. Although a lot of work has already been completed in regards to the Many Lights Sampling algorithm, the goal of this project is to merge this work into the main branch after sufficient testing and user feedback.
This project aims to implement the sequence space jacobian methods of Auclert et al. (2021) into the Heterogeneous Agents Resources and toolKit (HARK) under the econ-ARK project. These methods would allow the HARK toolkit to provide open source software for economic researchers to solve heterogeneous agent macroeconomic models. To implement these computational methods, objects and tools in HARK will be extended to allow for the efficient simulation of a macroeconomic model, the computation of Jacobians to linearize a model, and the computation of impulse responses to a linearized model. At the completion of this project, economic researchers will be able to simply specify the equations that define their model and be immediately returned the solutions to their model.
inetd enhancements to allow it to babysit general daemons, not just networking ones. To make it a service management program for starting, stopping and managing daemons, processes and other programs. This will give inetd the ability to keep daemons alive (even when they crash), start them after various specified events/intervals and specify scheduling priority of them. And, a new command line utility to add/remove/start/stop new services.
Orcanode repository contains a set of projects distributed in different directories that provide a number of tools to deal with capturing, processing, and uploading audio files archived at the Ocean Observatories Initiative (OOI) site. However, there are a few issues that need to be resolved and other enhancements to be made. This project focuses on the following: 1. Handling lags in miniSEED audio data fetched from the OOI website. The missing data issue also needs to be resolved. 2. Leveraging cloud tools for continuous pulling and streaming of data to reduce local system dependence. 3. Integrating the data with the Orcasound website and streaming hls format for users to listen.
Control-flow hijacking attacks represent one of the most recurrent methods of gaining fine grained access to a system. Forward edge attacks (through function pointers and virtual calls) were proven to be less accessible after implementing Control-flow integrity (CFI) solutions. However, backward edge attacks easily bypass present instrumentation (Safe Stacks, canaries). Under these circumstances, shadow stacks become more than necessary: shadow stacks are a defense mechanism that require metadata about the program’s state to enforce their policies. They protect the return value of the functions by comparing what’s pushed into them with what resides in the traditional stack, practically, functioning as a backup and check storage. My project will consist of comparing different implementations of shadow stacks with their advantages and disadvantages, crafting a compelling PR, that would perfectly fit Unikraft's vision regarding modularization and portability and a clear discussion of the overhead brought by such an approach.
cve-bin-tool currently uses the National Vulnerability Database as its only source of vulnerabilities. However not all vulnerabilities are captured in the N.V.D and there are other sources which may also be useful in understanding the vulnerability status of a product. This project aims to add data sources for vulnerabilities, by creating a framework that allows for the use of multiple databases, and minimises duplicate reporting of vulnerabilities.
mitmproxy is a superb tool for security and privacy forensics. It currently supports HTTP/1 and HTTP/2, but lacks support for QUIC and HTTP/3. This leaves about 25% of the web's traffic in the dark. The project's goal is to change that. To achieve this goal, UDP support and layers for QUIC and HTTP/3 need to be implemented in mitmproxy. For UDP, stream-like readers and writers will be introduced. Facilitating a library will aid in implementing QUIC, preferably aioquic. The new HTTP/3 layer will be based upon mitmproxy's existing HTTP/2 layer. Once the project is complete, QUIC and HTTP/3 traffic can be inspected using mitmproxy as well, just like HTTP/1+2 today. As a bonus, DNS capabilities will also be available, as a proof-of-concept for UDP support.
The Performance API is a set of web APIs that implement the Performance interface of the High Resolution Time standard. The interface is exposed under the window.performance object and allows web developers to accurately determine and diagnose slowdowns, bottlenecks etc in their web applications. To ensure all developers encounter consistent behaviors and implementations of the Performance API across different web browsers, the web-platform-test project has a suite of tests that can be used to determine the browser's compliance with the current specification. These include tests for ResourceTiming, NavigationTiming, PaintTiming, ServerTiming, EventTiming portions of the API, and tests related to reporting the Performance entries and dealing with various methods of preloading resources. In this project, I will be working with mentors to bring Chromium’s implementation of the Performance API more in line with the implementation specified in the web standards. This will be done by analyzing, debugging and fixing failures reported by the web-platform-tests project. By the end of the project, I would want to achieve a 100% pass on all tests in the web-platform-tests suite and be able to address and provide fixes for tests that fail intermittently, as reported on the flake portal.
Codelabz provides a platform that consists of guided tutorial which has been created by organizations for the users. Codelabz is developed using ReactJS, Material UI in the Front End, and Google Firebase in the backend. I would like to contribute to Codelabz because I have the frontend skills that are required to make the current web pages more user-friendly and interactive. We were asked to finish the Pre-GSoC task which I have completed. I have made stories of all the most used Components from my Figma design using Storybook. I really like this project and would keep on contributing in the future even after the GSoC 2022.
This project is based on the proposed project (Learning Loop Transformation Policies) by the mentors Johannes Doerfert, Mircea Trofin. This project would like to experiment on how the compiler may learn for improvements by observing from the back-end. We can try it on RISC-V, an open instruction set architecture.
PDC (Proactive Data Containers) is a software-defined data management system meant for high performance computing systems with several layers of storage, aiming to minimize overhead of moving data between memory and storage layers. Its existing interface is written in C, but with the rise of Python in scientific computing applications, PDC would be much more accessible with a python interface as well. In this project, I will build that interface, document it, and test it by translating parts of the existing test suite.
CGAL currently uses the Boost Parameter Library to provide a convenient way for users to pass parameters. However, with the evolution of C++ Standard, we would like to create our own API for passing named function parameters. To do so, we create our own API which emulates the Boost Parameter Library, while preserving the current API.
Ruby 3 introduced Ractors, which allow true concurrency in the language. However, Ruby's stop-the-world Garbage Collector (GC) pauses all of the Ractors when doing Garbage Collection. This diminishes the efficiency of using Ractors. This project proposes to modify the Ruby GC to improve its performance with Ractors, ideally by having only one Ractor paused at a time. The idea is to investigate the ways in which the GC can avoid interfering with objects belonging to Ractors that it is not working on, which would allow these Ractors to continue unhindered during Garbage Collection. The final objective would be to have code for an improved version of Ruby's GC with measurable gains in efficiency.
This project aims to get rid of the Node environment from the renderer process for Electron fiddle to enforce a stronger security model. Basically, with the release of Electron v12.0.0, it is now made default to set the contextIsolation as true which prevents the usage of powerful Node APIs in the renderer process. However, these changes aren’t yet reflected in fiddle’s architecture due to which it currently uses an outdated security model. Therefore, over the summer I plan to refactor Electron fiddle by migrating all the Node APIs used in renderer process to main process and later call them via IPC events.
The goal of the project is to extend the low-cost DIY robot kit for educators, including the designs, tutorials, and basic use-case scenarios. All of the parts of the modular DIY robot kit are 3D-printable, and together with basic low-cost electronics and sensors are used to assemble the robot, for a successful operation. Extensive and simple guidelines of how to print and assemble the robot are to be provided, so that non-expert staff in robotics, electronics or IoT programming, will be able to follow them successfully. In addition, the Blockly graphical UI will be extended with configurable blocks that will allow the easy though fine-grained operation of the robot. This project will be developed in collaboration with Open Technologies Alliance (GFOSS), as it will be based on the previous GSoC projects of the applicants of 2019 and 2021. It will refine the robot assembly guidelines, manual for the installation of the software stack (which will be automated as much as possible in order to support the continuous integration of software updates), and will extend the stack both in terms of the front-end of Google Blockly and the back end code in order to facilitate the robot operation and programming.
The 2010s decade marked a beginning for widespread compiler testing with the release of programs like Csmith, a C program generator that since its release has found and reported over 400 compiler bugs. However, as highlighted by a recent study, the research on compiler testing has critically neglected the front-end component of compilers, leaving unfound bugs in the type checking procedure of compilers. More specifically, this could lead to the compilers of statically-typed languages, which utilize features such as type inference, both accepting erroneous programs and rejecting correct ones. Hephaestus is a tool designed to test the compilers of three languages, namely Java, Kotlin, and Groovy. It has already successfully detected over 150 bugs in the compilers of these languages. I propose a way to extend Hephaestus for it to be able to successfully test and detect bugs in the compiler of TypeScript. This can be a great contribution to the user-base and community of TypeScript, a language that has risen in popularity and usage in the past years. Hephaestus detects bugs by: 1. generating semantically-valid programs that (a) utilize parametric polymorphism and (b) are abstract 2. generating these programs in an intermediate representation (IR), an OOP language that supports parametric polymorphism and type inference 3. using translators to convert the abstract IR program to the desired language.
Building and maintaining a website is an essential task for any business or organization. This project aims to ease the workflow of getting a website up and running by developing reusable Gatsby Components which are easily pluggable to create Gatsby websites with ease. Expected Results Design 5 new themes for Webiu(For 5 different use case) Design and Developing theme module for Webiu Implement new themes in Webiu