Contribo
ProgramsOrganizationsProjectsProposal StudioResourcesOrbit AIDashboard
Login
Login
Contribov1.0

Your premium companion for discovering, matching, and tracking paid open-source mentorship programs and verified starter issues.

Product

  • Programs Directory
  • Orbit AI
  • User Dashboard

Resources

  • Guides & Resources
  • Proposal Studio

Community

  • GitHub Repository
  • Code of Conduct

Legal

  • Privacy Policy
  • Terms & Conditions
  • Cookie Policy
  • Accessibility Statement

Made with love bySubhranshu Sekhar Dash

© 2026 Contribo. Built for the global open-source community.

PlatformProjects

Explore Projects

Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.

Confused which project to choose or don't know which one you are most suitable to work on?

Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.

Match with Orbit AI
Filters Clear
4718 Projects Found
Sort by

Add Support for GraphQL Security Testing in ZAP

intermediate
OWASP Foundation•2020Varies

Ready to Apply?

Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.

Start Proposal
Proposal Status
0% ProgressNot Started
Accepted Proposals
3 SimilarView →
Proposal Guide
Tailored DocsOpen →
Checklist & Review
Readiness AuditCheck →
175h (Medium)

<p>GraphQL Schemas can be very large and testing them can be a very time-consuming, manual process. Currently, there is a lack of tools that allow developers to launch and automate attacks on GraphQL. This project hopes to fill this gap by adding the appropriate functionality to ZAP. The ultimate goal is to help developers make their applications more secure.</p> <p>This project aims to add GraphQL support to ZAP. Upon the completion of this project, ZAP will be able to understand GraphQL schemas and send queries. The user will be able to make use of existing functionalities in ZAP such as Request Editor, Fuzzer etc. to attack GraphQL endpoints. The existing Active Scan Rules will be updated to test for GraphQL weaknesses.</p>

pythonjavascriptjava+10
Student: Akshath Kothari
Code
Proposal

Improving Gazebo’s Mesh Format Support

advanced
Open Robotics•2022Varies350h (Large)

The project aims to extend Gazebo’s mesh loading support by either (A) Using an external open-source library or (B) Writing glTF2 and FBX mesh loaders consistent with the current approach. The new features implemented will be tested using unit and integration tests. In Phase 1, different mesh loading libraries will be collected and compared against each other and with the option of writing original glTF2 and FBX mesh loaders. The comparison metrics include but are not limited to maturity, complexity, integration difficulty, testing difficulty, and required time to implement. The report generated in this phase will be critical for the next phase and the future of the Gazebo’s mesh structure. In Phase 2, the selected approach will be implemented and tested using unit and integration tests with example worlds. Finally documentation will be created for future reference.

pythonc/c++ros+5
Student: Onur Berk Töre
Code
Proposal

Re-Introducing Transit Routing Support to Valhalla

intermediate
OpenStreetMap•2022Varies175h (Medium)

Valhalla is a routing engine built on OpenStreetMap data, that allows for high flexibility by providing diverse routing modes and routing filters. Initially, Valhalla received transit data from Transitland API, which converts GTFS (General Transit Feed Specification) data into a database. However, Transitland data is no longer compatible with Valhalla due to their internal updates. To bring back transit routing support to Valhalla and make it less reliant on third-party software, it can receive transit data from GTFS directly. There are downsides of simply updating the code for Transitland: (a) it is dependent on OpenstreetMap, making Valhalla heavier, while GTFS can be independent, (b) Valhalla is still vulnerable to future changes in Transitland code that may break the code. Therefore, this proposal is for an independent integration of transit data from RAW GTFS, rather than being dependent on a third-party platform.

javascriptjavaopengl+10
Student: Chris Park
Code
Proposal

Add Support for SQL Database Storage in CurveBS

intermediate
CNCF•2023Varies175h (Medium)

CurveBS currently use etcd as metadata storage but etcd has limited scalability, and the amount of metadata that can be stored is limited.So i plan to add a MySQL database as one of the storage engines and let user choose whether the metadata is stored in the kv engine or the sql engine through the configuration file. Deliverables: 1.A new SQL storage client implementation for metadata in CurveBS. 2.Configuration options to choose between kv engine and SQL engine for metadata storage. 3.Modifications to the leader election process to support the new SQL storage client. 4.Documentation on how to configure and use the new SQL storage client. 5.Tests to ensure the new SQL storage client works as expected and is compatible with existing functionality. 6.Release notes detailing the changes and improvements made to CurveBS with the addition of the new SQL storage client.

