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 wrongsecrets project is structured in two modes the standalone app and the CTF mode. Here we will focus on OWASP/wrongsecrets-ctf-party and how to improve it in terms of infrastructure and deployment.
Scan8 is a distributed scanning system for detecting trojans, viruses, malware, and other malicious threats embedded in files. The system will allow one to submit a list of URLs or files and get the scan results in return. Currently the user interface of this project is outdated and does not support real time data updates from the database. The aim of this project is to resolve the problem of real-time data orchestration by integrating websockets and by updating the user interface to make it more user-friendly
This project aims to create async SFTP client API's for libSSH. Currently sftp_write is the only way of uploading files over SFTP using libssh but sftp_write is a synchronous write. Providing an asynchronous api for upload will make the upload process much more faster. A high level API which will internally use the low level async API for uploads and downloads will also be created which will make uploads/downloads easier for the user and more efficient since the async API is used internally. The set of deliverables for this project will be : a low level async API for writing, a high level API for upload and download, tests for the created API's, benchmark code to analyse performance of the API's, documentation for the created API's.
Project Abstract The project proposes to add new probes to the Plugin Health Score tool. Originally started in 2022 as a part of a GSoC project, this tool determines the health score of a plugin. Probes are the heart of the tool. To extend the work started last year, I propose adding new probes to make the tool more valuable and feature-complete. Project Description Jenkins is an almost two-decade-old open-source project with over 1000 repositories. Plugins bridge the gap between Jenkins and different environments. A project as mature and large-scale as Jenkins requires active involvement from active maintainers. In general, probes serve two purposes within the context of this toolset: To collect the data to compute the score of the plugin systematically. Based on the computed score, the health of the plugin can be determined. Based on the score future contributors, maintainers, and adopters decide which plugin(s) they want to invest their time in. Project Deliverables Designing of the probes Identify the key features and functionality of the plugins. Define the metrics that would contribute to the Plugin Health Score. The more probe criteria the plugin meets, the higher the health score of the plugin. Deciding the probe’s interaction with other probes Determining how the probe would contribute to the score. Adding unit test cases for each probe and scoring implementation. If time permits, I will add integration test cases too. The final delivery would be 10 new probes to the Plugin Health Scoring System. These probes will contribute to calculating the overall health of a plugin. By the time the project ends, the tool will approximately have 24 probes in all (10 new + 14 existing probes) Proposed Implementation Plan - Build each probe, implement it, score it and write its test cases. - Define interaction of probes with each other. - Define execution order of each probe. Stretch Goals - Adding metrics probe - Writing integration test cases
Many members of Google Developers Groups are available on Meetup . So I want to develop a platform which will make developers easily to get all upcoming meets and last 7 day meets . All previous events photos will be available on the app. Maps will show the concentration of the developers globally . User can show all updates on events on the app itself.
The project aims to add new algorithms for computing the greatest common divisor (GCD) of polynomials in the sparse representation in order to improve the speed of many parts of sympy such as matrices, solvers, integration, and simplification functions. Currently, the slow speed of polynomial GCD impacts many operations in SymPy, leading to heavy performance penalties and avoiding the use of domain elements in some algorithms. By improving the speed of polynomial GCD algorithms, many parts of SymPy could become faster, and the use of GCD could become more widespread. This project could significantly enhance the overall performance and usability of SymPy.
My proposal aims to extend Pydra's worker classes to handle a wider range of systems by utilizing PSI/J, which offers a unified API for various schedulers. The objective of this project is to create a Pydra worker class capable of submitting and monitor jobs on different HPC systems, such as Theta, using PSI/J. Furthermore, I intend to use Bokeh to construct an interactive web-based dashboard that will monitor the jobs being submitted and executed by the Pydra worker. The expected outcome of this project is a Pydra worker that can use PSI/J to submit and track jobs on various HPC systems, an updated Dask worker, as well as a jobs monitoring dashboard. The proposed methodology involves designing and implementing the Pydra worker class, evaluating its functionality and performance on various systems, comparing it to existing Pydra workers, and constructing a Pydra dashboard using Bokeh to monitor the jobs. Finally, I will document the usage and installation of the Pydra worker with PSI/J, as well as the Pydra dashboard, and provide users with examples and tutorials. The project timeline includes a community bonding phase from May 4 to 28, followed by an extended coding period from May 29 to September 17.
The implementation of a pgr_ksp() function that can calculate K shortest paths for various scenarios is essential for many applications. This project aims to implement a pgr_ksp function that can handle four more different scenarios that are one-to-many, many-to-one, many-to-many, and combinations of (source, target). By implementing such a function, we can efficiently and accurately find multiple shortest paths for different scenarios and improve the performance of various applications that rely on this functionality.
The aim of this project is to implement an http4s Ember WebSocket client, a pure functional WebSocket client in Scala and integrate it with other libraries in the Typelevel ecosystem. WebSocket is a computer communication protocol that enables two-way communication between a client and a server, which is widely used in numerous applications including messaging and real-time notifications, as well as GraphQL subscriptions and executing commands in a Kubernetes Pod. An Ember implementation of the WebSocket client would benefit from the ability to cross-compile to multiple platforms (JVM, ScalaJS and Native). It would also potentially achieve high performance due to Ember being built on fs2 and thus can take advantage of highly optimized fs2 runtimes.
This project aims to improve the P5.js library by fixing the issue flag on GitHub, adding new features, developing new examples for typography documentation, and interviewing creative coders for feedback. The goal is to enhance the functionality and versatility of P5.js, and ensure that it remains a valuable tool for creative coders and graphic designers.
The overall UI design of Submitty can get a little overwhelming for the general public. Submitty is feature-rich but lacks simplicity for non-technical users navigating the application. The autograding feature of submitty is an important and mature feature allowing instructors to assign points for various checkpoints in the student-submitted code. All the autograding details are contained in a config.json file The autograding configuration is however a little difficult task for non-technical users. They have to make sure that the format is correct and that all the fields are valid, which can be overwhelming. Hence a GUI page can help more people be accustomed to designing their own configuration files. I am willing to introduce some more features in the GUI which will allow richer and greater engagement with the configuration file for the instructors. Additional features Add test cases automatically for programming/non-programming courses. Add plagiarism check of 2 types: 1) student vs student 2) student vs internet Verify if the config file created is valid or not Add a verification process for the input form text field Edit an already existing configuration file with the GUI interface. Deliverables GUI for technical and non-technical interface Plagiarism checker for all categories Additional features implementation (as discussed above) in the GUI Documentation and tutorials for all implemented features
d-SEAMS currently uses an embedded Lua interpreter to provide user interactivity in tandem with YAML inputs for selecting workflows. The project seeks to replace this interface with a Python interface. This is expected to take place in two stages: - Replacing the Lua Interpreter with Python - Binding to C++ classes and functions directly With both of these milestones completed, feature parity will be kept with the existing code while also providing much more flexibility due to the Python library formed in the second deliverable.
For my GSoC project, I wish to implement bigger full-stack features while continuing to investigate and fix bugs in the areas I'm familiar with. These areas include the settings panel, user Profile, compose box, popovers, message feed UI, and left sidebar. The issues I specifically aim to solve this summer are: - Unmute Topics within a muted stream - Add subscribe widget to user profile popover - Unsubscribed tab in stream settings - Make it possible to cancel uploads - Show empty conversation in left sidebar - Migrate manage user/bot to user profile - Special title and bug fixes for narrow titles. - copy drafts feature - Major bug fixes in user profile modal.
The proposed project aims to improve the visual appearance of canvas controls like nodes and handles, which are currently very unappealing and outdated, by introducing a customizable CSS file that will specify the styles of the controls. A default CSS file will be shipped with Inkscape, which can be overridden by a user-customized CSS file. The technical implementation would involve parsing the CSS file through libcroco and rendering the controls using cairo. The project aims to write simple and extensible code improving upon the existing hard-coded implementation.
Bustle is a powerful graphical tool for analyzing D-Bus activities. The current implementation, while still functional, cannot take advantage of the latest developments in the platform and is less accessible to potential contributors and users. However, through a GTK 4 and Rust rewrite, the tool could take advantage of more ergonomic libraries such as zbus, gtk4-rs and LibPCAP bindings and access to newer APIs such as Libadwaita widgets and the ListView API. The project will begin on continuing the basic implementation. Then carrying on to porting from GDBus to zbus, implementing the diagram, improving the loading implementation, implementing recording, and adding multiple recordings and opened files handling. For future deliverables, the following can be implemented: pair of logs opener, statistics view, command line interface, and exporting to other formats.
Existing frameworks for simulation autonomous vehicles use a gazebo simulator with ROS, which limits the development to only Python and C++ programming languages. I intend to develop an unreal engine-based simulator which the OSAVC team can use for development, taking inspiration from Airsim. This allows us to do high-fidelity simulation with the support of programming languages,i.e. Python and C++. In this project, I will add an example of simulating a custom-built CAD model and additionally controlling it using Matlab (Simulink). So that in future, the Vehicle control algorithm design and validation process will become easier. I intend to add detailed documentation of the weekly development period and examples to smoothen future development. Upon successful completion, the project will deliver a powerful simulator with realistic simulation using an unreal engine and the ability to test different vehicles like cars, UAVs and Rovers in future.
Deep learning is a subset of machine learning that involves the use of neural networks with multiple layers. Neural networks consist of multiple layers of interconnected nodes, each building upon the previous layer to refine and optimize the prediction. The main goal of the project is to accelerate as many types of layers as possible using OpenGLES and Darknet as deep learning frameworks. Accelerating the performance of deep learning models is crucial for real-time applications. GPUs are widely used to accelerate the computations in deep learning models, as they can perform many operations in parallel.OpenGLES is a widely used graphics API that provides a framework for performing computations on GPUs. By using OpenGLES to perform computations, we can leverage the parallel processing power of the GPU to accelerate the performance of deep learning models.
This project aims to deliver a module to add capture capabilities over the LDAP protocol. This module will allow the capture of LDAP traffic and logging of the captured information like authentication information. The logged information can be used by other auxiliary and post-exploit modules to perform future actions.
Markdown provides a great ability to format messages and write structured documents using plain text format. Zulip uses two different markdown processors: for the backend, it is Python-Markdown and for the frontend, it is marked.js. While the backend markdown processor is highly extensible but the current frontend markdown processor doesn’t allow the same. Moreover, it is not upgradeable because of the Zulip customisations. The goals of this project are: Refactor the frontend-markdown processor with CommonMark parser. Make the same extensible for Zulip’s custom features like @-mentions. I’ll take the reference from commonmark.js to write the CommonMark parser for our frontend-markdown processor. And to make it extensible, I'll use the upstream marked.js. In parallel to this, I’ll focus on works in the markdown area. Integrating them with the Zulip will help to increase the overall users’ experience. The list of them are: Add support for link shortener Re-enable backslash escape inline pattern Add support for online mentions Add support for importing avatar from GitHub on account creation
When working on a project in Purr Data, saving regularly is important to avoid losing any changes or progress. The auto-save feature provides an added layer of protection by automatically saving the project at set intervals, such as every 10 minutes. In case of a sudden power outage or system crash, the auto-save feature can help to recover the project files, reducing the risk of losing valuable work. This feature also helps to reduce the likelihood of accidentally closing the program or forgetting to save changes. The auto-save feature in Purr Data is a helpful tool for ensuring that project data is automatically saved and backed up regularly, providing peace of mind and added protection against data loss.
The aim of this project is to use IVY as a framework and build that into TensorLy project so that TensorLy would be usable with any of the frameworks supported by IVY. This will allow TensorLy users to switch backends via IVY’s backend handler rather than their own native backend handler. Set of deliverables are as follows: Implementing the desired functions in tensorly/backend/ivy_backend.py which will enable users to now use IVY as a framework in TensorLy. Implementing TensorLy’s abstraction layer (functionalities like Tensor Decomposition, Tensor Regression and Tucker Tensors) by using IVY as the framework. Implementing new functions into Ivy’s Functional API which exists in TensorLy’s API but currently not present in IVY’s Functional API (for example: context, index_update, ndim, sign, logsumexp, Conj). Creating demos that demonstrate how the functionalities can be used while building projects using TensorLy when IVY’s backend handler is being used. Running tests and implementing benchmarks showcasing the difference in runtime performance. Documenting the benchmark evaluations in a notebook for further research. Extending features with suggestions from the community.
While Industry Foundation Classes (IFC)—the leading international standard for exchanging building data—offers generic descriptions for smart building equipment relationships, the BrickSchema semantic structure makes the format more scalable, simplistic, and fine-tuned. This project intends to further bridge the IfcOpenShell and BrickSchema open-source communities and shared mission to evolve the common exchange of building information. By upgrading the bare-bones BrickSchema module in IfcOpenShell’s Blender addon, BlenderBIM, this project will allow users to seamlessly edit Brick entities and relationships. Features include entity editing, feed relationship editing, undo/redo support, and save-to-file utilities. This is particularly important to the continued management phase of a building’s life cycle, so this project will contribute to BlenderBIM’s coverage over building lifetimes. Furthermore, although the IFC and Brick schemas exist separately, there is continued industry interest in utilizing IFC to enhance the granularity of BrickSchema—the project aims to contribute to this endeavor.
Back in 1999, a new revision of the C standard removed several backward compatibility features. However, GCC still accepts these obsolete constructs by default. Support for these constructs is confusing to programmers and potentially affects GCC's ability to implement features from future C standards. But newer versions of compilers (for example Clang 16, expected March 2023) are planning on becoming significantly stricter with the C code they will accept or reject. This is a huge problem for the general Linux ecosystem. Even worse is that some of these failures are silent and lead to incorrect behaviour at runtime. Extra care must be taken to detect this and we must prioritize these cases because they're the most harmful. Also, in the coming years with C2x (likely C23), additional changes like removing certain depreciated prototypes will be made. All of these changes will affect Gentoo packages in the following ways: Lots of packages fail to build with these settings Sometimes packages build successfully but their ./configure scripts have mis-detected features or otherwise made the wrong conclusion about the system because they expect a test to succeed when it now fails.
This proposal outlines a continuation of the Google Summer of Code (GSoC) 2022 topic to move uninitialized memory to poison semantics. Starting with GSoC 2022 and continuing over the last year several potential solutions have been developed and shared with the community via patches and RFCs. This has helped to build further understanding of both front-end and internal LLVM limitations. Based on the latest RFC two possible semantic solutions have been identified that allow loads to migrate to poison by default and provide backward compatibility with the current load undef semantics. This is accomplished by either freezing all bits regardless of initialization state or byte-level freezing based on initialization state. By implementing both solutions real-world performance metrics and maintenance impact can be evaluated by the LLVM community. This work will increase use of poison semantics further contributing to the eventual deprecation of undef.