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 project aims to improve the quantum circuit visualization capabilities of QuTiP-QIP by introducing a new framework for circuit rendering that doesn't rely on external dependencies. Presently, circuit visualization relies on LaTeX and ImageMagick, which can be problematic for users. This solution plans to create two rendering modules: one utilizing matplotlib for visually appealing and precise quantum circuit diagrams, and another ASCII text-based rendering. The matplotlib renderer will also support generating circuit visualizations within IPython environments like Jupyter Notebook, while the text-based renderer will cater to command-line interactions. Apart from the rendering modules a Circuit Renderer Selector will also be included in the project deliverables, enabling users to easily choose their preferred rendering method among LaTeX, Matplotlib, or Text-Based options. These tools will enable users to visualize quantum circuits more efficiently and effectively, making it easier to work with QuTiP.
The Scala ecosystem thrives on information accessibility, and Scaladex stands as a pivotal resource in this domain. However, the current scope of Scaladex's artifact pages does not fully exploit the wealth of metadata available in Maven pom files. This project aims to enhance Scaladex by extracting and presenting additional information from pom files, enriching the user experience, and empowering developers with deeper insights into Scala artifacts.
The Jenkins ecosystem, characterized by its monolithic core and modular plugin system, offers users remarkable flexibility. However, it encounters difficulties in propagating large-scale changes across its multitude of plugins. These challenges encompass technology migration, API deprecation, dependency updates, and more. Given the extensive number of plugins—over 1900—in Jenkins, updating each one to accommodate these changes proves to be a laborious and manual process, resulting in many plugins falling behind. To address this issue, this project leverages OpenRewrite to develop a versatile tool capable of transforming code. This initiative empowers developers to efficiently address technical debt within their repositories.
The Eventyay-Video platform is a robust tool for hosting virtual events. This GSoC project aims to enhance its functionality, improve deployment efficiency, and introduce features for a more interactive and accessible user experience. The upgrades will make the platform more adaptable, especially for events needing multilingual support and enhanced streaming capabilities. Key responsibilities for this project include: 1. Implementing a Live Interpretation System: Introduce real-time multilingual audio support, allowing participants to select and listen to different language streams during presentations and discussions. 2. Setting Up Auto-Deployment with Docker: Automate the deployment process using Docker to streamline workflows, allowing developers and contributors to efficiently deploy, test, and maintain the platform. 3. Updating Dependencies: Ensure the platform is secure and up-to-date by updating all outdated dependencies to their latest versions, addressing compatibility issues, and maintaining smooth operation with the latest software standards. 4. Improving the User Interface: Enhance the UI to make the platform more intuitive, offering a seamless experience for participants, organizers, and moderators. 5. Improving YouTube Integration and Adding More Controls: Upgrade the platform's YouTube integration, allowing for better control over embedded videos, including advanced playback controls and interaction features. By the end of the project, Eventyay-Video will be significantly more powerful and versatile, providing a highly functional platform for virtual events with real-time interpretation, streamlined deployment, and enhanced streaming features.
This project utilizes open AIS data to create a real-time visualization tool on Google Earth and Liquid Galaxy rigs. The goal is to provide users with detailed information about maritime activities along the Norwegian coastline, including vessel positions, routes, and other relevant data. The application will allow users to customize their viewing experience through a controller flutter app, with features like vessel selection, detailed vessel information display, historical route playback, future route prediction and collision risk management using machine learning, region-specific vessel tracking, and filter options based on vessel type and country.
Chrome is going to remove MV2 deprecated extensions by June 2024 . The purpose of this project is to successfully migrate towards Manifest V3 while retaining all the functionalities as well as achieving cross browser compatibility.
The Vala compiler and the Vala API generator currently have no support for the latest GObject Introspection attributes. This proposal plans to add this support to both the Vala compiler and the Vala API generator. It also seeks to add GI-Docgen format support to Valadoc. I plan to make the Vala compiler support these attributes by making Vala.GIRWriter insert these attributes in the generation of GIR files. Similarly, Vala API generator can support these attributes if we make Vala.GirParser parse them from GIR files and add them to the Vala AST. Finally, the plan is to make libvaladoc parse comments in the GI-Docgen format. Upon the completion of this project, the Vala compiler and Vala API generator will be able to use these latest attributes in the generation and parsing of GIR files. It will also result in Valadoc being able to support the GI-Docgen documentation format so that it can be used with Vala GIR files. In addition, Valadoc documentation pages will have a modernized appearance and they will be able to render working GI-Docgen links.
Currently GIMP uses the complicated GtkTreeView from GTK3. My job is to create a new GimpTreeView widget which moves away from GtkTreeView as it will be deprecated in GTK4 port, and which is much simpler to implement than GtkTreeView. With inspiration from GTK4's GtkColumnView, I will create a versatile widget which is much cleaner in implementation.
Clad is a Clang library which allows automatic differentiation (AD) of functions. Clang provides the necessary facilities for code transformation. The AD library can differentiate non-trivial functions, to find a partial derivative for trivial cases. Newer C++ versions provide the constexpr and consteval specifiers, but currently Clad does not abide by them. The aim of this proposal is to ensure that Clad generated derivative functions follow the semantics of the original functions. Adding support will likely require a new interface for CladFunction's and changes in clad::differentiate and clad::gradient.
VisionGuard is a desktop application designed for AI-enabled PCs to mitigate eye strain through real-time gaze tracking. The app builds on OpenVINO's gaze estimation demo to provide customizable break reminders and detailed screen time analytics. With support for multiple devices (CPU, GPU, NPU), VisionGuard ensures efficient, private, and low-power local processing without the need for an internet connection. The user-friendly interface includes system tray integration, leveraging OpenVINO, Qt, and OpenCV for seamless functionality. All data remains securely on your device, ensuring privacy while promoting healthier screen habits.
Djed is a formally verified crypto-backed stablecoin protocol. Its different ver- sions have already been deployed on various chains such as Ergo Blockchain, Milkomeda-C1 (an EVM SideChain of Cardano), and Zephyr, a privacy-oriented cryptographic coin. In this proposal, our primary focus will be on Djed’s im- plementation on EVM-based blockchain networks. We aim to enhance existing Djed implementations and extend deployment to other EVM-based chains. Ad- ditionally, we will explore ideas to enhance the frontend of existing deployments by optimizing the CI/CD pipeline using github workflows and UI/UX improve- ments.
The current FreeBSD system call creation script was implemented to streamline the introduction of system calls into the FreeBSD kernel. It’s a monolithic script, converted from awk to Lua, and has kept much of the procedural-oriented awk code. It does not take full advantage of modern features of Lua (object-oriented design) and is difficult to extend. The goal is to strip the current script into an easily extendable interface. It will utilize classes to give extensible methods to objects, mainly utilizing the facade and command design patterns, to give a more "bite-sized" interface to the previously procedural code. This will allow easier maintenance of the Lua tables and procedures, and a better platform to add more. Lua modules will provide better namespacing of globals, dynamic generation of output files, and more modules with different tasks may be easily added. After refactoring, the previous functionality of the original script can be achieved simply by calling the necessary modules. The benefit to FreeBSD is further streamlining in the creation of system calls, a more maintainable interface, and a strong foundation to build upon in the development of future system call creation tools. It will further demystify the process of system call creation and allow others to more easily contribute. Deliverables are (1) system call creation will work as before; (2) the monolithic script will be refactored into core, modules, and classes; (3) a system call creation library that is easily extensible; and (4) well-documented with conventions used.
My project idea is to implement an undo/redo functionality in a Flutter-Paintroid. This feature aims to enhance the user experience by allowing users to easily correct mistakes and experiment with their creations without the fear of making irreversible changes. The implementation will rely on the command pattern, where each user action, such as drawing a line, erasing, or adding shapes, is encapsulated within a command object. These commands will be managed by a command manager, which handles the undo and redo operations efficiently.
Git has many existing end-to-end tests which are written in shell script. However, to unit test some of the internal libraries/functionality, we use helper binaries whose output is consumed by these shell scripts to compare the result obtained from those binaries with the expected result. This translation is costly due to many reasons. Therefore, this project aims port some of these existing unit tests to the newly merged TAP implementation of a unit testing framework, which allows for tests to be written solely in C, and does not require the shell script translation.
This project aims to significantly enhance the notification system by implementing a series of improvements: consolidating multiple notifications into single emails to avoid flooding users' inboxes, enabling global preferences to allow users to disable or enable notifications across all organizations easily, and introducing a REST API for administrators to manage user settings efficiently. Additionally, a dedicated, user-friendly interface will be developed for managing notification preferences, complemented by adding a direct link in email footers for managing preferences and an unsubscribe option. These features collectively aim to streamline the management of notifications, reduce inbox clutter, and elevate the overall user experience.
Matchings and perfect matchings have received considerable attention in graph theory as well as in other related domains (such as, but not limited to, algorithms and optimization). There still remain many open problems — such as Barnette’s conjecture, Berge-Fulkerson conjecture, and so on — due to which it continues to remain an active area of research. For problems concerning perfect matchings, it is well-known that it suffices to solve them for matching covered graphs (that is, those connected graphs wherein each edge belongs to some perfect matching). The objective of this project is to implement efficient algorithms pertaining to the canonical partition, tight cut decomposition, dependency relations, (optimal) ear decomposition, brick and brace generation methods and related concepts in the theory of matching covered graphs, and to make all of these available freely to students, educators as well as researchers all across the world.
The goal of this project is to provide a real-time monitoring dashboard on the IHR website to easily monitor how a prefix propagates on the Internet. This tool will get a prefix (or list of prefixes or an ASN) from a user, also the user can select a list of RIS collectors and the maximum number of hops from the monitored prefix to display. Then the user pushes a 'play' button. The tool will connect to RIS Live with the corresponding parameters and display the AS paths received.
Most scientific and engineering applications heavily depend on floating point arithmetic. Floating point numbers only approximate the real numbers, which can lead to accumulation of errors and ultimately to unusable results. Current state of the art of floating point arithmetic optimization is done in Rust (egg) or Racket (Herbie). This is not very accessible for the actual target group of scientists & engineers who are used to program in high-level languages such as Python, MATLAB and Julia. Additionally, it requires manual labour (rewriting symbolic expressions, then optimizing them, and finally translating the resulting code back to the original language) due to the necessity of interfaces to interoperate between different systems written in different languages. We propose to take advantage of Julia's homoiconicity and powerful existing symbolic-numeric ecosystem to implement an automatic floating point expression optimizer in Julia, acting on any expression that supports TermInterface.jl, such as Symbolics.jl expressions as well as native Julia code. The project will include a package that implements the floating point expression optimization apporach (OptiFloat.jl). To achieve this Metatheory.jl will be fully integrated with Symbolics.jl, enabling e-graph based optimization of any symbolic expression (not just numerical). Additionally we will finalize the release of Metatheory.jl v3.0, identify existing Julia packages that may suffer from numerical error propagation, and perform a thorough comparison of automatically optimized expressions vs. original vs. external system including the time required to obtain them.
This project aims to support the detection and reporting of SPDX License Expressions. Currently, FOSSology uses regular expressions, full-text match, and fuzzy match to scan licenses, stores all types of license expressions as a list of licenses, and wrongly classifies them as conjunctive licenses or disjunctive licenses. It also stores license exceptions as licenses and does not differentiate exceptions from licenses. In the project, I will be working on scanning license expressions using regular expressions with Ojo, storing them in the database, creating UI components to see license expressions in the file clearing page, and finally updating reports to export the expressions in the correct format.
Currently Krita from KDE doesn’t have a Pixel Perfect option, the name for an algorithm that visually smoothes out pixel art curves. The idea here is that whenever the user ends up with a L-shape with this option, it would smartly remove corner pixels so that the overall curvature looks less blocky and more clean. By introducing this functionality, Krita users looking to utilize the pixel art functionalities alongside with Krita’s features can have an easier time controlling the precision and aesthetics of their pixel art creations.
The Electron documentation currently doesn't feature API history for its functions, classes, etc. I aim to implement the missing API history in a similar fashion to the Node.js documentation: by allowing the use of a simple but powerful YAML schema in the API documentation Markdown files and displaying it nicely on the Electron documentation website.
The Prometheus Operator plays a pivotal role in deploying, configuring, and managing Prometheus instances within Kubernetes clusters. Despite its significance, fully leveraging its functionalities remains challenging due to outdated and ambiguous documentation. This proposal aims to address this issue by identifying the current shortcomings in the documentation and development processes. It will outline strategies to revamp the documentation, ensuring clarity and relevance. Additionally, emphasis will be placed on establishing sustainable practices to prevent future documentation difficulties. By implementing these improvements, the goal is to elevate the Prometheus Operator documentation to a level where users can easily engage with the project. This initiative seeks to highlight the importance of Prometheus Operator while fostering accessibility and usability for all users.
Rustfmt, the de facto standard tool for formatting Rust code, has been reported that it occasionally fails to format silently. One of the major causes is that the internal formatting mechanism loses the context when issues occur during formatting. While rustfmt heavily relies on the Rewrite trait to format various AST structures, the rewrite method, the only method that consists of the Rewrite trait, returns Option. This makes it hard to track how and why formatting failed. To improve handling of silent failures and allow rustfmt to retry formatting under more contexts, this project aims to refactor the Rewrite trait so that errors occurring in formatting can be propagated.
This project aims at enhancing the current DRAKVUF Sandbox by: - extracting common TTPs and displaying them in accordance with the MITTRE ATT&CK framework. - Identifying common malware families and extracting their configuration. - Extracting host and network based indicators of compromise (IoCs) using virtual machine introspection (VMI). - Enhancing the analytic pipeline by means of integrating it with FLARE's capa and floss tools. - Generating STIX objects for the newly extracted information. - Refactoring the Flask backend to be able to serve the output of the added tools. - Extending the React frontend to display all the newly-added information. This will be done by adding new modules to the sandbox' post processing script, and serving the output to the Flask backend by means of MinIO. Then, the Flask backend will be updated accordingly to provide endpoints for fetching the newly-added information. Finally, the React frontend will be updated to fetch data from the new version of the backend, and then displaying the information in a concise and informative manner for the malware analysts and threat researchers.