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.
Hyperledger Umbra is a Hyperledger Lab designed to run unmodified versions of our DLT platforms (e.g. Hyperledger Fabric, Hyperledger Iroha) under a simulated environment with software defined networking for the purposes of running experiments (e.g. scaling experiments, consensus algorithm development, etc) and security audits. Currently Hyperledger Umbra can run unmodified Hyperledger Fabric Docker images and execute a full Fabric network under simulation. Umbra is written in Python and has code for doing virtual network switches and connections. This project is to extend that code to allow for network fuzzing capabilities. The goal is to be able to introduce packet drops, packet delay, packet reordering, as well as unsolicited packets with random/known-bad data. The purpose it be able to test Hyperledger Fabric's resilience to general network "weather" and intentional attacks coming from the network.
Description: WasmEdge would like to integrate WasmEdge as an alternative runtime for Fluvio. We would like to create a compile-time feature for the [fluvio-smartengine](https://github.com/infinyon/fluvio/tree/master/crates/fluvio-smartengine) crate. Once this feature is turned on, the compiler will choose to embed WasmEdge into the binary build using the [WasmEdge Rust SDK](https://wasmedge.org/book/en/sdk/rust.html). Expected Outcome: A complete PR and a demo app that uses WasmEdge to process streaming data using a Tensorflow or Pytorch model
The mentee will work on updating the Getting Started chapter with updates from Zowe, add new and updated content to the Advanced chapter, review issues, and work on incorporating those that will add value to the course offering and be part of the release team, releasing the next version of the course
Containers are becoming more and more omnipresent, event outside their natural habitat, the cloud. It is not common today to see that container are running on small and remote devices on the EDGE. Those fleets of devices often don’t have a reliable internet connection or no internet connection at all. Running containers without being able to fetch images is a hard thing to do. So we are bringing the registry closer to the appliances where they are running. Since we are not talking about a few registries but many more, it becomes challenging to manage all the registries, this is where the satellite concept comes into place where images are distributes from a central registry. The following slides and video outline the concept and its purpose in more detail. https://youtu.be/GJ3pnfUocEw?si=F9mn4-sgN1_K6rLK&t=1529 https://docs.google.com/presentation/d/e/2PACX-1vRfcwotFzUSmfmSOmRQccBdJuFUFtIxeFE4mB3L9NgnOBM5tBnCs6uYOzyfUCIpd5xiEueMA1RYTFML/pub?start=false&loop=false&delayms=3000 Expected Outcome: The goal is to create a proof of concept, showcasing that such a solution practically works. Candidates should be able to demonstrate, how images can be replicated from a central registry to a registry on the edge location. The demonstration should contain a tunneling solution that has a Golang SDK or can be controlled from a Golang application. Part of the project is the selection and evaluation of different tunneling solutions.
Cluster API Provider AWS (CAPA) enables the creation of Kubernetes clusters in AWS with Cluster API. CAPA allows you create EKS and non-EKS based Kubernetes clusters. When creating a non-EKS cluster we must use AMIs for the nodes in the cluster. The project publishes some AMIs for non-production use. However, the process for publishing the AMIs needs improvment. Firstly we want to fully automate the publication of new AMIs when there is a new Kubernetes version available. Secondly, we need to implement the "AMI Publication Policy" for the project which will involve automated house keeping of AMIs. And thirdly we want to add back support for base operating systems that where temporarily dropped. - Expected Outcome: Automated AMI publication and deletion inline with the projects policy. Support for additional operating systems.
Harbor Satellite provides software-based config encryption and device fingerprinting for edge registries. This project hardens the security model by integrating CNCF PARSEC to enable hardware-backed zero-trust provisioning (ZTP), X.509 device certificates, and device identity. Mentees will implement a secure backend toward a hardware root of trust to enable device attestation via PARSEC's platform-agnostic API, hardware-sealed config encryption with graceful software fallback, and verifiable device identity that Ground Control can cryptographically validate. The work extends the existing SPIFFE/SPIRE authentication with hardware root-of-trust, advancing Harbor Satellite toward a fully zero-trust edge registry with hardware-attested device enrollment. Expected Outcome: - Integrate CNCF PARSEC for hardware-backed device attestation via its platform-agnostic API - Implement hardware-sealed config encryption with graceful software fallback for non-hardware environments - Enable verifiable device identity with X.509 certificates that Ground Control can cryptographically validate - Extend the existing SPIFFE/SPIRE authentication with hardware root-of-trust - Implement zero-touch provisioning (ZTP) with hardware-attested device enrollment
<p>Volcano's scheduler has no presence in the dashboard today. Three critical operator workflows are missing: </p><p><br></p><p>(1) Configuration — the entire scheduling policy (6 actions, 22 plugins, per-plugin toggles and arguments) lives in a raw Kubernetes ConfigMap edited only via `kubectl`, with no validation or UI; </p><p>(2) Observability — Volcano exposes rich Prometheus metrics (scheduling latency, preemption counts, unschedulable job/task counts) that the dashboard never queries, leaving operators dependent on a separate Grafana stack; </p><p>(3) Logs — debugging scheduling issues requires `kubectl logs` against pods in `volcano-system`; the dashboard has no log viewing capability at all. This project adds a `/scheduler` section with three tabs: a Config tab that reads and writes the `volcano-scheduler-configmap` as a structured form, a Metrics tab that proxies and visualizes the scheduler's Prometheus `/metrics` endpoint, and a Logs tab that streams live logs from any Volcano system component (`volcano-scheduler`, `volcano-controller-manager`, `volcano-webhook-manager`, `volcano-agent`) — all backed by new tRPC procedures using the existing `CoreV1Api` client in `packages/trpc/server/utils/k8s.ts`.</p><p><br></p><p>Expected Outcome:</p><p><br></p><ul><li>Config tab: draggable action pipeline editor, plugin tier editor with per-plugin `enabled` toggles and typed argument fields, live YAML diff preview, and a Save button that patches the ConfigMap via `CoreV1Api.patchNamespacedConfigMap`.</li><li>Metrics tab: stat cards for unschedulable jobs/tasks and total preemptions; line chart for e2e and per-plugin scheduling latency; bar chart for per-action latency — all from a new `getMetrics` tRPC procedure querying the scheduler's `/metrics` endpoint.</li><li>Logs tab: component selector dropdown (`scheduler`, `controller-manager`, `webhook-manager`, `agent`), `tailLines` control, keyword filter/highlight, and real-time log streaming via `CoreV1Api.readNamespacedPodLog` with a Server-Sent Events or polling transport.</li><li>Updated RBAC in `deployment/volcano-dashboard.yaml` for ConfigMap `get`/`update` and Pod logs in `volcano-system`.</li><li>Tests and user-facing documentation.</li></ul>
KubeFlex is a flexible and scalable platform for running lightweight Kubernetes control plane APIs to support specific use-cases in cloud and edge computing environments. It supports various kinds of control planes, such as: vcluster, ocm, host, etc. This project aims to extend KubeFlex to support a new type of control plane that provides the full components of a control plane in a typical Kubernetes cluster (e.g., API Server, Scheduler, Controller-Manager, etc.). This new control plane will be based on K3s and it will allow KubeFlex to support new use-cases such as multi-tenant scenarios. Expected Outcome: A new type of KubeFlex provided control plane based on k3s
Enhance Meshery's existing orchestration capabilities to include support for kro ResourceGraphDefinitions (RGDs) as first-class Meshery Models. This involves enabling Meshery to manage and orchestrate RGDs, similar to how it handles other Kubernetes resources. The project will also include generating support for ResourceGraphDefinition in Meshery's Model generator. Expected Outcome: - Meshery will be able to orchestrate and manage kro RGDs. This includes the ability to deploy, configure, and manage the lifecycle of RGDs through Meshery. The Meshery Model generator will be updated to automatically generate models for kro RGDs, simplifying their integration and management within Meshery. This will be an officially supported feature of Meshery.
The Software Package Data Exchange (SPDX) is an open source standard for communicating software bills of material information (including components, licenses, copyrights and security references). To support SPDX, an online tool has been developed which provides an easy all-in-one website to upload and parse SPDX documents for validation, comparison and conversion and search SPDX license list. This project will provide enhancements and support for the online tools including: - More automated and high-quality deployment for software updates - Removing some of the dependencies on a Python Java Bridge by moving features like license matching over to a native Python implementation - Improving performance and quality of the online tools implementation
<p>We plan to refactor and recode Community AI / ML and HPC (double precision) applications to port them to RISC-V this summer. This is a large, potentially daunting effort but we anticipate building scripts and methods to be able to substantially automate the process. Priority will be given to codes that make the most impact. Here is the initial list of 400 codes we are optimizing and compiling for RISC-V this summer: <a href="https://tinyurl.com/2aau5b9r" rel="noopener noreferrer" target="_blank" style="background-color: rgb(255, 255, 255); color: rgb(17, 85, 204);">https://tinyurl.com/2aau5b9r</a><span style="color: rgb(34, 34, 34);"> </span></p><p><br></p>
The validation of post-software deployment, conducted in two parts: Part 1) Validation of the installation manifests will be performed against the requirements (probably defined in a machine-readable format in PDF 2.0) and the software repositories; Part 2) Validation (comparison) of actual installation vs. the expected installation through log, directory, components, configuration, and software stack. Apart from ensuring that the requirements are met, this validation helps in minimizing/eliminating any deployment errors, drives test-automation, and checks for consistency to achieve efficient automation. Have a comprehensive understanding of the CNTT community, especially Reference Implementation and Reference Compliance Hands-on opportunity for software tool development, testing and verification Have a comprehensive understanding of software deployment tools (e.g. Airship) and related hardware provision interface, e.g. IPMI, Redfish
The VelaUX API server follows the Open API schema. It could auto-generate the swagger configs via CLI. When VelaUX frontend or other projects need to call these API, they must write the model code and request the API code. We can provide SDK for them to start faster. [OpenAPI generator](https://openapi-generator.tech/) could help to generate most codes. But there are still some special cases like: - Dynamic component/trait/policy/workflowsteps properties need to be generated according to CUE. - Automatically handles the user authentication process, including automatically refreshing tokens. - The API definition may be incomplete accuracy, we should check it to generate high-quality code. - Expected Outcome: The outcome of this project will be expand two more database driver for KubeVela VelaUX API server: - VelaUX APIServer TypeScript SDK - VelaUX APIServer Java SDK
Performance benchmarking distributed systems (such as DLTs) is a challenging task, comprising of multiple aspects, such as scalable workload generation, representative workload definitions, and comprehensive data analysis. Hyperledger Caliper is a general-purpose benchmarking tool with the goal of mitigating the aforementioned aspects of performance benchmarking: 1. It provides a flexible architecture to allow scalable workload generation. 2. It collects and reports results based on detailed client-observable execution traces. 3. It allows the implementation/plug-in of custom workload behaviors to meet the diverse criteria of a wide range of business scenarios. The flexible support of the aforementioned performance benchmarking aspects inherently makes the setup and configuration of a Caliper-based project cumbersome and error-prone: - The user must provide information about the system under test (SUT) in the form of a network configuration file. - The user must also specify the flow of the benchmark run in the form of a benchmark configuration file. - The runtime behavior of Caliper components can be influenced in detail through a configuration file. - As with most programming-related projects, a Caliper-based project should employ best practices to make its structure flexible and maintainable. The goal of the mentorship project is to deliver a Visual Studio Code extension that can help users perform the aforementioned tasks in an assisted and possibly automated manner.
The proposed project includes the following key activities: A systematic review of the applicability of fault-tolerant software patterns to Hyperledger Fabric chaincode as the potentially faulty software Creation of programming idioms for applying the applicable patterns to Hyperledger Fabric chaincode Prototyping "fault tolerance gadgets" (libraries) for easy application to chaincode The book "Patterns for Fault Tolerant Software" from R. Hanmer (Wiley, 2013) is a good reference of the patterns that the project will target. This is a research-focused project which is relatively light on programming. At the same time, a rather deep dive into the workings of Hyperledger Fabric is expected.
<p>Harbor CLI needs two foundational improvements this term. First, migrate the TUI from Bubbletea v1 to v2 and refactor the fragmented list/table/selection models into a unified `loadingtablelist` abstraction with consistent loading, pagination, and error states across all commands. Second, replace static credentials with an OAuth 2.0 Device Authorization Grant (RFC 8628) and OIDC login flow so users and CI/CD pipelines can authenticate against Harbor through their identity provider without long-lived secrets.</p><p><br></p><p>Expected Outcome:</p><p><br></p><ul><li>Bubbletea v2 upgrade and unified `loadingtablelist` model adopted across all list-style commands</li><li>harbor login --sso` device-code flow plus a non-interactive CI/CD path with short-lived tokens</li><li>Encrypted local token storage with automatic refresh and provider-agnostic OIDC config</li><li>Tests for TUI state transitions and a mock OIDC provider covering device flow and refresh</li><li>Updated docs covering the new TUI patterns and OIDC setup for common providers</li></ul>
Move2Kube is a command-line tool for automating creation of Infrastructure as code (IaC) artifacts. It has inbuilt support for creating IaC artifacts for replatforming to Kubernetes/OpenShift. Move2Kube has a very plugin friendly architecture, users can write custom logic in the form of "Transformers" that Move2Kube can integrate seamlessly into its transformation pipeline. So far we have support for both Starlark and container image based transformers. We would like to support writing transformers as WASM modules that Move2Kube can run. WASM provides extensive sandboxing for security, it allows writing transformers in different language stacks like Rust, C/C++, etc. other than Golang, and WASM is just as lightweight and fast as Starlark. - Expected Outcome: - Implement a feature in Move2Kube CLI to allow running WASM modules as custom transformers.
Security-sensitive workloads on embedded and server platforms require isolation primitives to support many use cases that require enforcement of confidentiality and integrity for workload against software and hardware adversaries. Providing these protection properties requires architectural support for page-based physical memory isolation managed at the machine level to be able to create isolated supervisor domains which can then host isolated S/H and (V)U, V(S) mode software. A supervisor domain can extend the trusted computing base (TCB) to host isolated VMs and/or applications. The Supervisor domains task group has defined privileged ISA extensions (Smsdid, Smmtt, Smsdia, Smsedbg etc.), to be used by machine mode to isolate physical memory, and other platform resources flexibly across supervisor domains. As specified in the RISC-V Supervisor Domains specification, per-hart controls for a supervisor domain identifier can be used to program a memory tracking table (MTT) structure that will specify if a supervisor domain is allowed to access physical memory regions (at architectural page-size granularities). The MTT will be programmed by an M-mode root-domain security manager (RDSM). The mentee will primarily focus on developing extensions to Qemu to emulate the RISC-V Supervisor Domain (Smmtt) ISA extensions, and build an priv. software prototype for the M-mode RDSM using OpenSBI to demonstrate the functionality of the emulated ISA.
We plan to have students download and modify processor core code bases to include a number of different numerical notation options. We will try a number of variations to get either multiple functions or a single optimized numerical notations.
Design and implement a new hierarchical elastic resource quota mechinism to support resource lending and borrowing to improve the cluster utilization for multi-tenants environment. - Expected Outcome: - design doc and how to use - implement a elastic resource quota mechinism to support min, max and resource sharing - implement the hierarchical resource quota - produce Blogs about these new cases.
This project utilizes Hyperledger Fabric to develop a federated learning framework with committee consensus. Hyperledger Fabric is used for storing and tracing global model update exchange. A customized committee consensus mechanism is required to reduce a load of consensus computation by selecting a random smaller subset of nodes to participate in consensus each round. In order to protect the identity of local data owners, the proposed framework will be integrated with Indy, Aries, and Ursa stack projects to offer self-sovereign identity. The mentee will work with the project mentors to gather and validate the requirements, and design the appropriate technical solution.
Plugins may have a variety of documentation that are shipped with them: readmes, licenses, guides, api documentation and more. As the various types of documentation generally resides in file formats that browsers can visualize, be it PDF or text or markdown, it would be convenient to present this documentation in the same place where the plugins run. A standard viewer & standard packaging scheme is needed so that plugin developers do not instead come up with their own way to solve the same problem, multiple times.
The Karmada Certificate Lifecycle Management project addresses user challenges in certificate management, focusing on mitigating service disruptions and security risks due to expirations. Key goals include implementing a feature for real-time monitoring of certificates with advance notification for upcoming expirations; creating a comprehensive manual for manual replacement with best practices and visuals; allowing configurable certificate validity during deployment via CLI, Helm charts, and Operator; and designing an automated certificate rotation system to streamline certificate maintenance and ensure continuous security across Karmada environments. Expected Outcome: Certificate Visibility Tool/Feature, Manual Certificate Replacement Guide, Updated Installation Tools with Customizable Certificate Validity, and Automated Certificate Rotation Solution Design or Integration Recommended Skills: Golang, Kubernetes Admin, certificate management, Helm. Upstream Issue: karmada-io/community#69
*OPEN TO US BASED STUDENTS ONLY* - Accepting applications until May 23, 2025 Alpine was primarily designed by Google to enable testing of an SDN-controlled fabric without an embedded control plane. However, Alpine can be extended to support traditional routing protocols that are supported by hardware SONiC switches. This project will help make Alpine more broadly useful as a virtual SONiC switch. Expected Outcomes: 1: Enable the routing container (FRR) in Alpine virtual switch image 2: Extend the Alpine configuration to include BGP configuration 3: Test the configuration in a mirror testbed 4: Identify any data plane gaps (and if found, update Lucius) 5: Run the SONiC test suites 6: Document running and configuring BGP in Alpine Recommended Skills: Kubernetes, Linux, Networking, Go Relationship to SONiC and Impact on Community: One of the main goals of Alpine is to provide a virtual switch with a dataplane to accelerate software delivery with fast test iterations. Integrating support for the widely-used BGP protocol in Alpine significantly broadens its applicability and increases its relevance to the SONiC community. Additional Information: https://youtu.be/55X1_2utiVg