gorustkubernetes+3
Student: Bokai Jia
Code
Proposal

AiiDA: Full support of asyncio in aiida-core

intermediate
NumFOCUS•2020Varies175h (Medium)

<p><code>aiida-core</code> uses <code>plumpy</code> as its workflow backend and uses <code>circus</code> to daemonize its workflow manager process. However, the <code>plumpy</code> workflow library, and the circus process &amp; socket manager have not kept up with recent developments, forcing libraries of AiiDA ecosystem to run with outdated versions of <code>tornado</code>, and making it incompatible with the latest python web technology. In this project, I will replace <code>tornado</code> dependencies of <code>plumpy</code> and <code>aiida-core</code> by <code>asyncio</code> to enable full support of <code>asyncio</code> in <code>aiida-core</code>. If the goals and deliverables are reached before the end of the project, I will also migrate <code>circus</code>, which is also used by many other open-source projects besides AiiDA, from <code>tornado</code> to <code>asyncio</code>.</p>

pythonjavascriptr+3
Student: Jason Yu
Code
Proposal

Support for Optimization with Complex Variable in Convex.jl

advanced
The Julia Language•2016Varies350h (Large)

<p>Many problems in applied sciences are posed as convex optimization problems over the complex field such as MaxCut, Phase retrieval from sparse signals, designing a FIR filter given desired frequency response.</p> <p>The present approach is to manually convert the complex-domain problems to real-domain problems, then use domain specific languages like Convex.jl, cvx or cvxpy to get the solution of the corresponding real-domain problem and finally combine the solution from these languages to get the complex-domain solution. This process can be time-consuming and non-intuitive sometimes. The correct approach to such problems is to make our existing packages deal with complex-domain problems directly.</p> <p>The aim of the project is to add the support for solving complex-domain linear programs, second order conic programs as well as complex semidefinite programs (SDP) in Convex.jl (a Julia package for Disciplined Convex Programming).</p>

cjavascriptc+++12
Student: KrishnaKanhaiya
Code

Add Support for Reporting on the Annotation Test Suite

beginner
JSON Schema•2026Varies90h (Small)

Bowtie is a meta-validator for the JSON Schema specification, giving users a way to execute and compare how different implementations behave against the official test suite. Currently, Bowtie only supports validating instances on a simple pass/fail basis, comparing implementations solely on their correctness regarding strict schema validation. However, the JSON Schema specification also defines "Annotations"—rich metadata attached to schemas like descriptions, deprecation notices, and default values. This project primarily focuses on integrating the official Annotation Test Suite into Bowtie's architecture. This involves upgrading Bowtie's core protocol and updating numerous language-specific test harnesses to successfully extract and transmit this annotation data natively. By building a dedicated interactive dashboard within the Bowtie website, this project will allow users to easily visualize annotation compliance across languages. Ultimately, this gives users another crucial dimension to evaluate different implementations, ensuring the ecosystem correctly surfaces important specification metadata alongside standard validation results.

pythonjavascripttypescript+2
Student: Vidit_Agarwal
Code
Proposal

Add Debug Adapter Protocol Support to GJS

intermediate
GNOME Foundation•2026Varies175h (Medium)

GJS is a JavaScript runtime built on Firefox's SpiderMonkey JavaScript engine and the GNOME platform libraries. It allows the use of the GNOME platform libraries in JavaScript programs. GJS powers GNOME Shell, Maps, Characters, Sound Recorder and many other apps. The Debug Adapter Protocol (DAP) defines the abstract protocol used between a development tool (e.g. IDE or editor) and a debugger. DAP makes it possible to implement a generic debugger for a development tool that can communicate with different debuggers via Debug Adapters. DAP is already supported by the most prominent code editors and tools like VS Code, Zed, Emacs, etc… (https://microsoft.github.io/debug-adapter-protocol/implementors/tools/) Today, you can already debug applications and libraries written for/with Android, Node.js, Deno, C, C++, Rust, Python and more (https://microsoft.github.io/debug-adapter-protocol/implementors/adapters/). This proposal aims to make GJS applications and libraries like GNOME Shell, Maps, Decibels etc… debuggable by implementing a DAP adapter for GJS.

