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.
PCI and PCIe devices may support a number of possible reset mechanisms, for example Function Level Reset (FLR) provided via Advanced Feature or PCIe capabilities, Power Management reset, bus reset, or device specific reset. Currently the PCI subsystem creates a policy prioritizing these reset methods which provides neither visibility nor control to userspace. This project would work to expose the reset methods available per device to userspace, likely via sysfs, and allow a administrative user or device owner to have some ability to manage per device reset method priorities or exclusions. This feature aims to allow greater control of a device for use cases as device assignment, where specific device or platform issues may interact poorly with a given reset method, and for which device specific quirks have not been developed.
Thanos Querier microservice is one of the core component of the Thanos system responsible for asking relevent data stores for metrics, labels, metadata, exemplars, targets, alerts and more and merging their results. One of the key challenges to Querier configuration is telling which endpoints it should talk to and what APIs it should expect. For this we proposed the Unified Endoint Discovery idea, which allows consistency and easy to use configuration across all APIs. This project is meant to continue the implementation of this proposal and make sure it works well for all the edge cases using our e2e testing framework.
Blockchain technology has a wide range of day-to-day applications ranging from electronic voting to supply chain management to financial transactions to healthcare management, energy management etc in a distributed and a decentralized environment. The enterprise blockchain provides transparency and immutability in a permissioned setting. The consensus protocols play a crucial role in establishing trustworthiness within these systems, facilitating secure and reliable operations across various sectors. The seamless integration of Byzantine Fault Tolerance (BFT) further fortifies the trustworthiness of enterprise blockchain. To achieve high security and scalability this project implements the BiniBFT consensus for Hyperledger Fabric, which was successfully innovated and designed after careful research through the CLP 2023 project, BiniBFT - An Optimized BFT on Fabric. This mentorship project highlights the pivotal role of blockchain and BiniBFT in revolutionizing the reliability and security of day-to-day operations across industries, offering a glimpse into the transformative potential of decentralized technologies in shaping the future of sustainable digital ecosystems. The project will start with the implementation of BiniBFT consensus. Both the versions of BiniBFT namely BiniBFT with Random Polling, and The Time-Weighted BiniBFT Consensus protocol will be implemented. The documentation phase will happen along with the implementation to have better clarity for users.
OpenEBS is completely Kubernetes native and is implemented using microservices. OpenEBS can be installed via kubectl or helm chart and managed via Kubernetes custom resources. Each of the OpenEBS components/services exposes Prometheus metrics. This proposal is to provide Grafana dashboards for monitoring the OpenEBS services.
LitmusChaos is an open source Chaos Engineering platform that enables teams to identify weaknesses & potential outages in infrastructures by inducing chaos tests in a controlled way. This project aims to develop new commands/features for litmusctl along with integration tests for it.
Description: Add more versatile replication filters Expected Outcome: Implement regex capability when defining relication rules, update documentation and present the functionality
[Krkn-AI](https://github.com/krkn-chaos/krkn-ai) generates rich but complex experiment outputs (JSON, CSV, YAML, graphs, and tables) capturing fitness scores, SLOs, health checks, and other metrics, which can be difficult for engineers to interpret and compare across experiments. Although recent work using LLMs to produce high-level textual summaries is helpful, text alone limits deeper exploration. This feature change proposes building an interactive analysis and visualization layer for Krkn-AI that transforms raw chaos experiment data into intuitive, explorable visual representations, enabling users to quickly understand system behavior, detect anomalies, and focus on the most impactful failure signals. - Expected Outcome: The outcome is to deliver a simple web-based GUI or generated report built from Krkn-AI result artifacts (JSON, CSV, YAML), featuring interactive visualizations for key metrics such as fitness scores, SLOs, and health checks, along with clear highlighting of important or abnormal results to guide users’ attention.
Description: Refactor the framework of karmada-scheduler to make it easier to extend and adopt more scheduling policies.
Meshery integrates with many other CNCF projects and technologies. Sustaining those integrations is only possible through automation. End-to-end testing with Playwright, GitHub Workflows, and self-documenting test reports is the means to the end of maintaining a healthy state of each of these [Meshery integrations](https://meshery.io/integrations). Expected Outcome: - Successful migration of E2E tests from Cypress to the Playwright test library within the Meshery project. - Implementation of robust and reliable test cases using Playwright to cover a wide range of Meshery's E2E scenarios. - Documentation detailing the migration process, and guidelines for future contributions to maintain test quality. - Integration of Playwright test suite into the Meshery CI/CD pipeline to ensure continuous testing and reliability of the platform.
Kyverno has the largest policy library of any policy tool for Kubernetes. Ensuring that policies work effectively across releases of both Kyverno and Kubernetes is important for users. Additionally, these tests can be leveraged in the CI processes ensuring that changes to the Kyverno codebase do not cause regressions which impact areas relevant to these policies. In this mentorship, you will learn how the `kuttl` tool works and write test cases using `kuttl` to cover all policies in the official Kyverno policy library. - Expected outcome: All policies have corresponding tests using the `kuttl` tool.
This project focuses on building a robust end-to-end testing framework for the KubeStellar UI using Playwright. The goal is to ensure seamless user experiences by automating critical workflows, enhancing test coverage, and catching UI issues early across various browsers and environments. This includes setting up Playwright from scratch, writing reusable and scalable test suites using the Page Object Model (POM), and integrating these tests into the CI/CD pipeline. Special focus will be given to WebSocket-based testing, authentication, and resource-heavy scenarios in a multi-cluster Kubernetes context. Expected Outcome: 1. End-to-end testing setup with Playwright integrated into the KubeStellar frontend 2. Comprehensive test suites for login, cluster/resource management, and binding policy workflows 3. Page Object Model-based modular test architecture 4. Mocking framework for WebSocket and REST API-based interactions 5. Visual regression testing integrated into GitHub Actions CI 6. Test coverage for key workflows 7. Cross-browser testing across Chromium, Firefox, Safari, and WebKit 8. Flaky test rate under 5% with parallel test execution and retry strategies 9. Documentation for writing, running, and debugging tests locally and in CI
Enhancements for Kyverno Policy Exceptions including support for images and conditions. - Expected Outcome: A future version of Kyverno has enhanced support for its Policy Exception resource.
Harbor is a popular and widely adopted container registry. We have developed an initial CLI (https://github.com/goharbor/harbor-cli) that we would like to extend and implement additional functionality, and common workflows that are currently only present in the Web UI. We are seeking a Golangs experienced manatee who can work on the project independently. Expected Outcome: Working Golang Harbor CLI which can be used in the CI/CD implementations that compliment the Web UI covering the typical workflows of Harbor administrators and users. Familiarity with Golang library spf13/cobra and REST/Open API. Well-documented CLI that users love to use, and with the corresponding architectural diagrams under the Harbor. Working CI/CD with GitHub actions that create multi architecture binaries and containers.
<p>PipeCD v1 introduced a plugin-based architecture enabling deployments on any platform. While the technical capabilities have evolved significantly, resources for building plugins are currently only available in Japanese. This project focuses on translating and expanding the existing [PipeCD Plugin Development Book](<a href="https://zenn.dev/warashi/books/try-and-learn-pipecd-plugin" rel="noopener noreferrer" target="_blank">https://zenn.dev/warashi/books/try-and-learn-pipecd-plugin</a>) into English and hosting it within PipeCD's docs, making plugin development accessible to the global contributor community.</p><p><br></p><p>As part of the project, [examples of pipedv1 will also be created](<a href="https://github.com/pipe-cd/pipecd/issues/6266" rel="noopener noreferrer" target="_blank">https://github.com/pipe-cd/pipecd/issues/6266</a>) practical, real-world deployment patterns built around PipeCD's new plugin architecture to help adopters get started.</p><p><br></p><p>Alongside this, the mentee will improve documentation experience for contributors and adopters, produce technical content (blogs, articles and walkthrough videos) tied to the book chapters, and grow community awareness through talks and outreach.</p><p><br></p><p>Expected Outcome: </p><p><br></p><p>English Plugin Development Book published within PipeCD docs, v1 examples completed, improved contributor and adopter onboarding experience, better docs usability and content discoverability, walkthrough videos (2–4) and blog posts tied to book chapters, and measurable community and social media growth.</p>
The project aims to integrate Graph for Understanding Artifact Composition (GUAC) with in-toto, a framework safeguarding software supply chain integrity. Graph for Understanding Artifact Composition (GUAC) aggregates software security metadata into a high fidelity graph database—normalizing entity identities and mapping standard relationships between them. This project seeks to extend in-toto's capabilities by incorporating GUAC, enabling users to query GUAC with Package URLs (purls) and retrieve pertinent attestations. Expected Outcome: Adds functionality to query GUAC, retrieve and parse relevant attestations for the specified artifact.
<p>Kubescape today has no declarative, in-cluster mechanism for posture/compliance exceptions — they only come from JSON files or the ARMO cloud API, which blocks GitOps-native workflows and air-gapped clusters. A design for a `SecurityException` / `ClusterSecurityException` CRD (group `kubescape.io/v1`) already exists and covers both vulnerability and posture exceptions in a single resource with OpenVEX-compatible fields, label/namespace/image selectors, CEL validation, and Kubernetes Events for observability. The kubevuln (vulnerability) side is being implemented by the maintainers; this project focuses on the kubescape (posture) side, the operator rescan integration, and surfacing exceptions in the Kubescape Headlamp plugin so users can view and manage them from the UI.</p><p><br></p><p>Expected Outcome:</p><p><br></p><ul><li>New `CRDExceptionsGetter` implementing `IExceptionsGetter` in kubescape, wrapping the existing getter and merging CRD posture entries (`SecurityException → armotypes.PostureExceptionPolicy`).</li><li> Match-field conversion: `resources`, `objectSelector`, and `namespaceSelector` mapped to `PortalDesignator` attributes; cloud-vs-CRD precedence per the design (cloud wins on overlap).</li><li>expiresAt` evaluated at scan time; scan-time Kubernetes Events emitted on matched SecurityException resources.</li><li> Operator `SecurityExceptionWatchHandler` watching both kinds with a debounced `CooldownQueue`, dispatching rescans on changes.</li><li>CRD manifests with CEL validation rules merged into the Helm chart.</li><li>Headlamp plugin additions: list/view `SecurityException` and `ClusterSecurityException` resources, show matched findings/events, and a guided form to create new exceptions from a failing control or CVE on a workload.</li><li>Unit + integration tests for the Go side, plugin tests for the UI, and end-to-end verification against a running cluster.</li></ul>
Volcano is a batch scheduling system for Kubernetes. This project will create a Headlamp plugin that adds first-class UI support for Volcano resources and workflows. The plugin will help users discover, inspect, and manage Volcano objects (e.g., queues, jobs, podgroups) directly inside Headlamp, making batch/HPC-style scheduling easier to operate from a Kubernetes UI. The idea is aligned with maintainer interest in a Volcano-focused Headlamp plugin. - Expected Outcome: - A working Headlamp plugin that can list and display key Volcano CRDs (e.g., Queue, Job, PodGroup) with meaningful status and relationships. Relevant Volcano related metrics displayed (on map and overview/detail pages). - Detail pages for Volcano resources with common actions (where appropriate) such as viewing events, related pods, and logs. - UX that fits Headlamp’s plugin patterns (navigation, list/detail views, and resource integration) and is packaged in a way consistent with the Headlamp plugin ecosystem. [1](https://github.com/headlamp-k8s/plugins), [2](https://headlamp.dev/docs/latest/development/plugins/) - Documentation covering installation, development workflow, and how to test against a cluster with Volcano installed. - Blog post on Kubernetes Blog about the project
Exemplars are an amazing solution that allows linking metrics to logs, traces, and more! Recently Prometheus added support to Exemplars as defined by OpenMetrics API. In Thanos with our powerful deployment flexibility, we can allow federating Exemplars up to multi-cluster, global level! During this task mentee will develop together with mentors a new gRPC API that allows to access Prometheus exemplars on Thanos level. This is a work item bringing novel and edge technology to the open-source, which will enormously help Thanos users. During this mentorship, you will learn a lot about programming in Go, distributed Systems, gRPC Observability, Prometheus, Thanos!
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. (1) Currently jaeger-v2 components are initialized without observability clients. We need to instantiate appropriate logging, tracing, and metrics clients and pass them to the components. The existing code uses internal metrics API, which needs to be bridged to OTEL metrics to minimize code changes. (2) Jaeger-v1 components can report their readiness using an internal health check API that is connected to the healthcheck endpoint on the admin port. We need to implement similar capability in Jaeger-v2. Expected Outcome: Achieve parity in observability of jaeger-v2 compared to jaeger-v1
Create a web-based voting application, with voting logic based on CIVS project, that allows use of external Oauth, such as Github, for voter authentication. Full Specification for Kubernetes Voting Application - https://docs.google.com/document/d/e/2PACX-1vQ4Z3jOpIsGZHaBy9Xa6me6IyL_rj-JZgAl-xRO-M2KacWhcRexcV3mILjwclsc9QI4ghRfic2ESFtB/pub
Extend the Kyverno CLI to cover generate policies and improve tests coverage for Kyverno. Based on the test results, the candidate has to add more unit/E2E tests.
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 AWS services. - Policy Contribution: For advanced interns, there may be opportunities to contribute to the Rego policies that evaluate and enforce these relationships.
Description: Kubewarden currently allow policy writers to use 4 different programming languages. Therefore, there are 4 SDKs to be maintained. However, they lack feature parity. In other words, some SDK have feature that have features not available in other SDKs. It's necessary to map what are the features missing between the Go and Rust SDKs and implement some of them. For that, it is necessary to read and understand what is done in the Rust SDK and implement the equivalent in the Go SDK. Expected Outcome: Map all the features missing between the Go and Rust SKDs and implement some of the missing features
This project focuses on enhancing and improving the Chaos Center code base, specifically redesigning the Chaos Workflow APIs to provide an enhanced user experience. The main objectives include refining the functionality of the Chaos Workflow and Workflow Run APIs, modularizing the chaos-workflow package into separate packages, and addressing security vulnerabilities and golangci-lint issues in the Chaos Center backend components. The project aims to deliver a more robust and secure Chaos Center platform, offering improved usability and performance for users. - Expected outcome: The outcome of this project will be improved functionality, security, and usability of the chaos workflow GraphQL APIs and chaos-center backend components through the implementation of new features, refactoring of existing code, and addressing of security vulnerabilities.