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.
WasmEdge supports PyTorch, TensorFlow Lite, llama.cpp, and more NN backend. Dealing with the text-to-voice is a big thing that we want to achieve. To make it possible, we would like to integrate piper (https://github.com/rhasspy/piper), A fast, local neural text-to-speech system in C++ as a new WASI-NN backend (https://github.com/second-state/wasmedge-wasi-nn). Expected Outcome: 1. A new plugin provides a piper WASI-NN backend 2. A test suite for validating the plugin 3. Documents and examples for explaining how to use the plugin.
The rise of ARM processors has created new binary targets for pre-compiled executables. Additionally, there are tales of widespread use of operating systems that aren't linux? In the ideal case a `pack` user could create a build for an abritrary architecture and operating system, regardless of the host system they used to run the command. Expected outcome: Improved multi-architecture (including ARM) and multi-os "cross-compilation" support in [pack](https://github.com/buildpacks/pack/) Upstream Issue (URL): https://github.com/buildpacks/pack/issues/1459 and https://github.com/buildpacks/pack/issues/1460
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. 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. Expected Outcome: Achieve parity in observability of jaeger-v2 compared to jaeger-v1
OpenCost's data model is now 6 years old, and we have learned a great deal long the way. Based on these learnings, we would like to revamp how OpenCost represents its cost and usage data across the stack. We want to set OpenCost up for the next set of features and scale by building a solid foundation for the way we represent data. Expected Outcome: We would make the UID of Kubernetes objects into a first class citizen. These UID based objects would then be grouped in a similar hierarchy to the way Kubernetes itself is organized. A successful conclusion of this project would see an additional emitter implemented in OpenCost, that emits data objects stored in compressed protobuf which reflect a hierarchy of Kubernetes objects. The mentors will help establish this hierarchy. This hierarchy should then be tested via integration tests against the existing objects, and key metrics compared to be equal across those.
The project aims to extend KubeArmor support and document how KubeArmor is relevant for securing Kubernetes on Edge in addition to generic Kubernetes based Application deployments - Expected Outcome: - Try KubeArmor on Different Kubernetes Platforms - Microshift, k0s - Make fixes to deployments to make them work if needed - Document Usecases on these platforms - Document Usecases at a broader level for EDGE and Container Security - Produce Blogs about extended support and additional usecases
Strimzi is a Kubernetes Operator for running Apache Kafka. This project builds a Headlamp plugin that adds a **Strimzi** section to Headlamp, surfacing Strimzi CRDs so operators can **view and manage Kafka clusters, topics, users, and connectors** from the Headlamp UI. The plugin follows Headlamp UX patterns with list and detail views, links between related resources, and optional metrics embedding. - Expected Outcome: - Plugin exposes key Strimzi CRDs: Kafka, KafkaTopic, KafkaUser, KafkaConnect, and KafkaConnector. - List views, with summary columns (name, namespace, brokers, partitions, replication, status). - Detail pages, showing config, status conditions, sub-resources (broker pods, connectors), and basic actions (create/edit topic, regenerate user creds). - Relational navigation, cluster → topics/users; topic → cluster. - Consistent Headlamp UX, icons, tables, detail layouts, Map view enhancements. - Structured config display (collapsible sections/YAML toggle), humanized statuses, validated forms for mutating actions. - README with prerequisites and limitations; blog post demoing usage.
As an early stage project we’ve biased in favour of documenting the essentials and getting content in place as fast as possible. This has worked well but a side-effect is 3 or 4 different sources of content ( www, docs, rfcs and courseware ). In concert with CNCF technical writing and learning best practices use your UX/web design and technical writing expertise for tremor where we as a team are unskilled - make our content awesome and the user experience exceptional. These are some improvements we did think of, but these are neither complete nor required, more suggestions are welcome: - Unify the different content forms under a single consolidated theme and design - Ease of navigation ( breadcrumbs ) - Preserve markdown for data entry ( we’re programmers ) and keep design separate ( we’re not designers and find this stuff super hard ) - A clean, easy to navigate theme with a focus on user experience - Well integrated with our CI and doc generation tooling ( think gitops for docs and content ) This task would suit a candidate who is interested in `full stack` engineering and the complete software development lifecycle with a specific focus or interest in engineering documentation, web design and communicating well designed content to others with a good user experience - exploiting principles of good technical writing and web design of content management systems for technical content consumers.
This project is about implementing the [groupcache](https://github.com/golang/groupcache) back-end for the caching bucket. Caching bucket is a generic mechanism for caching requests to remote object storage. All of the other caching mechanisms currently suffer from the [cache stampede](https://en.wikipedia.org/wiki/Cache_stampede) problem and it is impossible to "properly" solve this problem with them. This is where `groupcache` comes in. Some work has already been [done](https://github.com/GiedriusS/thanos/commit/d269ce25b744b02c6d4d99f0e2e72af812e45f37) so you will have to something work off of. `Groupcache` also needs some improvements with regards to fetching multiple keys at once to improve the performance even more. In the end your work will make not just Thanos faster but also cheaper because less requests will need to be made to the remote object storage.
As a built-in orchestration engine for Volcano, jobflow acts as an improtant role for users and it's still new-born. Many issues related to its stability are reported recently. Please help make full test for job-flow on the classical scenarios and reslove bugs reported in issues. - Expected Outcome: Make full test for jobflow and output the test report, fix bugs reported in recent issues.
Over time, the plugin-arch pipecd (https://pipecd.dev/blog/2024/11/28/overview-of-the-plan-for-pluginnable-pipecd/) (some docs we call pipecdv1) has reached the final stages before release. Although most of the features of v0 are retained when moving to v1, some of the documentation and usage need to be updated to match v1. Expected Outcome: 1. Refine pipecd documentation, ensure v0 and v1 coexist in parallel without causing confusion 2. Prepare documentation for pipecd v1 3. Support prepare developer guideline for making pipecd plugins (https://github.com/pipe-cd/community-plugins/)
Description: WasmEdge is a lightweight, high-performance, and extensible WebAssembly runtime for cloud native, edge, and decentralized applications. WasmEdge is an official sandbox project hosted by the CNCF. WasmEdge has implemented some features of WASI-NN. However, the backend is using ONNX. In this ticket, we would like to have both ONNX and OpenVINO backend.
The project DRman aims to develop a stand-alone utility for provisioning Verifiable Credential Registries (VCR). This utility will also support the administration of the registry, containing credentials issued by organizations. Core functionalities, such as the creation, verification, modification, and revocation of credentials, are fundamental to this project, enabling administrators to manage the VCR effortlessly. Key considerations for the project include: - Creation (of DID Registry): Function to create a DID Registry for an organization on Git. - Onboarding: Function to add enable/restrict access to members of an organization to a repository (e.g., using a combination of GitHub private tokens, GitHub username & users DID). - Management: Function to list APIs that are needed to add/update/revoke access DID’s or (DID Document) saved as files on the repo. - Adoption of Hyperledger AnonCreds: Incorporating the Hyperledger AnonCreds specification for our DIDs, signifying a commitment to leveraging advanced cryptographic techniques and privacy-preserving protocols..
Optimize KCL LSP(language server protocol) prompt information, including the implementation of type inlayhint and optimization of hover content rendering. Currently, KCL’s hover content is in plain text format and needs to be rendered into a more beautiful style. Expected Outcome: Added type inlayhint in KCL IDE and optimize hover content render.
This project aims to develop the frontend components for managing clusters in the Inventory and Transport Space (ITS). Users should be able to onboard and manage clusters through an intuitive UI. Objectives: - Develop UI components for cluster onboarding and management. - Implement validation and error handling for cluster registration. - Ensure smooth integration with backend APIs for real-time updates. - Provide a guided onboarding experience for adding new clusters. Expected Outcomes: - A fully functional ITS management UI. - Improved usability for adding and managing clusters. - Seamless backend integration for real-time data updates.
This project focuses on implementing an enhanced Model Context Protocol (MCP) and A2A communication framework for KubeStellar's Management Control Plane server. It builds upon the foundation MCP implementation to include advanced A2A coordination capabilities, distributed AI agent communication, and sophisticated context management for multi-cluster environments. Expected Outcome: A fully specified Model Context Protocol with A2A communication extensions, implementation of protocol handlers in Python for the MCP server, A2A communication framework enabling AI agent coordination, context management system for KubeStellar state information, serialization mechanisms for cluster state, protocol extension mechanisms for different AI providers, performance optimizations, and comprehensive test suite.
The Kruise Game Controller Manager currently stores cache information for network plugins in memory, resulting in its single-replica deployment. From a business stability architecture perspective, it is necessary to migrate the cache out of memory to enable Kruise Game to transition to a multi-replica deployment. Besides, the current webhook certificate is self-signed by the controller. When the number of copies is more than one, an unauthenticated error will occur, so this needs to be modified. Expected Outcome: 1. Support multi-replicas deployment 2. Support webhook certificate signing using cert manager
Kmesh employs eBPF for load balancing. However, at present it only supports short-lived connections and offers a limited range of load balancing algorithms. Consequently, we aim to support a broader range of load balancing capabilities. - Expected Outcome: - 1.Load balancing with load-dependent connections via eBPF. - 2.Support as many load balancing algorithms as possible - 2.1 Sticky Round Robin - 2.2 Weighted Round Robin - 3.Userguide and Proposal - 4.Unit Test and E2E test
Jaeger is an open-source, distributed tracing platform designed to monitor and troubleshoot microservices-based systems. Jaeger UI pioneered many new visualizations for analyzing distributed traces. However, over time, it accumulated views that utilize different and sometimes deprecated viz libraries. The objective is to standardize charting / graphing libraries used in Jaeger UI, upgrade their dependencies, and add new visualization features. Please refer to the upstream issue for more details. Expected Outcome: 1. Jaeger UI is not using deprecated dependencies 2. Consistent look and feel of graphs 3. Bonus: side panel for details for a given node 4. Bonus: overlaying metrics on the graph (as edge annotations and node coloring to reflect health / error rates) 5. Bonus: varying node displays depending on the type of node and implementation language
ClusterDuck Protocol is a mesh communication firmware that utilizes LoRa radios and makes it easy to set up emergency networks. The current implementation only allows for information to flow in one direction. While this works well, the experience is not great for end users who need to know if help is on the way. Therefore we want to add 2-Way communication so that disaster survivors can chat with emergency response teams.
Description: [ORAS](https://oras.land/) is a tool for working with OCI artifacts and OCI registries. It allows users to distribute OCI artifacts across OCI Registries. Users seeking a generic registry client can benefit from the ORAS CLI, while developers can build their own clients on top of one of the ORAS client libraries. ORAS has Python and Golang SDK that allow developers to build their own clients on top of one of the library. Similarly, developing a .NET SDK will enable .Net developers to use ORAS API and enhance the ORAS ecosystem. Expected Outcome: Develop a .NET SDK in a new repository and write the examples and API document on GoDoc. Write unit test for this SDK and make sure the testing coverage is qualified.
Since jobflow is an important built-in orchestration engine for Volcano, it is still lack of user guidance. Please add more docs to demonstrate its installation, usage, tips and so on. - Expected Outcome: Add docs into volcano-sh/volcano/docs/user-guide and describe the usage of jobflow.
A really common use case we have been seeing is about enabling an IoT scenario with MQTT based devices and using an Apache Kafka cluster as the events and storage platform running on Kubernetes via Strimzi. In order to do that, there is the need to map the MQTT protocol to the custom Apache Kafka one and bridge from one to the other. This project idea is about designing such a mapping and developing a pure [Netty](https://github.com/netty/netty/tree/4.1/codec-mqtt/src/main/java/io/netty/handler/codec/mqtt) based MQTT server component (not a full MQTT broker) able to accept MQTT client connections and handling the corresponding communication based on the [MQTT 3.1.1 specification](http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html). Finally, developing the Kafka producer part to get messages from MQTT clients and sending them to an Apache Kafka cluster. - Expected outcome: POC source code for an MQTT to Apache Kafka bridge
Reduce adoption friction by building integrations between KubeStellar and popular Kubernetes ecosystem tools. The mentee will survey early users to identify integration priorities, design integration architectures, develop working integrations with tools like GitOps platforms, Terraform, CI/CD systems, or monitoring solutions, create comprehensive documentation and examples, and validate integrations with real users. This program emphasizes software development, API integration, understanding ecosystem tools, and creating seamless user experiences. Expected Outcome: 2 production-ready integrations with popular Kubernetes tools, Integration documentation with clear setup guides for each, 2 demo videos demonstrating integration value and setup, Sample implementations and templates for common scenarios, 3 users actively adopting each integration, Submissions to relevant tool marketplaces where applicable, Integration maintenance guide for ongoing support, User feedback on integration quality and usefulness, User engagement: 6 GitHub issues filed by integration users, 4 PRs or PR reviews contributed by integration users
In this project the student will participate and contribute to OSS projects L3AF and eBPF for Windows led by Walmart, Microsoft and contributed to by WiPro. L3AF is an API for cross-platform, multi-cloud Enterprise eBPF deployment. With the R1 public release of L3AF R1 one of our next goals is to strengthen our multi-platform capabilities by supporting eBPF for Windows. The intern will work with the L3AF and eBPF for Windows teams to bring the cross-platform vision of the L3AF project into reality for a future release.