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.
This proposal aims to enhance CVE-BIN-TOOL by integrating support for different VEX triage functionality. The problem at hand is the limited scope of CVE-BIN-TOOL, which currently lacks extended VEX integration, hindering its ability to provide a holistic risk assessment. The solution involves refactoring the current workflow, implementing support for various VEX formats (such as CSAF, OpenVex, and CycloneDX), establishing linkages between SBOMs and VEX formats, and updating documentation and tests for usability. Through this project, we aim to provide cybersecurity professionals with a comprehensive tool for identifying and mitigating vulnerabilities effectively. The deliverables include a refined workflow, support for multiple VEX formats, documented linkage mechanisms, and updated documentation and tests.
This proposal aims to develop an automated node graph layout restructuring system for the Graphite node network. Nodes are organized within a tree-like structure while adhering to specific constraints and design principles. This makes it possible to create a node positioning system that organizes the graph in collaboration with user actions. Through a set of deliverables including layout algorithms, cost quantification, heuristic-based reorganization, and a decision-making processes, this solution will enhance node graph clarity to users and adhere to design principles, all while still allowing flexibility in node positioning within the network.
This project is aimed at advancing the capabilities of heterogeneous computing environments in Julia through Dagger.jl. We propose to implement a series of enhancements for significantly improving task execution efficiency, data transfer speed and robustness of distributed parallel computing systems. We place special emphasis on further development of streaming data processing for distributed heterogeneous systems with Dagger.jl. Heterogeneous computing environments leverage a combination of resources - such as CPUs, GPUs, DPUs - and face challenges in optimizing task execution and data streaming. Data transfer mechanisms are often inefficient or may lack robustness against system slowdowns or failures. The project will be supporting ongoing radio astronomy and ionospheric RADAR work at MIT and its Haystack Observatory — bringing about real-world impact in the short-term.
This proposal aims to describe how to add inlay hints support to the Haskell language server. Inlay hints can provide a more fancy, intuitive, and convenient ui view of the current state of the code, such as the fixity of operators, the type of bound symbols in `let`, the type of holes, etc. Some basic work already exists in the current HLS that makes it feasible to implement inlay hints, such as the basic type library already in use: https://github.com/haskell/lsp; and the hls plugin system. Prior to submitting this proposal, I had already started working on trying to make some implementation work, and had made some progress. I submitted a draft pull request (https://github.com/haskell/haskell-language-server/pull/4131) to hls's github repository, which lists some todo's, but it should be noted that there is more to this proposal than just the pr's, and any suitable information that can be presented with the help of inlay hints will be included in the work. Since the ability to configure inlay hints is already in the todo, even if inlay hints that are too informative are implemented, they will not be a bother to the user: the user has the ability to configure the information that inlay hints will display. In the body of the proposal, I detailed the timeline and details for implementing the idea. I'll continue to build on the progress of this pull request, gradually implementing more inlay hints usages and important configuration capabilities.
Okular, the cross-platform universal document viewer developed by KDE supports PDFs with forms. These forms often use Javascript to make forms more convenient for its users. However, as of today, the support for Javascript within Okular is lacking. A lot of pre-defined javascript form functions are either partially implemented or not implemented. This often breaks form functionality for the users. Also at present, many essential objects and functionalities outlined in the PDF Javascript API Reference specification are either only partially implemented or completely absent. This leads to a lot of bug reports regarding broken form support for Okular. This project aims to resolve this, by improving the Javascript support for PDF forms. For this, the pre-defined Acrobat methods shall be implemented and newer JS objects shall either be added or improved upon during the course of this project. Deliverables : 1. Pre-Defined Acrobat method implementations. i. AFNumber_Keystroke ii. AFSpecial_Keystroke iii. AFMerge_Change iv. AFTime_Keystroke v. AFDate_Format vi. AFDate_Keystroke vii. AFPercent_Format viii. AFPercent_Keystroke 2. Expand the implementation for the event object. 3. Expand the implementation for the field object. 4. Implement the global javascript object. 5. Implement the submit and reset actions.
Extend the "Chart" functionality on the Study View Page by supporting additional types of charts such as line charts and area charts. Support chart toggle functionality to allow users to select different types of charts for the particular data set. Implement "group chart" functionality to improve UX for chart analysis.
Space Visualizations for Liquid Galaxy is an application that showcases the Mars 2020 NASA mission and some of the most famous Earth orbits. The application uses the Liquid Galaxy platform to provide immersive space exploration experiences. In the Mars mission section, users can interactively learn about the mission by visualizing 3D models, technical data, and the path of the Perseverance rover and Ingenuity drone. Users can see Mars from the perspective of the Perseverance rover with more than 220000 photos available. The photos can also be displayed on all Liquid Galaxy screens, providing a very immersive experience. In the Earth orbit section, a list of orbits can be displayed in both the application and, with a realistic representation, on Liquid Galaxy Google Earth. Users can interact with these orbits and learn more about them.
This project focuses on standardization of the libcupsfilters code into C. As the libcupsfilters library is principally written in regular C and not C++ due to the issues which would occur due to use of C++. But libcupsfilters still depend on one library which is written in C++, QPDF, a library for manipulation of PDF files. We need to replace this dependency on C++, with another library PDFio. This is a PDF handling and manipulation library, as QPDF is, but it is fully written in standard, regular C, not in C++.
In this project, we will provide an open source based example deployment of a trained/tested/functional workload, which would address market verticals by implementing edge-core-cloud infrastructure. It would be a brainstorm to an end-to-end example approach and potentially port portions of found examples to another technology aspect. We will use Rancher (Kubernetes-as-a-service) to manage cluster, deploy microservices and fully DevOps Integration.
The project aims to enhance the Django Debug Toolbar (DDT) by adding comprehensive asynchronous support to make it fully compatible with Django Channels and asynchronous Django applications running under the ASGI specification. This can be proceeded by adding separate storage mechanism for panels and async aware middleware
This proposal aims to improve the capability of markdown exporter package inorder to cover multicompartment model, and also to support generation of p.d.f, h.t.m.l , latex file types not only this but also to follow a standard template generation using jinja2 templates , Inorder to streamline the process for user to select the output according to their requirements based on their template selection. apart from this handling the python environment inorder to extend support for morphologies , moreover allowing users to use their own templates from their file system, which enables them to make the best use of brian2tools package.
The ‘Open Source Community Sustainability’ project is about simulating open-source community interactions to encourage conditions leading to sustainable practice. I propose to do this by creating a framework with an agent-based model powered by Large Language Models (LLMs). This project has been worked on in OREL for the past 2 years, and a variety of models and tools have been created towards it, utilizing reinforcement learning, active inference and attraction-repulsion based approaches to build several agent-based models. Thus, this framework will represent open-source communities as a system composed of interconnected components (agents), mapping the intricacies of community engagement and collaboration as well as focusing on emergent properties and overall system behaviour. This project is important to the open-source ecosystem because as the demand for open-source software continues to grow, so do the challenges associated with community management, collaboration, and sustainability. Thus, providing a framework to understand how individuals collectively contribute to community growth and success can help derive insights into effective community management, collaboration strategies, and sustainability factors.
The project focuses on streamlining the debugging and development process for code intended for offloading to devices like GPUs. It proposes a method to execute offloaded code in a separate CPU process on the same host, simplifying debugging and avoiding the need for a GPU setup. The work involves creating a host-ISA offloaded code generation mode and a libgomp plug-in to interface with the libgomp offloading machinery, managing the new process for the offloaded code. This approach can simplify debugging issues related to memory mapping or multi-device offloading, and potentially simulate GPU-like parallelism using CPU threads for a broader range of debugging scenarios.
Deploying AWS Lambda functions using AWS SAM (Serverless Application Model) requires manual creation of a deployment descriptor, posing challenges for Swift developers due to learning a new DSL and adopting new tools like SAM CLI and Docker. To simplify this process, the community proposed a Swift-based DSL and a Swift package plugin. However, these solutions rely heavily on accurately mimicking the evolving SAM AWS deployment descriptor. To address this, this project proposes to automatically generate the AWSLambdaDeploymentDescriptor library based on the SAM template definition. That generated code is used by the Swift-based DSL to create SAM YAML templates required to deploy Lambda functions and their dependencies to AWS.
MetaCall offers binaries and a CLI that can be downloaded and installed easily through metacall/install. This provides a CLI for executing code and a REPL for interacting with some MetaCall functionalities. Apart from this, there are two separate projects that are part of the full development lifecycle: metacall/deploy, which is a CLI for deploying into the FaaS and metacall/faas, which is a reimplementation of the FaaS for local development. These two tools are right now completely separated from the CLI, although they are necessary for the full development lifecycle. The idea of this project is to unify them into the same project. For example, having metacall deploy ... for executing the deploy CLI or metacall faas for executing the FaaS locally. With these options, all tools will be unified into one, and end users will install all of them once the CLI is installed.
The project aims to enhance the f951 compiler's `DO CONCURRENT` construct by implementing locality clauses, supporting reduction operation and developing parallelization strategy include OpenMP-based parallelization.
This project aims to build a conversational assistant designed around OpenROAD to answer user queries. The goal is to build a complete pipeline that includes dataset updates, model training, and model deployment. The pipeline's architecture will be able to adapt to evolving datasets, with metrics to regularly keep track of the model’s performance.
Researchers have tremendous difficulty keeping up with the exponential growth of scientific literature--where groundbreaking findings and complex concepts are emerging at a rapid pace--hindering their ability to stay on top of the latest insights in their field. There is a dire need for AI utilizing retrieval-augmented generation (RAG) models that can efficiently process and summarize these vast volumes of scientific papers, helping human researchers focus their efforts on the most promising areas of investigation. The "AI Scholar" project aims to develop an advanced AI system utilizing state-of-the-art natural language processing, information retrieval, and machine learning techniques, including a RAG model, to efficiently process, summarize, and analyze vast volumes of academic papers. This innovative system will enable personalized recommendations, automated literature analysis, idea generation, and guidance for researchers navigating the complex landscape of statistics, data science, and potentially other scientific domains, thereby accelerating the pace of scientific discovery and innovation.
This project will focus on implementing a number of high priority features for Zulip web app focused around left sidebar and stream settings. This includes addition of new features, improving user experience and working across different areas if needed.
OGC SensorThings API is an international standard to eliminate vendor lock-ins in IoT systems and to create an open geospatial ecosystem by defining a standard data model and describe how to retrieve the ingested data. However, the standard by itself does not specify a way to physically store the data. Most of the current server implementations are all based on Postgres databases using the PostGIS extension. Unfortunately, relational databases are not a great choice to store large volumes of data, which is often the case with IoT applications. As a result, retrieving large volumes of data from any of the open source SensorThings API servers is painfully slow. Modern data lakehouse standards and cloud-native geospatial file formats offer a scalable, modular, cost-effective and a much faster way to store and work with large volumes of geospatial data on the web. Specifically, Apache Iceberg is an open table format for organizing data lakes in object stores and ensuring ACID guarantees. GeoParquet is a cloud-native geospatial file encoding, based on a columnar data storage format for tabular data that significantly compresses the data and improves querying efficiency. A cloud native SensorThings API extension using Apache Iceberg could significantly enhance the standard's ability to ingest and aggregate large heterogeneous streams of sensor data. The proposal hence puts forth a design architecture for any SensorThings API server to use Iceberg to store and retrieve sensor data in a more efficient manner reducing memory overhead and network latencies when retrieving such data over the web. Eventually, as GeoParquet gets merged into Iceberg, the implementation will support a much faster alternative to existing SensorThings API implementations for handling sensor data at scale.
The ENIGMA project has its own language, EDL (ENIGMA Development Language), along with a dedicated parser. Two years ago, a significant effort was made to completely rewrite the EDL parser, resulting in a recursive descent parser that handles most aspects of the language, though some features remain incomplete. This year, the focus is on further developing the parser to address these unfinished features, implementing the pretty printer to translate the generated AST (abstract syntax tree) to C++ code, replacing the old parser calls with the new ones, and implementing visitor classes such as the declaration gathering visitor and the syntax checker.
The proposal is to improve QEMU's emulation capabilities on FreeBSD to support and fix issues related to architectures such as ARM, RISC-V, and Aarch64. To achieve this, the goal would be to implement syscalls and other functions from the blitz branch that is being maintained by the mentor. The project will involve finding the necessary calls and adding them to the master branch as a series of patches. My main task would be to upstream changes from the blitz branch after verifying and testing the code, as the end goal is to support more architectures for emulation purposes.
This project aims to enhance Simplenews newsletter module for Drupal 10, enhancing functionalities from existing modules while prioritizing usability, scalability, and compatibility. The project focuses on improving the Simplenews module by addressing specific issues, such as fixing the incorrect subscriber language for anonymous users , resolving bugs for users with blank email addresses, and adding a setting to disable per-user rendering. Key features include efficient subscriber management, streamlined newsletter creation, engagement tracking, and seamless integration with email service providers. Mentored by @azizos, the 8-week project emphasizes meticulous planning, task assignment, and time management, starting with frontend development. With a strong background in Drupal development and project management, the proposer aims to deliver a comprehensive, user-friendly enhancement for Drupal 10.
The Music Blocks v4 project is a complete overhaul of the original Music Blocks project, which was derived from the Turtle Blocks project. The existing implementation, which started in 2015 using native Vanilla JavaScript, lacks modern front-end tooling and ecosystem standards, leading to difficulties in maintenance and subpar performance. The v4 project uses improved application architecture, modern tools (such as Vite, ESLint, Prettier, Docker, Jest, Cypress, etc.), better languages (TypeScript and Sass), and libraries (React for UI rendering). This will significantly enhance the overall developer and user experience, maintainability, and performance. The proposal focuses on implementing one of the main features of Music Blocks, the "Masonry Framework" (previously code-builder/project-builder), which is currently missing in the new version (v4). The is a graphical blocks manager module used to create Music Blocks programs, including interactive blocks like Start, Rhythm, Note, Pitch, Instrument, and many more. These blocks can be dragged, dropped, and clicked to perform actions or open context menus. By implementing the Masonry feature end-to-end, users will be able to create different musical patterns seamlessly. This will bring the v4 project on par with the capabilities of the old version (v3) and provide a more accessible, efficient, and user-friendly application for users to create music through an interactive web application.