cpythonjavascript+4
Student: Angelo Verlain Shema
Code
Proposal

Linux kernel PCI project Mentorship Project

Intermediate
•Varies175h (Medium)

The Linux PCI subsystem includes core code as well as several PCI controller drivers. This project is to improve both the core code and the drivers to make them more maintainable. Applicants will work on these improvements and gain a much deeper knowledge of the PCI subsystem. Controller drivers The Linux PCI subsystem includes 50+ drivers that operate PCI or PCI Express controllers. The controller drivers do similar things, but they have to accommodate the details of a specific device. This project is to make these drivers more maintainable by making them more consistent in style and structure. This will be done by many small, independent changes. Error handling The Linux PCI subsystem logs errors reported by PCI devices, such as corrected parity errors, transactions aborted by access control violations, errors caused by defective devices, and errors caused by incorrect configuration by the kernel. This project is to log additional information to make error diagnosis easier and to fix several long-standing defects in this area. The defects range from fairly simple to quite difficult. ASPM ASPM is a power-saving feature of PCI Express. The Linux code that configures this feature is complicated and error-prone. This project is to make this code simpler and easier to maintain. This will be done by several incremental changes.

TBA
Proposal

Tail call support in the Kotlin/Wasm backend

beginner
Kotlin Foundation•2026Varies90h (Small)

WebAssembly's call stack limit is unspecified by the spec and varies across host environments. As a result, any Kotlin/Wasm program that uses mutual recursion or deep tail calls is vulnerable to stack overflow at runtime, with no way to guarantee safe execution across browsers and runtimes. Kotlin's existing tailrec modifier mitigates this for simple self-recursion by rewriting functions as loops, but it cannot handle mutual recursion or indirect calls, and requires an explicit annotation that many developers will not add. The WebAssembly Tail Call proposal (standardized and part of the Baseline target since 2024) addresses this at the instruction level with return_call and return_call_ref, which discard the current stack frame before transferring control and reduce stack consumption from O(n) to O(1) regardless of recursion structure. This project integrates that proposal into the Kotlin/Wasm compiler backend. The work covers adding the missing RETURN_CALL opcode to the Wasm IR layer, detecting tail call positions in the code generation pipeline and emitting return_call and return_call_ref in place of the current call + return two-instruction sequence, writing a test suite covering mutual recursion and virtual dispatch across multiple host environments, and benchmarking return_call against the existing loop transformation to evaluate the tradeoffs.

gradlekotlinjvm+3
Student: Ayako Hayasaka
Code
Proposal

Rails: Support Auto-Completion in Web Console

intermediate
Ruby•2016Varies175h (Medium)

<p><strong><em><a href="https://github.com/rails/web-console" target="_blank">Web Console</a></em></strong> is a debugging tool for the web apps built with Ruby on Rails. In order to debug, it provides an interactive Ruby session to the developers. The console is displayed in the current page of the browser, and its session stores context of running code of the web app. It allows us to debug the web apps interactively.</p> <p>This project aims to make a better user experience for Web Console as a whole, and the main focus is to support <strong><em>"auto-completion"</em></strong> feature, which is to help us typing commands speedy and quickly on the console.</p> <p>And also, this project is getting into ways to extend Web Console. The other goal of the project is to create <strong><em>"built-in commands"</em></strong> and its architecture, which makes Web Console more extendable, and it can open the door to yet another contributors.</p> <p>A point worthy of special mention is that the above features are working on the inner of console, and it basically does not need new things for the HTML view of Web Console.</p> <p>Details: <a href="https://github.com/sh19910711/google-summer-of-code-2016" target="_blank">https://github.com/sh19910711/google-summer-of-code-2016</a></p>

rubycjava+3
Student: Hiroyuki
Code
Proposal

Enhance flag support across Vitess Components (2025 Term 1)

Intermediate
•Varies175h (Medium)

Vitess is a distributed database system built on MySQL. Flags are widely used in Vitess for configuring components. As part of a major Vitess flag restructure, support for dynamic flag configuration was introduced. However, several Vitess components have not yet fully adopted this feature. This project involves modifying these components to fully integrate dynamic flags and performing additional flag-related refactors where necessary. Expected Outcome: Improved flag support across all Vitess components, ensuring consistent and flexible configuration management.

