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 focuses on implementing the backend API for managing Binding Policies. The API should support creating, reading, updating, and deleting policies while ensuring robust validation and performance. Objectives - Develop backend API endpoints for Binding Policy management. - Ensure proper validation and enforcement of Kubernetes standards. - Optimize backend performance for handling multiple policy requests. - Implement logging and error handling for better debugging. Expected Outcomes - A secure and scalable backend API for Binding Policies. - Full CRUD functionality accessible from the UI. - Improved validation and performance optimizations.
WasmEdge received several bug reports, which Fuzzer found. We would like to ask mentees to investigate and determine whether the issue is real, figure out solutions, or mark it as a `won't-fix` issue if it's invalid. To apply for this mentorship, you should also submit a proposal as part of the application materials. Please check the upstream issue for the detailed target list and the proposal template. Expected Outcome: At least fix/determine 60% of the mentioned issues.
The core goal of this mentorship consists in implementing the much requested feature of adding support for the F-extension to Ripes. This involves two major steps: first, constructing inside Ripes source code a working implementation of the extension for correctly simulating the instructions with VSRTL (a Ripes-specific, Hardware-Description-Language-like C++ Domain Specific Language created ad-hoc for Ripes); second, implement the required additional Ripes GUI interface for correctly visualizing meaningful insights into the inner working of cores implementing the F-extension. The mentee should expect to fully complete all complementary tasks to the development process, as writing and running comprehensive tests and updating the documentation to reflect the latest version of the project.
The project (https://github.com/litmuschaos/litmusctl) aims to improve litmusctl by introducing end-to-end (E2E) tests for better release testing and adding CRUD commands for probes, addressing user needs. Additionally, it seeks to enhance user accessibility by making litmusctl available on Brew and Chocolatey package managers. Expected Outcome: The enhancement of litmusctl will include comprehensive E2E testing for improved reliability, the addition of CRUD commands for probes to expand functionality, and availability on Brew and Chocolatey for greater accessibility and user convenience.
<p>The Microcks CLI (microcks-cli, written in Go) is a key part of Microcks' CI/CD story - it lets developers trigger contract tests and import artifacts from the command line and in GitHub Actions. This project goes into the developer experience layer. Today, developers must navigate to the Microcks web UI in a browser to see test results, check mock status, and diagnose import errors. There is no IDE integration, no offline validation mode, and no way to get mock results inline with the code being tested. This project builds three focused improvements that bring Microcks into the editor and the local dev loop: a VS Code extension, a local dry-run mode powered by Testcontainers, and an updated GitHub Actions output format that annotates PRs with per-operation pass/fail results.</p><p><br></p><p>Expected Outcome:</p><p> - A VS Code extension (microcks-vscode) published to the VS Code Marketplace that connects to a running Microcks instance and shows: loaded services, mock operation status, recent test run results, and importer job logs - all inline in the editor sidebar (Like postman, thunder client)</p><p> - A microcks test --dry-run flag in the CLI that uses Testcontainers (the Microcks uber image) to spin up an ephemeral local Microcks instance, import the specified artifact, run the contract test, report results, and tear down - with no external Microcks server required</p><p> - A demo video and documentation page on microcks.io showing the full local-to-CI workflow</p><p><br></p>
<p>The [Ecosystem Explorer](<a href="https://explorer.opentelemetry.io" rel="noopener noreferrer" target="_blank">https://explorer.opentelemetry.io</a>) helps users discover and get detailed documentation around various OpenTelemetry components. As the project expands to more ecosystems (Python, JavaScript, GenAI), information density will increase significantly, requiring patterns and approaches tailored to more than just the initial Java Agent use case. This mentorship involves conducting UX research to understand how users actually want to consume and use this information, covering: how users currently find information about components or instrumentation (LLMs, GitHub, docs, vendor sites, trial and error); what questions they are trying to answer (what telemetry will I get, how do I configure it, what changed between versions); what personas exist (app developers instrumenting code, platform engineers running collectors, SREs debugging production); how similar tools present dense technical information (npm registry, crates.io, Go pkg site, Docker Hub); and how LLMs are being used in this area and what the experience has been with them. The research will inform how we structure information, what features to prioritize, and how to present complex telemetry data in an accessible way.</p><p><br></p><p>Expected Outcome:</p><p><br></p><ul><li>User Interviews Report: Summarized findings from 3-5 user interviews covering different user types and key tasks</li><li>Competitive Analysis Report: Findings from reviewing 2-3 similar tools (e.g., package registries, API documentation sites) on how they present component information</li><li>Information Architecture Recommendations: Proposed structure for presenting a specific type of component data (e.g., "instrumentation" or "collector components")</li><li>Wireframes/mockups (stretch goal): Visual concepts for key user flows</li></ul>
This project aims to enhance the KubeStellar controller to reflect the readiness status of WEC resources in their corresponding WDS resource definitions. Currently, users must inspect status objects manually to determine propagation and readiness. This improvement is especially useful for tools like Argo CD, which rely on accurate READY status to show resources as synced. Expected Outcome: 1. Design an efficient architecture to map the status of WEC resources back to their originating WDS resource. 2. Implement the controller logic to update WDS resource readiness based on the aggregated readiness of all corresponding WECs. 3. Ensure the updated WDS READY state integrates well with tools like Argo CD, showing accurate sync states. 4. Validate and demonstrate that resources in WDS appear correctly synced post implementation.
This feature request aims to automate the building and publishing of OS images that are used in Kubespray CI testing. Currently, these images (defined in `test-infra/image-builder/roles/kubevirt-images/defaults/main.yml`) must be manually created and pushed by maintainers. Automating this process would reduce manual work, eliminate bottlenecks when maintainers are unavailable, and could include automatic cleanup of outdated or unused images, while still retaining images needed for older supported release branches. - Expected Outcome: A CI job (likely post-merge and possibly periodic) that automatically: 1. Builds the required Kubespray OS images used in CI for tested distributions. 2. Pushes these built images to the appropriate registry. 3. Cleans up old or no longer needed images but retains those required for supported release branches.
Vitess is a CNCF project that has been around for a while. It has a strong community of users and contributors. We want to continue growing this community and make sure that everyone feels welcome and included. Expected Outcome: The mentee is expected to evaluate contributor ladder schemes and rewards and produce a recommendation for the Vitess maintainers. Once a decision is made, the mentee is expected to implement the decisions from the maintainer team. The mentee is expected to collect data about Vitess usage from the community and publish the highlights as a blog post. The mentee is expected to review the Getting Started docs (https://vitess.io/docs/20.0/get-started/) on the Vitess website and enhance them to improve the onboarding experience. The mentee is expected to research and recommend marketing opportunities for Vitess. These could be guest blog posts, podcasts, live streams etc.
Volcano has introduced Agent Scheduling feature that supports fast scheduling for AI agent workloads. This includes ShardingController for shard management, agent scheduler for agent workloads scheduling, and enhanced existing Volcano batch scheduler with sharding support to coordinated scheduling with agent scheduler. To ensure correctness and stability of this new scheduling mechanism, we need to build a comprehensive end-to-end (e2e) test suite. Test cases should cover key scenarios including shard creation, node assignment across shards, agent scheduler scheduling in different sharding modes, etc. - Expected Outcome: - A comprehensive e2e test suite using Ginkgo framework covering all agent scheduling scenarios. - Test cases for ShardingController: shard creation, node assignment, node addition/removal, configuration changes, and node stability across shards. - Test cases for Agent Scheduler: scheduling in no-sharding, hard-sharding, and soft-sharding modes, shard reconfiguration, and multi-worker scenarios. - Test cases for Volcano scheduler with sharding: validation of allocate, preempt, reclaim, and backfill actions under different sharding configurations. - Integration with CI/CD workflows for automated testing. - Comprehensive documentation including test design, coverage reports, and guidelines for extending tests.
We have already implemented management for all types of resources on the control plane and for particial resources on member clusters in the Karmada Dashboard. However, resource management is currently atomic, and the relationships between resources are not presented intuitively. As a result, users may find it difficult to understand and manage relationship across resources. For example: On the control plane, after a user creates a ResourceTemplate, it is not easy to tell which Policy matched that ResourceTemplate and then generated the corresponding ResourceBinding and subsequent Work resources. Across the control plane and member clusters plane, users cannot easily see which member clusters a ResourceTemplate has been propagated to, or the status of the distributed resources in each member cluster. Therefore, we aim to provide a unified management and control capability (OmniControl). From the perspective of ResourceTemplate, users should be able to view the resource’s status on both the control plane and member clusters plane, building on the existing atomic capabilities. This will help users understand the end-to-end status of resources more intuitively and quickly identify and resolve issues when propagation or distribution failures occur. Expected Outcome: *Comprehensive design and API documentation *Topology visualization of Karmada core resources and Kubernetes resources (Karmada architecture diagram) (https://karmada.io/docs/core-concepts/architecture/)..
Description: Kubernetes Validating Admission Policy Support Expected Outcome: Kyverno support for ValidatingAdmissionPolicy in one of the identified proposals.
Kyverno supports image signature and attestation verification using the Sigstore Cosign tooling. Re-implement the Kyverno Sigstore Cosign module to use OCI artifacts and references and remove dependencies to the Cosign CLI packages. - Expected outcome: Kyverno can use OCI artifacts to verify container images that are in Cosign format.
Pack is the reference implementation of a Cloud Native Buildpacks platform used to build application images in multiple organizations. Because all developers want their code to build and deploy as quickly as possible, small speedups in pack can have significant benefits, and slow-downs in pack are undesirable. Today, pack has no benchmark suite that would safe-guard against regressions in execution speed. Expected Outcome: The mentee will create a benchmark suite around some critical path sections identified with help from maintainers. The mentee will be supported in applying profiling tools to identify possible speedups, hopefully leading to at least one user-facing performance improvement.
Headlamp is a Kubernetes UI that supports a growing ecosystem of plugins, including integrations with CNCF projects like Flux, KEDA, and Falco. As the number and complexity of these plugins grow, ensuring a consistent, intuitive, and user-friendly experience becomes increasingly important. This project will focus on conducting UX audits of existing Headlamp plugins, identifying usability issues, and proposing design improvements. It will also explore user personas (e.g., operators vs. developers) to inform design decisions and help shape the future of plugin UX in Headlamp. Expected Outcome: A design-led UX audit and improvement initiative that includes: 1. A review of selected Headlamp plugins to identify usability issues and inconsistencies 2. User research and persona development to better understand plugin audiences 3. Design proposals and mockups for improving plugin UIs and workflows 4. Collaboration with technical mentors to help implement selected improvements 5. Optional exploration of UX needs for recent Kubernetes features or under-designed areas in Headlamp
This project aims to develop/enhance the E2E test cases for ChaosCenter. The ChaosCenter is a single source of truth to control all the different Chaos Activities happening around Litmus. From the ChaosCenter you get the freedom to manage every single part of Litmus and shape your workflows exactly the way you want them.
Kyverno currently supports cluster-wide CEL-based policy types (ValidatingPolicy, MutatingPolicy, ImageValidatingPolicy, GeneratingPolicy, and DeletingPolicy), but lacks namespaced versions. This creates challenges for namespace owners who need to manage policies within their namespaces without requiring cluster-wide permissions. The goal of this project is to implement namespaced versions of all five CEL-based policy types to provide better RBAC control, security, and lifecycle management for namespace-scoped policy management. Expected Outcome: 1. Implement namespaced versions of all five CEL-based policy types 2. Ensure proper RBAC integration for namespace-scoped policy management 3. Create comprehensive documentation and examples for namespaced policies 4. Write tests to validate namespaced policy functionality
Improve how cilium.io content is discovered, ranked, and reused by search engines and AI tools. This includes enhancing technical SEO, optimizing for answer engines like Google SGE and Perplexity (AEO), and structuring content to be easily cited and used by large language models (AIO). The mentee will perform audits, recommend improvements, and implement changes across meta tags, structured data, documentation formatting, and content strategy. Expected Outcome: SEO, AEO, and AIO audit report for cilium.io, Implementation of structured metadata (e.g., FAQ schema, article metadata, canonical URLs), TL;DR summaries or answer-first formatting added to key documentation and product pages, Deep-linked, self-contained concept pages created or refactored for LLM usability, Improved search visibility and AI result representation (tracked via baseline comparison)
Develop a connector that provides both synchronous and asynchronous modes of interacting with a running Hyperledger Besu node. The connector would act as an interface between an enterprise application and the Hyperledger Besu node for data ingestions and it could provide event subscription options. The scope of the project would also include an end-to-end test on a sample network.
Description: To some extent, Terraform state is the most essential component for cloud resources provisioned by Terraform Controller. We need to better manage the state.
Iroha 2 currently has WASM-based smartcontracts. WASM, however, imposes a maintainer burden on the user, so upgrading these takes work. We also have an ISI based on easily upgradeable smartcontract facilities, which are difficult to compose into arbitrary logic but require no manual intervention for upgrading to newer versions of Iroha. We would like to involve the community in creating a domain-specific language for creating and composing logic made out of ISI. Iroha 2 DSL is our most important project. Therefore, we would like it to be considered with top priority if not all Iroha-based projects can be considered for the internship program. Learning Objectives - Explore domain-specific optimisations not ordinarily possible in regular compiler design. - Explore the design of ergonomic languages. - Improve the understanding of Rust. Expected Outcome - (Optional) Well-defined Iroha DSL grammar - A binary application (compiler) that parses DSL and produces ISI according to a well-defined grammar - A set of example files written in the DSL covering the following simple use-cases -Cross-blockchain transfer -Modification of metadata -Transference of permission tokens
This project is the continuation of the [etcd.io website](https://etcd.io) docs improvement work. While the relocation of the primary documentation, SEO, and site look and feel work has already been done, there is still more work to be done to implement the new information architecture that has been proposed. This includes working with the mentors and project maintainers to write new pages, adapt existing ones, and write blog posts.
The RISC-V movement has massive potential to unify a fragmented industry behind a single instruction set architecture (ISA). If technology providers focus their efforts on a single processor architecture, rather than duplicating efforts among incompatible architectures, the entire computing ecosystem benefits. Inefficiency in critical base components of the ecosystem hampers this consolidation. There are numerous projects which directly serve as the base components of the software ecosystem, including assemblers, disassemblers, compilers, linkers, loaders, simulators, emulators. In most of those projects today, the human-readable documentation is consulted, and the necessary implementations are performed manually. Needless to say, these processes are time-consuming, inefficient, and error-prone. A new foundation which can serve as a base for automatically generating large swaths of the processor-dependent ecosystem is available, but is not yet effectively use. The “RISC-V Unified Database” project has transformed the salient content from within the RISC-V specifications into an accessible format, YAML, from which content for downstream projects can easily and automatically be further transformed into the content necessary to their project which is currently produced by manual effort.
The healthcare system in Pakistan, particularly in rural areas, faces significant challenges due to limited access to medical facilities and high costs of conventional diagnostic equipment. These constraints leave a large portion of the population underserved, with limited access to timely and reliable healthcare. This project aims to address these gaps by providing a low-cost, portable healthcare solution powered by energy-efficient Edge-AI. By leveraging advancements in RISC-V technology, the proposed solution can revolutionize healthcare delivery in underprivileged areas, ensuring affordable and accessible diagnostics for all. The project, Healthcare-Centric Edge-AI Development on RVMCU Architecture, builds upon the RVMCU, a RISC-V microcontroller designed during the Linux Foundation's Spring 2024 LFX Mentorship Program. The RVMCU, which is compliant with the RV32IMC_Zba_Zbb_Zicsr_Zifencei specifications, was developed as an ultra-low-power, versatile SoC. This proposal seeks to extend that foundational work to enable healthcare-centric applications, specifically targeting wearable and portable devices. The enhanced RVMCU architecture will support diverse healthcare sensors (e.g., cough monitors, heartbeat detectors, ECG sensors) and provide real-time AI-powered analytics. The emphasis will be on achieving energy efficiency, modularity in hardware and firmware design, and seamless integration with AI frameworks optimized for edge computing.