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.
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.
<p>This project explores how AI PCs can be integrated into the KubeEdge ecosystem as a new type of edge node. With built-in heterogeneous computing capabilities such as CPUs, GPUs, and NPUs, AI PCs are becoming suitable platforms for local AI inference, privacy-sensitive applications, and low-latency intelligent services.</p><p>The mentee will connect one or more AI PCs to KubeEdge, deploy representative AI workloads, and explore resource monitoring and workload orchestration patterns for AI PC environments.</p><p>The project will summarize practical experience and provide reference documentation for using KubeEdge to manage AI PCs as edge computing infrastructure.</p><p><br></p><p>Expected Outcome:</p><p> - Connect one or more AI PCs to KubeEdge as edge nodes and verify their basic management capabilities.</p><p> - Deploy and run representative AI workloads on AI PCs through KubeEdge, such as lightweight large model inference, vision models, or multimodal services.</p><p> - Explore monitoring methods for local resources and AI-related metrics on AI PCs, such as CPU/GPU/NPU utilization, memory usage, and inference service health status.</p><p> - Summarize best practices for workload deployment, resource management, and edge-cloud collaboration for AI PCs.</p><p> - Fix issues discovered during validation, and submit PRs to KubeEdge, example repositories, or related documentation when necessary.</p><p> - Publish a blog or document to kubeedge/website introducing how to use AI PCs together with KubeEdge.</p><p> - Optional: explore an example scenario combining cloud-side collaboration and device-side inference, focusing on low-latency or privacy-sensitive tasks.</p><p><br></p>
This is a Project Management mentorship (product management for open source) for the project Inspektor Gadget (IG). Inspektor Gadget (https://github.com/cncf/mentoring/blob/main/programs/lfx-mentorship/2025/02-Jun-Aug/inspektor-gadget.io) is a powerful observability tool that enables security, monitoring and troubleshooting on Linux and Kubernetes. The framework uses a concept called “gadgets” which uses a technology called eBPF to enable us to drive valuable insights from the Linux kernel. Today, we have a very powerful gadget called Traceloop (https://inspektor-gadget.io/docs/latest/gadgets/traceloop/). However, as you can see the documentation around it is quite minimal and we need a strategy around how to bring this gadget to market in a big way. With Traceloop users can debug crashing applications as demonstrated here (https://www.youtube.com/watch?v=IoiDvzIZ3ok&list=PLnfCaIV4aZe9oQ7REBuP0PWwp-NEbFlGR&index=31). Our goal is to make community members aware of traceloop and therefore Inspektor Gadget to a) decrease time to resolution for developers debugging their applications b) drive adoption of the project . Expected Outcome: Increased awareness of the gadget Traceloop and Inspektor Gadget, and also a repeatable framework is established that can be easily scaled to other gadgets
To enhance code quality, maintainability, and developer experience, Fluid plans to migrate its unit testing framework from Testify to Ginkgo + Gomega—a more expressive and behavior-driven testing stack widely adopted in the Go ecosystem. Concurrently, we aim to significantly improve unit test (UT) coverage, raising it from the current 57% to at least 75%, thereby reducing regression risks and strengthening overall system reliability Expected Outcome: 1. Deliver comprehensive migration guidelines, coding best practices, and hands-on team training for Ginkgo + Gomega adoption. 2. Achieve a measurable increase in unit test coverage—from 57% to 75%—across core modules of the Fluid codebase.
Option 1: General Junior DevRel Mentorship This mentorship is designed for a junior Developer Relations or community-focused contributor who wants hands-on experience supporting a fast-growing open source project in the cloud native ecosystem. The mentee will work closely with the Kyverno maintainers and community to improve the overall developer and end-user experience through better documentation, tutorials, example content, and community-facing resources. The mentee will contribute upstream to Kyverno by helping create clear getting-started guides, improving existing documentation, supporting educational content such as blogs or walkthroughs, and assisting with community enablement initiatives. The mentorship focuses on foundational DevRel skills including technical communication, open source contribution workflows, user empathy, and translating complex technical concepts into approachable learning materials, while building a visible portfolio of real-world open source contributions. Option 2: Concise Version of the CEL-Focused Mentorship (1–2 Paragraphs) This mentorship offers a junior DevRel contributor the opportunity to work directly with the Kyverno community to support the adoption of Kyverno’s new CEL-based policy capabilities. The mentee will help create and refine documentation, tutorials, and example content that make it easier for new users to get started with CEL policies and for existing users to migrate from traditional policy types to CEL policie
<p>Kubescape evaluates compliance controls using OPA/Rego today, while Kubernetes has shipped native `ValidatingAdmissionPolicy` / `MutatingAdmissionPolicy` resources that use CEL expressions. The [`kubescape/cel-admission-library`](<a href="https://github.com/kubescape/cel-admission-library" rel="noopener noreferrer" target="_blank">https://github.com/kubescape/cel-admission-library</a>) project already ships a growing set of Kubescape controls as VAP resources, but Kubescape cannot evaluate them locally — so a resource passing `kubescape scan` may still fail the cluster's admission controller. This project adds a native CEL evaluation engine to Kubescape (running alongside Rego), using the same `ValidatingAdmissionPolicy` YAML format and `google/cel-go` library that Kubernetes uses internally. With the same rule expression evaluated in both places, Kubescape becomes directly comparable to — and competitive with — Kyverno for teams wanting a single policy language across CI, runtime scanning, and admission enforcement. A sample of existing Rego controls are then converted to CEL as proof-of-concept, validating the conversion pattern end-to-end.</p><p><br></p><p>Expected Outcome:</p><p><br></p><ul><li>New `CELLanguage` rule type dispatched from the existing `runOPAOnSingleRule()` extension point in `core/pkg/opaprocessor/processorhandler.go`.</li><li>runCELOnK8s()` implementation: loads `ValidatingAdmissionPolicy` YAML from `cel-admission-library`, evaluates with `google/cel-go` in a VAP-compatible environment (`object`, `params`, stubbed `request`), maps violations to `reporthandling.RuleResponse`.</li><li>Equivalence guarantee documented: for `object`-scoped rules, `kubescape scan` and the cluster admission controller produce identical results. Known gap (`authorizer`, `request.userInfo`) documented.</li><li>10–20 existing regolibrary (Rego) controls converted to CEL and contributed to `cel-admission-library` as `ValidatingAdmissionPolicy` resources, with a conversion guide for future contributors.</li><li>Unit and integration tests; end-to-end verification showing a converted control evaluated identically by Kubescape and a live VAP on a real cluster.</li></ul>
WasmEdge is a lightweight inference runtime for AI and LLM applications. The LlamaEdge project (https://github.com/LlamaEdge) has developed an OpenAI-compatible API server (https://github.com/LlamaEdge/LlamaEdge/tree/main/api-server) and a server-side RAG app (https://llamaedge.com/docs/user-guide/server-side-rag) based on WasmEdge. In this project, we aim to use the LlamaEdge components to build a new API server that incorporates real-time Internet search results into LLM answers. Expected Outcome: An OpenAI-compatible local LLM API server that uses Google Search for supplemental context
Description: Gateway API is an evolution of Kubernetes Ingress and Service networking that aims to upgrade and improve these APIs. This project is to have a docs assessment performed, to help us come with a plan for improving our documentaion. In particular, we're looking for someone to look at the content organization, the clarity of the language and concepts, and to make sure it's as readable as possible for both implementors and end users. You'll be working with the mentors and maintainers of the project, with a stretch goal being to make the changes you produce in the initial assessment.
<p>Add Active/Standby HA support for the KubeSlice Controller.</p><p> - Leader election: Only one controller cluster (the “Active” node) holds a distributed lock (e.g., a Lease) and is permitted to write updates to worker clusters or manage Slice configurations.</p><p> - Constant state sync: The Standby cluster continuously mirrors the Active cluster’s state, including relevant KubeSlice CRDs (Slices, ServiceExports, Clusters, etc.).</p><p> - Heartbeating: The Standby cluster monitors the health of the Active cluster.</p><p> - Failover: If the Active cluster fails to renew its lease, the Standby cluster detects the timeout, acquires the lock, promotes itself to Active, and worker clusters are updated to use the new Active controller.</p><p><br></p><p>Expected Outcome: Implement an Active/Standby HA architecture that makes the KubeSlice management plane resilient and disaster-recovery-ready.</p><p><br></p>
We need enhanced integration tests to prepare OpenCost for graduation and enterprise readiness. This proposed project will deliver a comprehensive suite of integration tests designed to facilitate development and contribution by third parties, while protecting the stability of OpenCost for our tens of thousands of users. These tests will validate both the quality of the data collected by OpenCost, and the correct operation of the APIs. We have recently implemented a pipeline that builds real stacks for these tests to hit - we now need to fill that framework up with great tests. See the testing strategy document @ https://github.com/opencost/opencost/blob/develop/docs/testing/AUTOMATED_TESTING.md for the current state of testing, and the infrastructure that we have put into place to support this mentorship effort. Expected Outcome: 1) A comprehensive integration test suite as defined in the linked ticket. 2) All tests run and pass automatically in pre-existing per-push integration test pipeline. 3) Approach for each integration test is documented 4) Endpoint coverage % and parameter coverage % is calculated 5) Any unfinished or follow on work is documented via issues on OpenCost
We intend to get some help around open issues in the repository and also come up with new use cases and scenarios for performance testing any kubernetes distribution. We love new perspectives and are always open to new ideas alongside what we have as tracked work in github issues. For the purpose of this mentorship program term, we have created an umbrella issue that outlines some of the critical enhancements to the project. - Expected Outcome: To knock down some of open critical issues and bring in new perspective to the project. There are no restrictions while working with issues/enhancements.
Description: Update the CoRIM profiles used for provisioning Veraison services to align with the most recent specifications. Expected Outcome: - Add support for the updated formats to the `veraison/corim` package - Add support for the updated formats to the `veraison/cocli` command line tool - Allow the provisioning of endorsement and reference values specified using the updated formats to `veraison/services`
Solang is a Solidity compiler that targets several blockchains, including Solana, Substrate and ewasm. The mentorship project consists of three goals that can provide mentees with a broad knowledge of a compiler's inner-workings. The three tasks are in different stages of the compiler. Solang’s parser analysis halts compilation entirely when there is any invalid expression or function declaration. This should be improved so that it continues parsing the Solidity contract after encountering an error, providing better diagnostics (warnings and errors) to the developer. The parser utilizes Lalrpop and the mentee would be using its error handling capabilities to implement a solution. Often the length of a dynamically allocated array is known at compile time as the allocation happens with a constant. When the length is required at some later point (e.g. for bounds checks for array indexing), the length is retrieved again. Mentees will add an optimization to make the length a compile time constant. Solang has an implementation of multiplication of integers of 256 and 128 bit. This does not have overflow detection. This requires improving the multiplication in the solang stdlib.
<p>Kuadrant's MCP Gateway is an Envoy-based gateway for Model Context Protocol (MCP) servers. It currently handles authentication and coarse-grained authorization via AuthPolicy/Authorino, but has no built-in mechanism for tool-level authorization, e.g., allowing agent A to call `add` and `subtract` on a math server while agent B can only call `subtract`. The kube-agentic-networking SIG is defining a standard AccessPolicy CRD for exactly this. MCP Gateway is well-positioned to implement it because its ext_proc already parses MCP request bodies and exposes tool metadata via headers (`x-mcp-method`, `x-mcp-toolname`, `x-mcp-servername`). This project will design how AccessPolicy maps to Kuadrant's AuthPolicy/Authorino, then build an experimental implementation covering CRD definition, a controller that translates tool-level authorization rules into Authorino configuration, identity model integration (starting with OIDC), `tools/list` response filtering so callers only see tools they're authorized to use, and CEL-based authorization expressions. The mentee will work closely with mentors on the design doc, pair on implementation decisions, and engage with both the Kuadrant and kube-agentic-networking communities.</p><p>- Expected Outcome:</p><p> - Design document covering AccessPolicy-to-AuthPolicy/Authorino mapping, body parsing strategy (ext_proc vs Envoy MCP filter), identity model choices, `tools/list` filtering, and CEL-based authorization</p><p> - AccessPolicy CRD with status conditions and CEL validation rules</p><p> - Controller that watches AccessPolicy resources and generates/updates AuthPolicy resources with authorization rules based on `x-mcp-toolname` headers</p><p> - OIDC identity source support, with consideration for ServiceAccount and SPIFFE identity types</p><p> - `tools/list` response filtering so callers only see tools they are authorized to invoke</p><p> - CEL-based authorization rule support (e.g., `request.mcp.tool_name.startsWith("read_")`)</p><p> - E2E tests covering allow/deny scenarios for tool-level access control</p><p> - Documentation guide in `docs/guides/`</p><p><br></p>
Vitess is a distributed database system built on MySQL. Developers often need to search through documentation, Slack discussions, and GitHub issues to find answers. This project will implement an AI-powered FAQ chatbot using **Retrieval-Augmented Generation**, integrating **vector search** with an **LLM** (like OpenAI, DeepSeek, GPT-4, Mistral, Llama3). The chatbot will be available via a **CLI and Slack bot** for developer support. Expected Outcome: A chatbot that provides accurate Vitess-related answers via CLI and Slack, using indexed documentation and discussions for retrieval.
Integrate a new architectural component into Meshery: a workflow engine. This project involves shifting Meshery off of bitcask and off of sqlite over to postgres using gorm (golang). Interns will familiarize with concepts of orchestration engines, including chaining workflows, and content lifecycle management.
Description: Cluster API Provider AWS (CAPA) can create and manage the lifecycle of Kubernetes clusters in AWS (with the help of Cluster API in general). For each target AWS account where a user wants to create clusters it must be prepared for usage first. This is currently done using [clusterawsadm](https://cluster-api-aws.sigs.k8s.io/topics/using-clusterawsadm-to-fulfill-prerequisites.html) which creates/updates a CloudFormation stack that in turn creates/updates IAM resources. This approach has caused issues as CloudFormation is region specific but IAM is global and users often run the tool in different regions which results in failed stacks that cannot easily be deleted. As a project we want to move away from using CloudFormation and instead use API calls (like the rest of CAPA). We also want to make the process idempotent so it doesn't matter if you run it against different regions. This account preparation is key to CAPA and with out it CAPA cannot run. Expected Outcome: A new approach to handling the prerequisites required for CAPA. We need to continue to support the cli based approach (so clusterawsadm will be updated) but we can also explore a declarative approach with an operator.
Copacetic currently doesn't support vulnerability scan reports by Wiz scanning. This mentorship project will extend Copa's support to cover this new scanning schema using a pre-existing template. Expected Outcome: The mentee will produce the following i. Design doc for Wiz Scanning ii. Wiz Plugin Integration iii. End to End integration tests
Description: Chaos Mesh is not like Chaos Engineering as a Service now: - Poor observability: the result of chaos experiments are not easy to observe and judge, the users need to check whether the Chaos effects by manual. - Chaosd(for physic node) is too simple: only supports command line operation, does not support task scheduling and life cycle management. - The costs of learning operation and maintenance are high: the maintenance of Chaos Mesh and Chaosd are not unified. - It should be a unified place to manage Chaos experiments for multiple platforms and multiple clusters, and can see the monitoring data of the experiment.
Kyverno has introduced new CEL-based policy types in the v1alpha1 API version that provide enhanced expressiveness, better performance, and native Kubernetes integration. These new policy types include ValidatingPolicy, MutatingPolicy, ImageValidatingPolicy, GeneratingPolicy, and DeletingPolicy. The goal of this project is to convert existing sample policies from the traditional Kyverno policy format to the new CEL-based format, ensuring they maintain the same functionality while leveraging the benefits of the new API. Expected Outcome: 1. Convert existing sample policies from traditional Kyverno format to new CEL-based policy types 2. Ensure functional equivalence between old and new policy formats 3. Write tests to validate the conversions and ensure reliability 4. Help users understand how to migrate from traditional policies to CEL-based format
Many advance workloads in OpenKruise are widely used in production, however the API version of the workload is still in v1alpha1. The goal is to promote the API version of mostly used and mature workload to v1beta1 and optimize the CRD fields for better clarity. Expected Outcome: 1. API definition of v1beta1 resources and the implementation for conversion webhook to convert v1alpha1 resource to v1beta1 resource 2. Unit and integration tests 3. Documentation for the usage of v1beta1 resource in the OpenKruise website
Performance research/design of RISC-V CPU designs require workloads for analysis. Workloads can be custom user applications or industry benchmarks such as SPEC, GeekBench, Dhrystone, etc. Using tools like the RVI Olympia Perf CPU Model users can pinpoint bottlenecks in CPU design, the workload, or the compilers/libraries. When the workload is small, running the workload on Olympia is not complex: trace the workload using a functional model and run that trace through Olympia; count cycles. However, if the workload is large, tracing the entire workload is not practical. Workload reduction tools, such as SimPoint, help narrow down the points of interest (POI) as well as reduce the instruction length to calculate estimated performance. The flow using SimPoint: Workload -> SimPoint analysis (using tools like QEMU) -> workload fragments -> trace generation. Each trace can be run in parallel on Olympia to gather the point performance. Post-processing tools will collate the fragments and generate an overall estimate of performance. This internship will: * Establish workloads (research) * Establish a SimPoint flow to reduce the workloads (QEMU or other instruction set simulators) * Generate STF traces using SimPoint data (QEMU or other instruction set simulators) * Create a repository of traces and their metadata, such as compiler info * Tools to run traces on Olympia and generate perf data (python, C++)
Istio is a service mesh platform used by thousands of companies to secure and manage their microservices traffic, most often in a single Kubernetes cluster. However, the ability to operate across multiple clusters is an important feature in Istio's traditional Sidecar mode, and work to support it in Istio's Ambient mode is making rapid progress. To call any feature complete, comprehensive testing is needed. Given that multicluster Istio Ambient is a new mode of operating, we will need to both adapt tests for existing features to ensure they work across multiple clusters, as well as identify multi-cluster specific scenarios we want to codify in tests. Expected Outcome: 1. Audit existing ambient integration tests for cases that do not support multi-cluster testing patterns. 2. Refactor those tests, using Istio's testing infrastructure to cover features within a multi-cluster environment. 3. Work with Istio maintainers to identify opportunities for testing new scenarios that exist only for ambient multi-cluster. 4. As documentation is written for https://istio.io, verify that the user instructions (kubectl commands, YAML snippets, etc.) actually work end-to-end. 5. Gain hands-on experience with Istio's codebase, service mesh architectures, and Kubernetes multi-clust......
Use Neo4j's ability to create graph projections, which copy a subgraph to RAM so that algorithms can be efficiently run. This opens the door to leveraging algorithms in the areas of Centrality, Community Detection, Pathfinding, Topological Link Prediction, etc. Bringing to bear advances made in Machine Learning / AI / recommendation systems, fraud detection could really help to derive meaning and comprehension for future tools. Another example is how ML + graph approaches are used to find and determine the optimal molecular structure of atoms such that desired physical properties are targeted. This approach could be applied to the problem of workload sizing and estimation for service mesh operators and would-be adopters.