TBA
Proposal

Implement an ITS Backend to Support UI Frontend Operations (2025 Term 1)

Intermediate
•Varies175h (Medium)

This project focuses on building the backend functionality necessary for managing clusters in ITS. It will provide API endpoints to support the frontend’s cluster onboarding and management features. Objectives: - Develop backend APIs for ITS cluster management. - Implement validation and security features for onboarding new clusters. - Ensure high performance and scalability for handling multiple clusters. - Optimize API interactions for faster response times. Expected Outcomes: - A fully functional ITS backend with API support. - Secure and efficient cluster onboarding processes. - Scalable architecture for managing large Kubernetes deployments.

TBA
Proposal

Next-Generation Transformer Models for Symbolic Calculations of Squared Amplitudes in HEP

advanced
Machine Learning for Science (ML4SCI)•2025Varies350h (Large)

In particle physics, a cross section is a measure of the likelihood that particles will interact or scatter with one another when they collide. It is a fundamental quantity and its computation can become time intensive. This project aims to apply state-of-the-art machine learning techniques, particularly transformer-based models, for the generation of symbolic representations of the squared amplitudes in HEP. The proposed sequence-to-sequence system aims to improve upon the existing time-intensive processes of calculations of the squared amplitude . This project builds upon the previous work which includes vanilla models, and extends it further to advanced transformer models.

pythonmachine learningc+++2
Student: Ritesh Bhalerao
Code

Coordinate descheduler and Volcano to support resource defragmentation (2025 Term 1)

Intermediate
•Varies175h (Medium)

Volcano community has provided Volcano descheduler to support descheduling. Currently, load-aware rescheduling is supported. Resource fragmentation is a problem that users are more concerned about. Volcano needs to provide a resource defragmentation strategy based on the existing descheduler, and needs to ensure that the evicted pods can be rescheduled successfully, which requires the cooperation of the rescheduler and the scheduler to solve resource fragmentation and maximize resource utilization. Expected Outcome: 1. Implementing a resource defragmentation strategy based on Volcano descheduler. 2. The Volcano descheduler works in conjunction with the Volcano scheduler to ensure that evicted pods can be re-scheduled successfully.

TBA
Proposal

Volcano supports queue-level scheduling policies (2025 Term 1)

Intermediate
•Varies175h (Medium)

Volcano supports unified scheduling of online and offline workloads, provides a wealth of scheduling plugins and algorithms, and can distinguish different tenants through queue distinction. The current scheduling policy is a global configuration, and all jobs in the queue use the same scheduling policy, but in actual scenarios, different tenants may need to use different scheduling policies due to different usage scenarios. Therefore, volcano needs to support setting and using different scheduling policies at the queue level instead of using a globally unified scheduling policy. Expected Outcome: 1. A new field is added to the queue CRD, and users can set scheduling policies at the queue level. 2. Volcano scheduler implements different scheduling policies based on the queue in which the job is located.

TBA
Proposal

Implement support for C++17 structured bindings in the Clang Static Analyzer

intermediate
LLVM Compiler Infrastructure•2022Varies175h (Medium)

Even though a lot of new C++ features are supported by the static analyzer automatically by the virtue of clang AST doing all the work under the hood, the C++17 "structured binding" syntax auto [x, y] = ...; requires some extra work on the Static Analyzer side. The analyzer's transfer functions need to be taught about the new AST nodes, BindingDecl and DecompositionDecl, to work correctly in all three interpretations described by the Standard. Incomplete support for structured bindings is a common source of false positives in the uninitialized variable checker on modern C++ code, such as #42387. It is likely that the Clang CFG also needs to be updated. Such changes in the CFG may improve quality of clang warnings outside of the Static Analyzer. The expected result is that the Static Analyzer correctly models structured binding and decomposition declarations. In particular, binding variables no longer appear uninitialized to the Static Analyzer's uninitialized variable checker.

cllvmc+++3
Student: Domján Dániel
Code

Add Chaos Engineering / fault injection support (2026 Term 1)

Intermediate
•Varies175h (Medium)

