Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
This project is about improving the observability of the Thanos compactor component to help user track the current progress. Thanos compactor usually has to deal with large TSDB blocks for compaction and downsampling. When the data are large, it takes a long time to finish the compaction or downsampling. Now users have to check the bucket UI manually to see whether the work is done. It would be better to have a more fine-grained way to tell the progress of compaction and downsampling. We can have some metrics to track the work and even integrate the stats into the UI.
As a K8s network plugin (CNI plugin), Antrea provides networking functions for K8s Pods. These Pods are located on different Nodes, which can be in different availability zones, or even different geos. We would like to provide as part of Antrea (built-in capability) a tool to monitor Pod connectivity across the cluster. This tool should be able to report the average network latency between any 2 Nodes in the cluster. The latency information could then be visualized using a heatmap representation in the Antrea web UI. Expected Outcome: A new Antrea API which reports network health information and latency between K8s Nodes. If time allows, the Antrea web UI should also be extended so that latency information can be easily visualized through a heatmap.
keink (KubeEdge IN kind) is a project for running local KubeEdge clusters using Docker container "nodes", so developers can install a multi-node edge cluster in one node. Now we need to support the latest version installation in keink. - Expected Outcome: keink can install the latest version of KubeEdge and developers can quickly use keink to run kubeedge, and then develop applications on KubeEdge.
Prometheus Summaries are less but still widely used metric type. Currently, similar to classic histogram, a single summary is composed of multiple counter series. The native summary idea proposes to structure the summary type metric samples into a complex sample, similar to native histograms. As a result, bringing meaningful storage efficiency and transactionality gains. This project offers an opportunity to introduce relatively complex database change across Prometheus scraping, WAL, TSDB and querying; considering the precedense of native histograms. This project will allow mentee to learn about Prometheus, generally database internals as well as observability needs. Expected Outcome: The proposal and demo Prometheus implementation is published.
Jaeger (https://www.jaegertracing.io/) is an open-source, distributed tracing platform designed to monitor and troubleshoot microservices-based systems. We provide an easy getting started guide using docker compose, but we would also like to run a live demo that people can access directly from the Jaeger website. This project aims to create a Kubernetes deployment for the Jaeger demo, including the Jaeger backend and the UI, HotROD demo app, and the Service Performance Monitoring setup, so that users can try out the project in action and we can use this for various events to promote the project. This should be something which automatically deploys the new versions when they are released. The data in the demo environment should either be a rolling buffer or purged daily. It might even be a good idea to just recreate the environment daily which might solve both problems at once. This can be determined by the mentee. We currently have access to an Oracle Cloud environment where this can be stood up for “dev” and “prod” as managed kubernetes clusters. Expected Outcome: A working version of Jaeger demo auto-deployed on Oracle Cloud. Automatic version upgrades. Config as code. Security. Monitoring. Documentation.
Description: Jaeger (https://jaegertracing.io) is a popular platform for distributed tracing. Critical path analysis is an important tool in the latency investigations. This project aims to add support for critical path analysis to Jaeger UI. - Expected outcomes: - Implement critical path determination algorithm (maybe in the backend) - Enhance Trace Timeline view to overlay critical path on top of the trace. - Add relevant documentation to the Jaeger website - Author a blog post on Jaeger blog explaining the new feature - Stretch goals: - Add critical path visualization to other trace views (graph, table, flamechart)
Hyperledger Aries currently support only Hyperledger Indy blockchain. Verifiable credential(VC) and decentralised identifier(DID) standard & specification emerged in last few years. Trust over IP , Sovrin network, covid credential initiative are using Indy & Aries technology framework. Hyperledger Fabric general enterprise blockchain framework and most used Hyperledger project, latest Forbes Blockchain 50 report shows that 60% companies using Hyperledger Fabric for their enterprise grade blockchain. All the major cloud provides fabric as BaaS( Blockchain as a Service). Currently every identity/credential application using Indy/Aries stack to build W3C complaint VC & DID applications. There will be huge adoption and applicability of Hyperledger Fabric & Aries integration project. As per Hyperledger project governance there should be Hyperledger project interoperability to huge adoption of Hyperledger technologies. Mentee will learn: 1) Hyperledger Fabric Architecture & SDK/API 2) Hyperledger Aries Javascript framework 3) VC/DID standard and Application Expected Outcome Hyperledger Aries & fabric Wrapper or Aries will have support to use Hyperledger Fabric as Blockchain for storing credentials.
Volcano provides rich scheduling capabilities for AI workloads in the field of single cluster. In large model training scenarios, a single cluster cannot meet the computing power requirements of jobs, more and more users hope to submit jobs uniformly on multiple clusters for large model training, volcano needs to provide various scheduling capabilities, such as job management, gang scheduling, queue management, etc., and select the appropriate cluster for jobs to cope with the requirements of large model training. Expected Outcome: - Implement a basic multi-clusters scheduling framework integrated with multi-clusters scheduler like [Karmada](https://github.com/karmada-io/karmada) or other multi-cluster orchestration. - Implement gang scheduling, fair scheduling in multi-cluster. - Implement queue management in multi-cluster.
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. This is a follow-up of [previous project](https://mentorship.lfx.linuxfoundation.org/project/7426f5d7-1879-46cc-a933-880ee790d0eb), and target API is the advance operation and resilience policy. - 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
We need to do some designs for adding more tests especially for the specific scenarios of edge computing, eg: - Application migration when the network is disconnected - System stability when the network is unstable - Run large-scale cluster tests periodically
This project aims to develop a plugin system for KubeStellar that will allow users to discover, install, and manage plugins that extend KubeStellar's functionality. The plugin system will provide a centralized hub for community-contributed plugins, enhancing KubeStellar's extensibility and user experience. The implementation will include a backend API written in Go and a frontend interface built with React. Expected Outcome: 1) A fully functional plugin system integrated into KubeStellar's UI 2) Backend API for plugin management (upload, discovery, installation, updates) 3) Frontend components for browsing, searching, and installing plugins 4) Plugin versioning and compatibility checking 5) User ratings and reviews for plugins 6) Documentation for plugin developers and users
<p>KubeVela's workflow engine and config management layer have two long-standing production gaps that this mentorship will close together. First, the `request` workflow step has no native way to source HTTP headers (bearer tokens, API keys, basic auth) from Kubernetes Secrets — users wanting to call authenticated APIs are forced to hardcode credentials directly in the workflow definition, where they end up visible in `kubectl get` output and Git history. On top of that, attempts to interpolate values into the `header` map using Go templates or CUE string interpolation regularly conflict with native CUE syntax, producing un-rendered strings or silent execution failures. Second, KubeVela's Config Management today stores `ConfigTemplate`s as labeled ConfigMaps (`config-template-*` prefix) and `Config`s as labeled Secrets — there are no proper Kubernetes API types (`kubectl get configs` returns nothing meaningful), and all CUE schema and `validation.$returns` checks run client-side in the `vela` CLI. Configs created through any other path (workflow steps, VelaUX, direct `kubectl apply`) bypass validation entirely, so the same template enforces different rules depending on the entry point. The mentee will tackle both. The first deliverable extends the HTTP provider in `kubevela/workflow` with a `headerFromSecret` field that resolves values from Kubernetes Secrets natively in Go (mirroring how the same provider already handles Secrets for `tlsConfig`), and exposes it as a first-class CUE parameter — bypassing the templating layer entirely. The second introduces a proper Kubernetes API group, `config.oam.dev/v1alpha1`, with `ConfigTemplate` and `Config` CRDs, event-driven controllers built on controller-runtime, and validating admission webhooks that move CUE validation server-side. Sensitive properties never live in the CRD — they sit in a separate Secret referenced via `propertiesFrom.secretRef`. A dual-read controller preserves full backward compatibility: legacy ConfigMap templates, old CLI versions, and existing Secret-based configs continue to work without disruption. Together, the two deliverables harden KubeVela's HTTP integration surface and modernize its configuration layer into a Kubernetes-native, GitOps-friendly API.</p><p><br></p><p>Expected Outcome:</p><p> - New `HeaderFromSecret` field on the `Request` struct in `pkg/providers/http/http.go` (kubevela/workflow), with native Secret resolution inside `runHTTP()` mirroring the existing `getTransport()` TLS pattern</p><p> - Updated `request.cue` definition in kubevela/kubevela exposing `headerFromSecret` as a parameter, with namespace defaulting to `context.namespace`</p><p> - New `config.oam.dev/v1alpha1` API group with `ConfigTemplate` and `Config` CRDs, DeepCopy, and scheme registration</p><p> - `ConfigTemplateReconciler` that parses CUE templates and writes the generated OpenAPI schema to `status.schema`</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: - A multitude of new relationships defined both intra and inter GCP services. - Policy Contribution: For advanced interns, there may be opportunities to contribute to the Rego policies that evaluate and enforce these relationships.
The RISC-V Mentorship Program enables one or more 12-week internship-style projects per session, funded by RISC-V, to match mentors/project leaders together with mentees/interns. Mentees are guided through a series of milestones by one or more project mentors, with whom the mentees meet on a weekly basis. With this mentorship, the mentee will be performing formal verification of the SweRV-EL2 core (https://github.com/chipsalliance/Cores-SweRV-EL2) using riscv-formal (https://github.com/SymbioticEDA/riscv-formal). RISC-V formal has been applied for formal verification of picorv32 and Vexriscv cores that implement the RV32IMC Instruction set. Since the SweRV EL2 implements RV32IMC, it would be a good idea to formally verify it using RISC-V Formal. This would enable rapid adoption of the SweRV-EL2 core. Deliverables for this project include an open-source formal testbench for the SweRV-EL2 core that verifies the core correctly implements the RV32IMC instruction set. Additional formal checks can also be added.
After upgrading the OpenEBS control plane, user/admin is required to upgrade the Jiva Volumes by launching a Kubernetes Job. This enhancement request is to improve the existing OpenEBS CLI jiva sub-commands that will help users with required information to create Kubernetes Jobs, as well as to add a sub-command that will automatically launch the upgrade jobs.
Description: Using interactive environments(like killercoda) for users to get started quickly. Expected Outcome: Implement 2 Karmada examples in killercoda, including a CLI installation example and script installation example, both contains installation and deploying workload to multi-clusters steps.
Integrate a new architectural component into Meshery: a workflow engine, using Temporal. This project involves shifting Meshery off of sqlite over to postgres using gorm (golang). Interns will familiarize with concepts of orchestration engines, including chaining workflows, and content lifecycle management.
Current design of the Knative website (https://knative.dev) does not look modern and contains inconsistent style. Knative UX working group has prepared a new design for the website. We would like to get this design implemented on the website. We also want to ensure with this implementation that the figures in the website include alt text descriptions. We are not looking for full WCAG compliance though. Also, currently the website is not really responsive and doesn’t look good on a mobile device. The group also has a design for the mobile. Finally we have many diagrams on the website that have different styles. We would like to have these diagrams more cohesive. This part is an extended goal though. Expected Outcome: New design applied to website; website is made responsive; diagrams look and feel more cohesive.
<p>This project focuses on validating KubeEdge as an edge-native infrastructure for lightweight large language model inference. As more AI services move from the cloud to edge devices, lightweight LLMs provide a practical way to reduce latency, protect data privacy, and support local intelligence under limited resources.</p><p>The mentee will deploy one or more lightweight LLMs on KubeEdge edge nodes and evaluate the complete workflow, including model packaging, workload scheduling, service exposure, lifecycle management, and performance measurement.</p><p>The project is expected to produce a practical reference for running generative AI workloads on edge nodes managed by KubeEdge.</p><p><br></p><p>Expected Outcome:</p><p> - Successfully deploy and run one or more small-parameter large models on KubeEdge edge nodes, and complete end-to-end inference workflow validation.</p><p> - Explore deployment methods and best practices for managing lightweight model services based on KubeEdge.</p><p> - Evaluate basic performance on edge devices, including startup time, memory usage, inference latency, and runtime stability.</p><p> - Fix issues discovered during validation, and submit PRs to KubeEdge or related example repositories when necessary.</p><p> - Publish a blog or document to kubeedge/website introducing how to deploy and run small-parameter large models based on KubeEdge.</p><p> - Optional: complete example validation with a lightweight scenario, such as local Q&A, document summarization, or lightweight multimodal inference.</p><p><br></p>
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.
thena now has components such as router, ModelServing controller, etc. However, it lacks necessary e2e test coverage. - Expected Outcome: - 1.E2E Test of modelserving Router and modelBooster. - 2.Write an E2E test for each of the three on GitHub workflows. Run them separately. - 3.Developer Guide of How to run and expend E2E test
Kyverno is working towards support of ValidatingAdmissionPolicy (CEL admission). Extend this support for other items such as CLI, reporting, and auto-generating ValidatingAdmissionPolicies from Kyverno policies. - Expected outcome: Extended support and integration with ValidatingAdmissionPolicies
Currently Antrea can be installed using a K8s YAML manifest or through the provided Helm chart. We believe there is value in providing a 3rd installation method, using the "antctl" CLI. The CLI installation / upgrade method would have the following advantages: a) more user-friendly, with support for command-line options to customize the installation, b) ability to run sanity checks on the K8s cluster before comitting to the installation, c) when upgrading, the CLI will ensure that Antrea components are upgraded in the optimal order, to minimize workload disruption. Expected Outcome: A new command for antctl, the Antrea CLI, which will provide support for installation and upgrade.
With your collaboration, we aim to analyze findings and meaningful information (quantitative and qualitative data) and run a series of ideation rounds. We will create user personas, empathy maps, and other UX deliverables that will be the foundation to lay out a set of solutions to improve the current way to search, navigate and find relevant information on the Landscape. - Expected Outcome: Creation user personas, empathy maps, and other UX deliverables.