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.
<p>Resource fragmentation in a cluster has two common sources: (1) intra-node imbalance between resource types — e.g. a node reaches 90% CPU allocation while memory allocation stays at 50%, leaving memory stranded; and (2) scale-down that evicts the "wrong" pods, leaving many nodes partially filled instead of fully drained. Koordinator currently has no dedicated strategy for either case. This project will add two coordinated capabilities: a descheduler plugin that detects nodes whose per-resource allocation imbalance (measured via standard deviation, consistent with the kube-scheduler `NodeResourcesBalancedAllocation` plugin) exceeds a configurable threshold and evicts pods whose removal most reduces the std; and a scale-down binpack strategy that, when upper-layer controllers scale workloads down, picks pod victims so that remaining allocations are concentrated on fewer nodes (inspired by Volcano's scale-down binpack). Both capabilities will reuse Koordinator's `ReservationFirst` eviction mode to preserve workload stability, and cooperate with the scheduler's `NodeResourcesBalancedAllocation` so rebalanced pods land on better-balanced nodes.</p><p><br></p><p>Expected Outcome:</p><p> - New descheduler plugin that detects intra-node resource-type imbalance above a configurable threshold using standard deviation across CPU/memory (and optionally other resources)</p><p> - Pod eviction prioritization that picks pods maximally reducing the per-node std after eviction</p><p> - Scale-down binpack strategy exposed to upper-layer controllers so scale-down victims are chosen to reduce cluster-level fragmentation</p><p> - Integration with the `ReservationFirst` eviction mode to preserve workload stability</p><p> - Coordination with the scheduler `NodeResourcesBalancedAllocation` plugin so evicted pods land on better-balanced nodes</p><p> - Unit tests, e2e tests, and a documented benchmark showing reduced resource fragmentation for both rescheduling and scale-down scenarios</p><p> - User-facing documentation and example descheduler / scale-down configurations</p><p><br></p>
The reference documentation for the Kubernetes API is generated at the end of every release cycle. Due to difficulties with the tools used to do this, and the state of that tool's documentation, intimate knowledge of how the tool works is required and generating the reference docs can only reliably be performed by one specific person. Currently, it is possible for the generator to fail at multiple points in the process. Many of these failures are entirely undocumented and without any error handling. Expected Outcome: A measurable improvement in the usability of the reference docs generator, through some combination of an improvement in documentation, error handling, and code refactoring. It should be possible for other contributors to follow instructions and reliably produce the reference API docs, with solutions to any remaining common failure modes thoroughly documented.
Now KubeVela's VelaUX uses two kinds of Database to store metadata: Kubernetes ConfigMap and MongoDB. As more users are expecting using different kinds of database. We proposing to expanding multiple database drivers for the VelaUX API server. - Expected Outcome: The outcome of this project will be expand two more database driver for KubeVela VelaUX API server:
Observability is very important for each application, we want to monitor more things of Chaos Mesh components, enrich the metrics for both logic patterns and performance data. We want to let users could watch the status of Chaos Mesh on grafana dashboard, and developers could using time-series metrics for debugging and profiling.
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. Currently we have rudimentary support for resources such as ArgoCD, Tekton, etc. We need to enhance this to make it useful. Example: https://github.com/konveyor/move2kube/issues/930 - Expected Outcome: - More comprehensive support for advanced K8s resources so as to support real world use cases.
Meshery's highly dynamic infrastructure configuration capabilities require real-time evaluation of complex policies. Policies of various types and with a high number of parameters need to be evaluted client-side. With policies expressed in Rego, the goal of this project is to incorporate use of the https://github.com/open-policy-agent/golang-opa-wasm project into Meshery UI. - Expected outcome: a powerful real-time multi-user collaboration experience.
Thanos Ruler is a critical component in Thanos that is responsible for the alert evaluation and recording rules. However, a few extensive rules can create a significant amount of resulting time-series, limiting the scalability of Thanos Rule, as it uses a single embedded TSDB. Recording/Alerting Rules are a substantial piece of monitoring infrastructure, so we want to ensure users can operate Rulers and scale them in an easy way. There is no way to scale rule evaluation and storage today except functionally sharding rules onto multiple instances of the Thanos Ruler component. Luckily, we have already solved scaling storage of time-series across various processes using Thanos Receiver. To scale rule evaluations and storage, during this mentorship, you will have a chance to implement the proposal that allows the Thanos rule component to have a stateless mode, storing results of queries by sending them to a Thanos receive hash-ring instead of storing them locally. You will learn about Go, Time-series databases, distributed system design, Prometheus, and of course Thanos.
Propogation Policy page on the web dashboard will help to perform different operations for Propagation policies in karmada, Settings page will help the user to modify the dashboard according to their needs.
Description: Robot accounts should be allowed to access the full Harbor API (more of a UI thing) Expected Outcome: Implement a way to configure and fully documented with examples usecase how to setup Harbor Robot accounts with full or managed access to Harbor
AgentCube is a proposed subproject in the Volcano community. It is designed to extend Volcano's capabilities to natively support and manage AI Agent workloads. At present, agentCube lacks authentication and authorisation capabilities. Therefore, it is hoped that basic authentication and authorisation capabilities for request identities can be established. - Expected Outcome: - 1. The ability to authenticate and authorise requests. Such as Token, JWT, OAuth, Cookie... - 2. Documentation containing the proposal and user guide - 3. Unit test and E2E test for the feature
Testing is an important task to ensure project stability, security, and other aspects. Since KubeEdge is built on top of native Kubernetes, in this project, we aim to integrate Kubernetes end-to-end (E2E) test cases into KubeEdge's CI. This integration will help ensure the native compatibility and usability of KubeEdge. Additionally, we also aim to improve the unit tests and increase the coverage of integration tests for KubeEdge. Expected Outcome: Improve KubeEdge test coverage scenarios
<p>OpenEverest is an open-source cloud-native database platform that helps developers deploy and manage PostgreSQL, MySQL, MongoDB, and other databases on Kubernetes. In V2 it uses a plugin architecture where database providers define their UI through declarative YAML schemas (UISchema in Provider CRD). Currently, plugin developers have no integrated tool for developing and testing these schemas — the only way to see the rendered result is to deploy a full Provider CRD into a running Kubernetes cluster, making the development cycle slow and error-prone. This project aims to build a Plugin Developer Playground — a page inside OpenEverest where plugin developers can write UISchema YAML, see the rendered form in real time, validate the schema structure, inspect the post-processed API payload, and save/share schemas, all without deploying to a cluster. The mentee must solve the CSP compatibility problem by either choosing a CSP-compliant code editor or proposing an isolation architecture (e.g., sandboxed iframe) that keeps the main application's strict security posture intact.</p><p><br></p><p>Expected Outcome:</p><p><br></p><ul><li>Split-pane YAML editor with syntax highlighting and live form preview using the existing `UIGenerator` component</li><li>Real-time schema validation: YAML parsing errors and structural validation against the `TopologyUISchemas` type, with inline error markers in the editor</li><li>Live form rendering with stepper navigation through schema sections and topology switching</li><li>Dynamic field support: existing API provider fields load real data from the running OpenEverest instance; new/unknown provider types can be mocked</li><li>Output panel displaying the JSON payload after form data post-processing</li><li>CSP-compliant solution</li><li>Unit tests for core logic (schema validation, persistence, mock data injection) and component tests for key panels</li><li>Plugin developer guide for using the playground and the UISchema format</li></ul>
Harbor is a popular and widely adopted container registry. LFX manatees 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 Golang 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.
Containers have extended beyond their traditional cloud environments, becoming increasingly prevalent in remote and edge computing contexts. These environments often lack reliable internet connectivity, posing significant challenges in managing and running containerized applications due to difficulties in fetching container images. To address this, the project aims to decentralize container registries, making them more accessible to edge devices. Expected Outcome: The goal is to extend the proof of concept and demonstrate that such a solution practically works. Candidates should be able understanding and implementing the image (https://github.com/opencontainers/image-spec) and distribution spec (https://github.com/opencontainers/distribution-spec) to replicate images from a central registry to a registry on the edge location.
This project focuses on enhancing observability in kgateway’s agentgateway integration by adding support for OpenTelemetry-based tracing, exposing Prometheus-compatible metrics, and configuring access logging. It builds on a previous LFX project that introduced tracing support for kgateway’s AI extproc server, extending those capabilities to support span propagation from agentgateway. Expected Outcome: 1. Translate the existing tracing and access logging APIs in kgateway to enable configuring tracing for the kgateway’s agentgateway integration 2. Create end-to-end (e2e) tests to validate configuration and trace propagation 3. Raise issues for any gaps or friction points discovered during testing 4. Write documentation for plugin developers and end users 5. Writing user-facing documentation and blogs on Otel tracing with agentgateway and kgateway integration with OpenTelemetry-compatible backends 6. Gain hands-on experience with AI providers, OpenTelemetry, tracing platforms, MCP, a2a, Kubernetes, and kgate 7. Fun!
KubeArmor is Cloud Native Runtime Security Enforcement System that restricts the behavior of containers and nodes at the system level using Linux Kernel LSMs (Linux Security Modules) and eBPF. KubeArmor applies container/pod annotations to achieve some of the goals. Currently, these annotations are applied using k8s rolling update feature that results in pod getting terminated and recreated. Mutating webhooks could achieve the same functionality in a much cleaner way without having to terminate the pods.
Provide a CLI command for Keptn CLI that generates a template repository to start developing a Keptn service integration.
Implement fuzz testing for KubeArmor using a suitable tool like oss-fuzz or AFL. Generate a comprehensive input set to guide the fuzz testing, profile execution using tools like pprof to detect anomalies, and identify components such as the policy controller, operator, configmap handler, and GRPC endpoints for testing. Document the entire process for repeatability in future versions and develop an automation strategy for ongoing fuzz testing. Expected Outcome: Improved OSSF Score; Standards for Fuzz Testing for KubeArmor; Stabilization of KubeArmor
Cartography (https://github.com/cartography-cncf/cartography) makes maps of the cloud so that security and devops teams can find and fix problems. Think about it like the Maurauder's Map (https://simple.wikipedia.org/wiki/Marauder%27s_Map) from Harry Potter. Cartography has very good AWS coverage, but lacks support for many Azure and GCP resources. With your help, we can fix this! Companies around the world use Cartography to better understand their infra, and you can be a part of this. Most of these modules should be conducive to coding with agents (we have a well-documented AGENTS.md! (https://github.com/cartography-cncf/cartography/blob/master/AGENTS.md), so if you enjoy writing in Python, want to learn about information security/devops, and moving fast, this is the project for you. Expected Outcome: Design and implement graph schemas for missing Azure and AWS objects in Cartography
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. Expected outcome: - Use Neo4j's ability to create graph projections, which copy a subgraph to RAM so that algorithms can be efficiently run.
Description: WasmEdge provides C SDK as the based library and uses this to implement other languages SDK such as Golang, Rust, Java, and Python(developing). We would like to provide C++ SDK in this task. Expected Outcome: A document to explain the C++ SDK, a test suite cover the implementation details, and the implementation of WasmEdge Basics and VM sections in the C SDK.
The goal of the project is to enhance the accessibility, consistency, and comprehensiveness of the Caliper documentation. This mentorship project aims to transition the current Caliper documentation site to utilize the common documentation template adopted by Hyperledger projects. This standardization effort will ensure a seamless user experience across Hyperledger documentation, facilitating easier navigation and comprehension. Furthermore, the project will focus on content improvement to ensure that the documentation covers all aspects of Hyperledger Caliper comprehensively, including installation, configuration, usage, and troubleshooting, with up-to-date and accurate information. The mentee can gain a wealth of knowledge and skills that are valuable not just for this specific project but for their professional development in technical writing, documentation management, and basic understanding of blockchain technology.
Description: Cluster API (CAPI) is a Kubernetes sub-project focused on providing declarative APIs and tooling to simplify lifecycle management of Kubernetes clusters. CAPV is the infrastructure provider that extends Cluster API to manage Kubernetes clusters on vSphere. As a mentee, you will start with learning CAPI/CAPV concepts and then, will work on the main project which is to improve unit test coverage.
Inspektor Gadget is an eBPF tool and systems inspection framework for Kubernetes, containers and Linux hosts. Users can develop gadgets using different kinds of eBPF programs: kprobe, tracepoint, etc. This project will focus on adding support for more kinds of eBPF programs such as uprobes and ensuring the documentation is updated for each of them Expected Outcome: Inspektor Gadget has support for additional eBPF program kinds