This project focuses on adding fault injection support in kgateway, enabling platform operators and developers to test system resiliency under controlled failure scenarios. Fault injection allows teams to proactively identify weaknesses by introducing network latency, service errors, or resource constraints. This project will involve designing a configuration API for specifying fault injection rules, implementing support in the kgateway plugin framework, integrating with Envoy’s native fault injection capabilities, and creating documentation and examples to demonstrate practical use cases in Kubernetes environments. Expected Outcome: 1. Create a design doc outlining the proposed API for fault injection and present at a community meeting 2. Implement the fault injection plugin in kgateway, leveraging Envoy capabilities 3. Develop e2e tests to validate fault injection scenarios 4. Write developer-facing documentation with example configurations 5. Create blogs and tutorials demonstrating how to use Chaos Engineering in kgateway 6. Demo fault injection features during kgateway community meetings

TBA
Proposal

Add Multi-User and POSIX File Permission Support to Apache NuttX

intermediate
Apache Software Foundation•2026Varies175h (Medium)

This project aims to introduce a POSIX-style multi-user permission model in Apache NuttX. Currently, NuttX does not fully associate user identity with processes or enforce file access permissions based on ownership and mode bits, which limits POSIX compatibility and structured access control. The proposed approach integrates user credentials (uid, gid) into task groups, extends inode metadata to include ownership and permission bits, and enforces access control through the Virtual File System (VFS) layer. Permission checks will follow POSIX semantics and be applied consistently across filesystem operations and device nodes. In protected and kernel builds, permission enforcement will be strict due to kernel mediation. In flat builds, while strict enforcement is not possible, the system will ensure consistent permission checks along standard VFS paths and restrict updates to permission metadata through defined interfaces. The project will deliver a credential management system, extended filesystem metadata, VFS-level permission enforcement, system call interfaces such as getuid, setuid, chmod, and chown, along with testing and documentation.

pythonjavascriptjava+7
Student: abhishekmishra12
Code

GradSLAM -2: Multi-backend framework support of GradSLAM in Ivy by implementing missing PyTorch APIs

advanced
Ivy (lets-unify.ai)•2023Varies350h (Large)

Multi-backend framework support of GradSLAM in Ivy by implementing missing PyTorch APIs: Brief Implementation Plan: 1.) Developing support of a basic low-level API of GradSLAM (which is independent of other GradSLAM APIs) in Ivy frontend and backend (by implementing missing PyTorch APIs), along with its corresponding ivy tests. E.g., gradslam.geometry 2.) Follow a similar implementation strategy for other independent APIs (gradslam.config) or high-level APIs dependent on gradslam.geometry (Eg: gradslam.datasets, gradslam.structures, gradslam.slam, gradslam.odometry) 3.) Develop test script same as in official gradslam repo for all APIs. 4.) Create a tutorial (a jupyter notebook similar to official gradslam notebooks as here) for running GradSLAM using Ivy. 5.) Lastly, showcase better runtime performance of GradSLAM using JAX as the backend framework. Deliverables: -> Multi-backend framework (PyTorch, NumPy, JAX, Tensorflow) support for GradSLAM

pythoncythontensorflow+2
Student: Dhruv Rajendra Patel
Code

Mission Support System: Collaborative editing of flight path in real-time

intermediate
Python Software Foundation•2019Varies175h (Medium)

<p>Mission Support System is a flight planning software which a researcher can use to analyze predicted atmospheric data, and plan a flight-path with 3D way-points. The software in the present state allows editing by a single user per flight-path. To share this work, one has to export the work as a <code>$name.ftml</code> file and send it to other researchers for further planning. This back and forth communication not only consumes a lot of human efforts and time, but also can be frustrating when the number of researchers involved in a project is bigger, say &gt;=3.</p> <p>I propose a solution to this problem, the development of <code>Mscollab</code> which stands for "Mission Support Collaboration". <code>Mscollab</code> server would facilitate <em>real-time</em>, <em>collaborated</em> editing of flight-paths by <em>authorized</em> users. By design, it will also provide a chat facility for the users who are collaborating on the project. Its UI would be a part of <code>msui</code>, the core User Interface module of <code>mss</code>. It would additionally provide insights about temporal changes related to waypoints and the users who created them, for analytics purpose. <code>Mscollab-server</code> will be a standalone server built with Python, Flask, and python-socketio.</p>

pythonmercurialjavascript+3
Student: Shivashis Padhi
Code

Support L4 protocol filters in PacketCapture API (2025 Term 1)

