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.
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 (Antrea v2.2) 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. In the last iteration of the LFX mentorship program, we added support for L4 filters (TCP flags, ICMP type & code) to the PacketCapture API, to enable Antrea users to target network traffic more precisely. We would like to keep improving the PacketCapture feature with 1) IPv6 support, 2) more flexibility when providing the source and destination, 3) the ability to specify the capture point for traffic (source or destination Pod). Expected Outcome: Extend the API definition for the PacketCapture CRD, and implement the new API functionality by generating the correct BPF instructions. The antctl CLI command for PacketCapture should be updated as needed to accomodate for the API changes.
Kgateway has a large number of end-to-end (e2e) tests that functionally test the full end-to-end flow of various routing and policy features present for both supported dataplane proxies, Envoy and agentgateway. However, these tests have been implemented with a custom e2e framework which is starting to show some cracks, notably around the speed of execution and general obtuseness of the framework. This project will contain two main phases: i. Analyze the gaps of the current custom e2e framework and work with kgateway maintainers to decide whether or not it is worth migrating to an alternative solution ii. Depending on the outcome of phase 1, identify a set of e2e tests to either migrate to the new framework or improve the execution of in the current framework This project will provide exposure to a wide range of features in kgateway as well as real-world experience with ensuring the kgateway project is providing rock solid reliability for its users! Expected Outcome: 1. An approved design doc with a decision on whether to use the existing custom E2E framework vs. using an alternative approach 2. A set of e2e tests that have been migrated or modernized that will run as part of the kgateway CI pipeline 3. A well-defined pattern that can be followed for e2e tests that have not been worked on as part of this project
One of the most important features of WasmEdge is its support for non-blocking network sockets. However, the current WasmEdge API for async networking is still cumbersome. Rust developers would prefer to use a Tokio-like async / await API for such tasks. But Tokio is multi-threaded and cannot run correctly in standard single-threaded WebAssembly. Yet, it is possible to provide a single-threaded Tokio runtime. Our goal is to create a WebAssembly compatible Tokio scheduler.
KubeEdge and Sedna have already enabled edge-cloud collaborative training and collaborative inference capabilities. We aim to explore and foster collaborations with more communities to provide enhanced AI capabilities. By integrating Volcano, we aim to achieve high-performance scheduling within the cloud-edge collaborative framework, thereby pushing the boundaries of what can be achieved in distributed AI and edge computing. Expected Outcome: - Successfully deploy a training task using KubeEdge and Sedna, and provide an example in the - Integrate Volcano within Sedna's architecture to achieve high-performance scheduling of training tasks - (Optional) Successfully deploy Kubeflow within the KubeEdge architecture and complete the deployment of an training task, with a blog post documenting the process.
Karmada would like to improve the UT coverage of the code to better maintain the quality of the code and reduce the introduction of defects. Increase the UT coverage rate to 50% to 60% (currently, the UT coverage rate is [28.26%](https://app.codecov.io/gh/karmada-io/karmada) ). The entire Karmada repository is a bit large for one project, so we will split it into two projects. The current parts mainly target the `karmada-controller-manager` and `karmada-scheduler` components. Expected Outcome: - Increase the UT (Unit Test) coverage by more than 25% and add more than 4000 lines of code coverage in the following directories: pkg/controllers pkg/dependenciesdistributor pkg/descheduler pkg/detector pkg/estimator pkg/scheduler pkg/resourceinterpreter pkg/util
Kyverno 1.14 is introducing new policy types based on the upstream Kubernetes ValidatingAdmissionPolicy and MutatingAdmissionPolicy resources, as well as a new ImageVerificationPolicy based on CEL. This project will add e2e tests using Chainsaw for these new policy types.
Learning Tokens register the process of transfer and acquisition of knowledge. They track what we know and how we learned it in individual profiles that help personalize education. They measure engagement in the transfer of knowledge, support educational management, and foster Anatole France's words, nine-tenths of education is encouragement. Learning Tokens recognize, register, and reward community engagement in collective learning while certifying skills acquisition and individual competencies. In 2021, we did a global directory of DLT/Blockchain learning places. Last year, we defined artifacts for learning tokens, and now we shall code their Smart Contracts for MOOCs. Learning Objectives - Understand the tokenization of learning experiences. - Use the Inter Work Alliance Token Taxonomy Framework, IWA-TTF. - Apply IWA Token Designer to create Learning Tokens Templates. - Deploy them in Hyperledger Besu. - Understand granular learning interactions in MOOCs. - Explore simple ways to integrate Learning Tokens and MOOCs. Expected Outcome - Deploy Learning Tokens in Hyperledger Besu. - Report about connecting IWA-TTF to Hyperledger Beso - Explore alternatives to integrate Learning Tokens into MOOCs. - Report about possible alternatives to integrate Learning Tokens into MOOCs
Description: For users who want to migrate from Prometheus to Cortex, currently it is supported via a tool called [Thanosconvert](https://cortexmetrics.io/docs/blocks-storage/migrate-storage-from-thanos-and-prometheus/#when-migrating-from-prometheus). However, having this feature as part of the tool is limited in some usecase like SaaS because users usually don’t have permissions to access their storage layer directly. It would be nice to extend this feature into an API so that users can import their Prometheus TSDB compatible blocks for easier migration. Expected Outcome: An API that imports Prometheus blocks into Cortex.
Jaeger is a distributed tracing platform. Jaeger V2 is a major new version where we rebase all Jaeger backend components (agent, collector, ingester, and query) on top of the OpenTelemetry Collector. The goal is to implement a deployment mode (supported in Jaeger-v1) that uses Kafka as an intermediate buffer for spans between collector and ingester. It should use the latest version of ibm/sarama driver (related issue) and support both original Jaeger formats as well as OpenTelemetry OTLP. It may be possible to utilize the Kafka exporter/receiver from OTEL contrib. Expected Outcome: Achieve parity for Kafka-based deployment jaeger-v2 compared to jaeger-v1, including internal observability. Implement integration tests. Update documentation accordingly.
This project aims to extend the CloudNativePG operator to support declarative configuration of foreign data wrappers through its Database custom resource. PostgreSQL supports the SQL/MED (Management of External Data) specification, enabling access to external data sources through standard SQL queries. These sources—known as foreign data—are accessed via foreign data wrappers (FDWs), which are libraries that handle the connection and data exchange with the external systems. A variety of FDWs are available for PostgreSQL. Of particular interest for this project is the postgres_fdw extension, which facilitates access to other PostgreSQL instances. Expected Outcome: 1) A detailed design discussion documented in the upstream issue in CloudNativePG GitHub repository, involving mentors, maintainers, and the community. 2) A fully working pull request implementing support for declarative foreign data wrappers, complete with: a. Reconciliation logic for the Database resource controller b. Documentation c. Automated tests integrated into the CI/CD pipeline
pair.sharing.io is a mentoring / pair environment used by ii.nz that brings up clusters to co-learn and co-author via tmate+emacs and a live cluster with many features useful to cloud native development. However, while many folks find the ideas useful, it would be good to reach a wider audience by bringing up workspaces w/ VSCode as an alternative to emacs. The request is for a PoC deploying coder.com to CNCF Infrastructure (likely Packet) and bringing over some of the methods of collaboration learned by ii on pair to a wider audience.
Hyperledger Cactus is a blockchain decentralized integration tool designed to allow users to securely integrate different blockchains started by companies Fujitsu and Accenture. Cactus has pluggable architecture which makes easy to integrate various blockchain by creating plugin, currently plugins for Fabric, Besu, Quorum are implemented. Cactus allows to transfer not only assets but also data between multiple blockchains. On the other hand Iroha (version 1.x) is great with asset management, and has functionality to store data, which makes those two projects a perfect fit! In previous HL Summer Mentorship Project the integration was successfully made (link). As a result of the project commands and queries from HL Iroha were integrated, it was Iroha 1.2, but after that year multiple features and changes was added to Iroha (e.g. Healthcheck). What is more - not all nice to have features was integrated (list of missing features). It is also important to make the configuration flexible to make its possible to set up connection between two different blockchain networks (e.g. Iroha → Iroha). In short, the project's goal is to: 1. Implement missing features + tests + documentation 2. Update Iroha version to newest in the integration. 3. Make the plugin configurable 4. Create tutorial demonstrating how to set up connection between multiple networks (at least Iroha - Iroha networks)
<p>Add partial mesh support to KubeSlice using a small-scope MVP topology: **Hub-and-Spoke**. Users can define one (or two) hub clusters for a slice; the controller computes desired connections so only hub↔spoke links are established (no spoke↔spoke), and workers reconcile connectivity accordingly. Includes status reporting for convergence and failure reasons.</p><p><br></p><p>Expected Outcome: Users can create a slice with hub-and-spoke partial mesh topology and see it converge across multiple worker clusters. Topology updates (e.g., changing the hub) rewire connections safely. Slice/worker status surfaces readiness and errors for debugging.</p><p><br></p>
Ianvs is currently grappling with significant dependency management challenges. It lacks a robust system to handle updates and ensure compatibility. As Python versions, dependency libraries, and Ianvs features continuously evolve, many existing examples fail to run, resulting in a surge of inquiries in the Issues section. Moreover, new PRs are often merged without being tested against historical examples, making it difficult to guarantee the functionality of past features through manual Code Review alone. There is an urgent need for a more comprehensive CI testing framework to maintain the usability of Ianvs features as the project progresses. Additionally, the online documentation is outdated, which can be quite confusing for new users. Expected Outcome: 1. Update the Contributing Guide 2. Develop a New Quick Start Example with Comprehensive Documentation 3. Update Documentation for Other Paradigm Usage
To improve the performance of KubeEdge dashboard, we would like to introduce a BFF (Backend for Frontend) layer. It serves as a middle layer to handle the communication between the dashboard and the KubeEdge API, providing a more efficient, secure, and maintainable solution. Expected Outcome: 1. Integrate with keink 2. Error handling and retry 3. Data pre-processing (Optional)
Enhance Meshery’s APIs capability by migrating to a schema-driven approach, which will ensure consistency, validation, and easier integration. It involves versioning and defining API schemas using OpenAPI/Swagger at https://github.com/meshery/schemas and auto generating structs. You will be ensuring all Meshery APIs aligns with defined schemas and are consistent. Expected Outcome: Identifying APIs and updating them to conform these schemas. Enhance API documentation to reflect the schema-driven approach. Updating APIs to ensure they are consistent and doing validation against defined schemas.
Jaeger UI provides several views to visualize service dependencies, also known as service topology maps. However, these views are using different drawing libraries, resulting in very different look & feel and inconsistent experience. One of the views is using a `plexus` library that was purposely built as part of Jaeger UI that provides rich capabilities for displaying graphs, which may be a good candidate for the other views. - Expected Outcomes: - Remove the dependency on react-vis library (https://github.com/jaegertracing/jaeger-ui/issues/1597). - Use a single library for graph visualizations. - Provide consistent look and feel of different graph views.
<p>Jaeger is the industry-standard platform for distributed tracing. As microservice architectures grow complex, finding root causes in massive trace data becomes increasingly difficult. While Phase 1 of this initiative established a baseline AI assistant for natural language search, the system currently relies on hard-coded capabilities. This project (Phase 2\) aims to transform the Jaeger AI agent from a static chatbot into an extensible, user-programmable platform. The primary objective is to implement a "Self-Service Skills" framework, architecturally similar to "Claude Code Skills." This will allow end-users to teach the Jaeger AI new debugging workflows (e.g., "Analyze Critical Path" or "Detect N+1 Queries") by simply adding configuration files containing system prompts and logic rules, without needing to recompile the Jaeger binary. The applicant will build this extension within the Jaeger v2 (OpenTelemetry-based) architecture, utilizing **LangChainGo** to orchestrate interactions with Language Models (SLMs/LLMs). This project bridges the gap between generic AI reasoning and domain-specific observability expertise.</p><p><br></p><p>**Expected Outcome:**</p><p> - **Skills Engine Implementation:** An approach compatible with our [BYOA (bring your own agent)](https://docs.google.com/document/d/1qD0OpyRfq-JbO6MCB5gmVxsdPcpPhxz1R_pPnKDdYOg/edit?tab=t.0#heading=h.qgr5ifum0a9m) direction that dynamically discovers, validates, and loads user-defined "Skills" (prompts and tool definitions) from configuration.</p><p> - **Smart Analysis Features:** A polished implementation of Natural Language Search and Contextual Trace Explanation that intelligently leverages these loaded skills.</p><p> - **Local-First Support:** Verified compatibility with local model runners (e.g., Ollama, Llama.cpp) to ensure deterministic performance without sending data to public clouds.</p><p> - **UI Integration:** Enhancements to the Jaeger React UI to expose these AI capabilities and visualize the "reasoning steps" taken by the agent.</p><p> - **Documentation:** A complete guide for users on "How to Author Custom AI Skills for Jaeger."</p><p>- **Learning Opportunities:**</p><p> - **Agentic AI Architecture:** Learn to design stateful AI agents in Go that utilize "Tool Calling" and "Reasoning Loops" rather than simple text generation.</p><p> - **OpenTelemetry Internals:** Gain deep familiarity with the OpenTelemetry Collector architecture, as Jaeger v2 is built directly on top of it.</p><p> - **Cloud-Native Engineering:** Experience contributing to a graduated CNCF project, including navigating code reviews, writing design docs (RFDs), and adhering to open-source best practices.</p><p> - **Full-Stack Development:** Practical experience bridging a complex Go backend with a modern React frontend.</p><p><br></p>
Microcks (https://microcks.io/) is a cloud native, open source tool under CNCF for API and microservices mocking and testing. This project focuses on enhancing the reliability and quality of Microcks releases by introducing comprehensive CI deployment tests and validations using GitHub Actions. While the project already includes unit and integration tests, recent issues (ex: https://github.com/microcks/microcks/issues/1470 and https://bugs.openjdk.org/browse/JDK-8345296) with dependencies have underscored the need for end-to-end validation to ensure new integrations do not introduce bugs or regressions. Participants will develop workflows for building and deploying Microcks and running automated tests to confirm its functionality under real-world scenarios. This will help prevent edge cases and dependency-related issues affecting the Microcks community and adopters. This project improves the delivery process to ensure that Microcks' releases meet the community's expectations for quality and reliability. Expected Outcome: Workflows encompass a bunch of deployment tests: - Test container images (with docker, with podman, and on different architectures) - Testing of common docker-compose configurations - Testing of Helm chart with different setup options
pair.sharing.io is a mentoring / pair environment used by ii.nz that brings up clusters to co-learn and co-author via tmate+emacs and a live cluster with many features useful to cloud native development. However, while many folks find the ideas useful, it would be good to reach a wider audience by bringing up workspaces w/ VSCode as an alternative to emacs. The request is for a PoC deploying coder.com to CNCF Infrastructure (likely Packet) and bringing over some of the methods of collaboration learned by ii on pair to a wider audience.
Kubespray is a sig project of Kubernetes. It helps deploy a production-ready Kubernetes cluster with Ansible. The project wants maintainers to help fix bugs and enhance the new features, as shown in the following link: https://github.com/kubernetes-sigs/kubespray/issues/5432. The project will start by tackling some 'help wanted' issues related to bug fixes and documentation. This initial involvement will help the mentee understand the Kubespray implementation and pave the way for potential maintainership. - Expected Outcome: Bug fix and enhancement of the helm support for add-ons.
Provide an automatic promotion mechanism for dependent resources in karmadactl. When promoting a resource, all the resources that it depends on will be automatically promoted as well. For example, promoting the Secret that is dependent by a Deployment. - Expected Outcome: - Technical Documentation: design description and analysis - Function Implementation: support promote the dependent resources automatically - Test coverage: add test cases to cover new functions
<p>As the Koordinator scheduler grows additional plugins (NUMA, Device Sharing, Reservation, Coscheduling, ElasticQuota), the project needs a continuous, lightweight performance harness to detect regressions and validate scaling targets defined in the 2026 roadmap. This project will build a Kwok-based simulation framework that drives realistic workload mixes (LSR/LS/BE, gang, reservations, GPU sharing) at scale (target 10k-100k pods), captures throughput, queueing latency, and per-plugin profiling data, and publishes results from a scheduled GitHub Actions workflow.</p><p><br></p><p>Expected Outcome:</p><p> - Kwok-based simulation harness with reusable workload generators for the major Koordinator plugins</p><p> - Scheduled GitHub Actions workflow that runs the harness on each release branch and publishes Markdown reports</p><p> - Baseline performance metrics and regression-detection thresholds for the 2026 release line</p><p> - Profiling integration (pprof, scheduler_perf) and dashboards for triage</p><p> - Documentation for contributors on adding new scenarios</p><p><br></p>
Meshery Models are declarative representations of infrastructure and applications. Within these models, Relationships define how different Components (e.g., Kubernetes resources, Cloud services) interact and depend on each other. These relationships are crucial for visualizing, understanding, and managing complex cloud native systems. This internship focuses on significantly expanding the breadth and depth of Meshery Relationships across a wide array of technologies supported by Meshery. As Meshery continues to integrate with more cloud-native technologies (Kubernetes, public clouds, and all CNCF projects), there's a growing need to accurately model the intricate relationships between their components - vital for providing users with comprehensive insights and control over their deployments. Expected Outcome: 1. A multitude of new relationships defined both intra and inter AWS services. 2. Policy Contribution: For advanced interns, there may be opportunities to contribute to the Rego policies that evaluate and enforce these relationships.