Intermediate
•Varies175h (Medium)

As a Kubernetes (K8s) network plugin (CNI plugin), Antrea provides networking functions for K8s Pods and includes various troubleshooting tools for cluster administrators and application developers to diagnose networking issues. The PacketCapture feature (https://github.com/antrea-io/antrea/blob/main/docs/packetcapture-guide.md) was introduced recently and allows capturing network traffic for specific endpoints using predefined filters similar to those supported by libpcap/tcpdump. Users can initiate a packet capture through a Kubernetes Custom Resource Definition (CRD) or a CLI command. The Antrea control plane then generates and injects the corresponding BPF program, and the captured packets can be exported as a pcap file. Currently, only a limited set of filters is supported. With this project, we aim to introduce additional filters, particularly Layer 4 protocol filters, such as TCP flags for the TCP transport protocol. These new filters will enable Antrea users to target network traffic more precisely. - Expected Outcome: Extend the API definition for the PacketCapture CRD with additional filter fields, and implement the new API functionality by mapping the new fields to the corresponding BPF instructions. The new fields should also be exposed in the corresponding `antctl` CLI commands. The implementation should come with a sufficient amount of tests (both unit tests and e2e tests), ensuring that the new functionality is working as expected.

TBA
Proposal

Unicode and BiDi support for GUI && Move Detection features to the main executable

advanced
ScummVM•2020Varies350h (Large)

<p>This proposal is based on a combination of 2 project ideas &amp; 3 tasks.</p> <p>1) ScummVM GUI is currently based on char size strings, so it relies on code pages. There are a <em>lot</em> of character sets and ScummVM supports a wide variety of languages. This means due to the multitude of codepages, we're using:</p> <ul> <li>Unnecessary memory and performance</li> <li>Low compatibility between different languages</li> </ul> <p>The main idea of the of this project is to shift GUI to Common::U32 Strings, which will make our GUI:</p> <ul> <li>Unicode friendly, thus reducing the vast codepages just to one big codepage</li> <li>Better compatible</li> </ul> <p>2) With enhancing our GUI, we're also trying to add support for RTL Languages.</p> <p>3) ScummVM Project has Dynamic Plugins system in place, which allows lower-end platforms to be capable of running ScummVM. However, when we detect games - these plugins are loaded one by one and the relevant detection features are called from the individual engines. Since this is very slow, the main idea of this project is to statically link detection features into the executable so</p> <ul> <li>Games are detected without loading of a plugin</li> <li>Game detection is faster</li> <li>Other parts remain as-is, so our low-end platforms will gain performance boosts</li> </ul>

openglc++assembly+5
Student: Aryan Rawlani
Code

Invariant and Equivariant Quantum Graph Attention Transformers for HEP Analysis at the LHC

advanced
Machine Learning for Science (ML4SCI)•2023Varies350h (Large)

Machine learning algorithms are heavily relied on to understand the data generated at the European Council for Nuclear Research's (CERN) Large Hadron Collider (LHC) which produces immense amounts of data through the measurement of the products of particle collisions. Since data from these events can typically be formed into a graph structure, deep geometric methods, such as graph neural networks (GNNs), have been used as an approach to various HEP anlysis tasks. One such task is jet tagging, where jets are viewed as point clouds with distinct features and edge connections between their constituent particles. To enhance the validity and robustness of deep networks, embedded symmetries, which are present in many physically realizable datasets and fundamental physical theories, can also be discovered by the model through the use of invariant I(n) and equivariant networks E(n). However, due to the increasing size and complexity of these datasets, as well as the models which process them, an involved yet computationally inexpensive approach must be utilized. To handle an increase in the complexity of the data, I suggest the implementation of a classical attention (AT) transformer with the necessary modifications to incorporate, invariant or equivariant, and GNN layers. As the extension of classical algorithms via bit-wise processes to quantum algorithms via qubit-wise processes has been rapidly developing over the last few years, I propose the full development of general quantum invariant and equivariant graph attention transformer (QIGAT or Quantum Informer, QEGAT or Quantum Equiformer) architectures to meet the demands of requiring these machine learning algorithms to offer enhanced robustness through the adherence to fundamental physical principles while reducing their computational cost.

pythonmachine learningc+++2
Student: Roy T. Forestano
Code
Showing 865 - 888 of 4718 Projects
3536373839
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal