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.
Microcks (https://microcks.io/) is a cloud native, open source tool under CNCF for API and microservices mocking and testing. This project aims to support the growing Microcks adopter community by fostering a collaborative effort to document production-grade deployment strategies for cloud environments. While the core Microcks maintainers focus on features, security, and enhancements, the adopters are responsible for production setups. However, a shared repository of best practices can help users learn from one another in a true open-source spirit. This project will empower the community to deploy Microcks confidently in diverse cloud environments, fostering collaboration and sharing of expertise among adopters. Expected Outcome: Participants will contribute to the Microcks community repository (https://github.com/microcks/community/tree/main/install) by documenting deployment workflows for popular cloud providers, such as AWS, GCP, and Azure, as well as other providers like OVH, Oracle, Scaleway, or Koyeb. Deliverables will include guides on utilizing cloud-native services (e.g., PostgreSQL, MongoDB, IDP) to create robust and scalable Microcks installations ideally on managed Kubernetes services from the provider.
Description: Integrate Kubernetes Pod Security with Kyverno - Part II Expected Outcome: PR sent to kubernetes/kubernetes containing necessary changes to implement the behavior on the Kyverno side.
Sometimes users will edit the `kcl.mod` file in the IDE to update project dependencies. The integration between LSP and KPM needs to be strengthened, it mainly includes two parts of functions. - According to the content written by the user in the kcl.mod file, the IDE automatically calls the `kcl run/mod add/mod metadata` and other functions, and feeds back the results in the IDE. - According to the user's operations in the command line, the changes of `kcl.mod` and project content are synchronized to the IDE. examples: 1. When users update kcl.mod in the IDE, the required dependencies are automatically downloaded. 2. When users use the kpm tool to update dependencies, the IDE can be updated (recompiled). For example import k8s # Error: Module not found use `kcl mod add k8s` to download the dependency `k8s`. kpm will download the k8s package and then the IDE errors will be eliminated Expected Outcome: - Complete at least the following parts: - IDE triggers automatic dependencies updates of package management tools. - Automatic synchronization of kcl.mod files. - IDE users actively trigger dependency downloads, it looks like: a button or link for user to download the missing dependencies. - After the dependency update is complete, the IDE triggers a recompile to clear the error
WasmEdge provides WASM module serializer in C API level for developers to convert the loaded WASM structure back into binary format. But after supporting the `function-references`, `GC`, `relaxed-SIMD`, and `exception-handling` proposals in WasmEdge, the partitions of these proposals in serializer are not implemented yet. Thus, we would invite mentees to complete the binary format serialization with the above WASM proposals in WasmEdge. Expected Outcome: * Complete the serialization of the new module extensions in WASM proposals. * Complete the serialization of the new instructions added in WASM proposals. * Add some basic unit tests with hand-writing WASM binaries.
Inspektor Gadget is an eBPF tool and systems inspection framework for Kubernetes, containers and Linux hosts. A Gadget is an OCI image that includes one or more eBPF programs, metadata YAML file, and optionally, WASM modules for post processing. As OCI images, they use the same tooling as containers: building, pushing/pulling from OCI Registries. But today, Inspektor Gadget does not have good tooling for inspecting a gadget: the ig image inspect command just gives the gadget name, digest and creation date without further details. Expected Outcome: the ig image inspect command tells the architectures supported by the gadget, the layers included in the OCI image, the data sources with their fields, the eBPF parameters. Additionally, inspecting the eBPF module can provide the ELF sections, the eBPF maps and the disassembled eBPF bytecode annotated with the source when available.
Description: KubeEdge's website has been running for a few years, and now we have more customer cases and more developer courses, so this project will update KubeEdge's website, with more readable documents on the homepage, covering user cases, developer courses, etc. Expected Outcome: The website has more readable documentation, covering user cases, developer courses, etc.
Users need to communicate between the cloud and the edge. For example, the cloud calls the rest interface of the edge service. In this case, the routing management function of KubeEdge can be used. Currently, routing management function of KubeEdge has some problems in the case of multiple CloudCore copies. The main problem is that when there are multiple copies of CloudCore, whether the cloud sends messages to the edge or reports the message to the cloud, it is not known which CloudCore is sent to it for processing, and there is confusion in message management in the cloud. In this project, we hope router manager can be optimized to support multi-CloudCore scenario. Expected Outcome: Support using router manager in multi-CloudCore scenario.
This project goal is to improve the efficiency of the image developers and users through the artifact explorer tool with ORAS under the hood. This tool helps users to explore and search the content of an artifact or a registry. This doc is to gather ideas for early brainstorming purposes. For users, this tool reduces CLI learning cost and improve efficiency for developers. They don’t need to memorize and type the CLI commands to explore the content of an OCI artifact and registry. - Expected Outcome: - Provides a web portal to view the content of OCI artifacts from any public registries - Users can drill down into the detailed content of an image manifest or a layer - Users can view the artifact reference graph from the web portal - Users can view and download the supply chain artifacts like the signature, SBOM, attestation - Provides search capabilities to allow users to search container images or OCI artifacts on a central web portal. We can combine it with Artifact Search API capabilities (https://docs.google.com/document/d/1rcQROZP31q7BOjoZ977Ok7pt28z_UXfW0vAK3xC0wdI/edit#heading=h.rx512bvufn5q). - Explore the image’s file system of layer (tentative)
keink(represent for 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.
Devfiles are YAML files that define development environment running in the cloud. The main part of a Devfile is the components section and specify the containers required to code, build and test an application. The Devfile can either include those containers defintions or reference external files such as Dockerfiles or Kubernetes manifests. The Compose file is a popular format in open source development projects to define runtime environments for testing the application but those cannot be referenced by a Devfile yet. The goal is to update the API specification to allow referencing a Compose file from a Devfile and to implement the support in the Devfile library.
Network topologies and graph databases go hand-in-hand. The OpenAPI specifications for Kubernetes provides taxonomy, but augmenting a graph data model with formalized ontologies enables any number of capabilities, one of the more straightforward is the inferencing requisite for natural language processing, and consequently, a human-centric query / response interaction becomes becomes possible. More importantly, more advanced systems can be built when a graph data model of connected systems is upgraded to be a knowledge semantic graph. Deliverables (among other items): - MeshModel capabilities browser - Import/export of MeshModel models and components as OCI images - augmentation of cuelang-based component generator
While the OpenAPI specifications for Kubernetes offer a taxonomy, integrating a graph data model with formalized ontologies unlocks a multitude of capabilities. Among these, enabling inferencing necessary for natural language processing stands out as a straightforward application. This, in turn, facilitates the possibility of a human-centric query/response interaction. Importantly, advancing to a knowledge semantic graph from a connected systems' graph data model opens the door to building more sophisticated systems. Expected Outcome: - Identifying new technologies from CNCF landscape and creating new YAML-formatted definitions of one or more relationships.
Volcano supports unified scheduling of online and offline workloads, provides a wealth of scheduling plugins and algorithms, and can distinguish different tenants through queue distinction. The current scheduling policy is a global configuration, and all jobs in the queue use the same scheduling policy, but in actual scenarios, different tenants may need to use different scheduling policies due to different usage scenarios. Therefore, volcano needs to support setting and using different scheduling policies at the queue level instead of using a globally unified scheduling policy. Expected Outcome: 1. A new field is added to the queue CRD, and users can set scheduling policies at the queue level. 2. Volcano scheduler implements different scheduling policies based on the queue in which the job is located.
1) Develop prompts & context size for LLMs that identify architectural parameters in the RISC-V privileged and unprivileged spec. a) Give examples from the manually created list (in UDB). b) Identify with textual excerpt from the specs. c) Classify the parameters as either dependent on a configuration, named or unnamed. 2) Use those prompts to collect a list of parameters using at least two different LLMs and the parameters documented in UDB. 3) Refine the prompts to address any differences between LLM and UDB results, as needed. a) Filter out any hallucinations as negative examples, e.g. doesn’t fall into any of the 1(c) categories or falls into the wrong category (could be context size dependent). b) Use some missing parameters as further prompt examples. 4) Create a Github PR to insert tags into the spec for each parameter in the resulting list, giving unique names to unnamed parameters according to the tag format spec, and using existing parameter names as examples.
Harbor is a widely adopted container registry, and its initial CLI has been developed by LFX mentees. The goal is to extend this CLI by implementing additional functionalities and workflows that are currently only available in the Web UI. The CLI should be useful for Harbor administrators and users, especially to manage workflows within CI/CD pipelines. We seek a Golang-experienced mentee to enhance the CLI independently. Expected Outcome: 1. Extend the Harbor CLI to include essential commands not yet implemented. 2. Add new features to improve Harbor management via the CLI, enabling robust workflows in CI/CD environments.
There are several steps to the CRI-O release process that are manual. Lots of work has been done to update this, but there is still pushing a tag, copying release notes and some other small tasks. This project is about such automation. Expected Outcome: - Fully automated release and patch versions of CRI-O
On a periodic basis, the CNCF would like to present a public challenge to those that are interested in participating (e.g. “Challenge: Distributed Tracing with Jaeger”). Your mission in this internship is technical content creation of said challenges through use of markdown, Meshery, and any number of other CNCF projects. Challenges will be created using the Meshery Playground and published (in what is potentially the CNCF Hub). They will be similar too, but slightly different from these [example tutorials](https://docs.meshery.io/guides/tutorials/). Understand that your challenges will be promoted through CNCF channels, reviewed by various project maintainers, and that each challenger (participant) will receive a certain number of points, depending upon whether or not they successfully complete the challenges that you create and in what timeframe they complete those challenges (the faster, the more points). Your challenges will need to vary in level of difficulty. Expected Outcome: - 5+ new challenges published - Challenges can contain more than one objective. Points are earned for each objective completed. - Bonus: Extend one or more of Meshery’s Learning Paths.
We have created a tutorial in the interactive learning platform killercoda for KubeEdge deployment. This can give a hands-on experience of KubeEdge deployment. Now we need to support the latest version of KubeEdge and integrate example for developers. - Expected Outcome: It can install the latest version of KubeEdge example, developers can experience these cloud native edge-computing demos online.
This project is about updating and optimizing the [protocol buffers](https://developers.google.com/protocol-buffers) implementation used for communication throughout the Thanos project. Thanos relies heavily on gRPC and protocol buffers for communication between its many components, and now with the release of the [new Golang API for protocol buffers](https://blog.golang.org/protobuf-apiv2) and the deprecation of the old API, Thanos should be updated to benefit from the improvements in the ecosystem. As part of this project, the protocol buffers generator used in Thanos will be migrated to one that supports the new API and brings other improvements, such as reducing memory allocations. This project will help make Thanos faster and ensure that we stay up to date with the latest libraries.
Software acceleration utilizing specifically designed hardware components is a widely used technique for speeding up different kinds of kernels found in the targeted applications. An example of such kernels in High-Performance Computing (HPC) are algorithms involving the computation of sparse data structures. Sparse applications are difficult to accelerate due to their memory-bound nature, which means that the data is not accessed contiguously in memory. That implies many scatter and gather accesses to the comparatively slow memory. Consequently, dedicated hardware components capable of accelerating the scatter/gather instructions, are a key to improve the performance of sparse applications. The goal of this project is to achieve an FPGA-based acceleration of the vrgather RISC-V vector instruction (RISC-V ISA vector extension v1.0) using a bitonic network. The bitonic network is originally a sorting network that implements the merge-sort algorithm (add reference here). A number of inputs of the network can end up in any output after traversing it. When this concept is applied to a Vector Register File, the bitonic network can be used not only to sort a set of vector elements, but also to move data internally from one register to any other register. The scope of this project is limited to the execution and acceleration of the gather vector instruction, in which the variability of the vector length needs to be considered.
Karpenter is a dynamic Kubernetes node autoscaler that provisions compute resources in response to real-time workload demands. While Karpenter is powerful, it lacks a native UI for visualizing its autoscaling behavior and managing its custom resources. This plugin will integrate Karpenter-specific insights into Headlamp, leveraging Headlamp’s existing CRD support to provide a focused, user-friendly interface for understanding and managing Karpenter’s decisions. Expected Outcome: A Headlamp plugin that provides: 1. Show Karpenter Provisioners, NodePools, and NodeClasses, including their constraints and current status. 2. Real-time display of scaling decisions, such as which pods triggered provisioning and why. 3. A dashboard for pending pods with unmet scheduling requirements, highlighting why they couldn’t be scheduled. 4. Integration with Kubernetes events and Karpenter metrics to show provisioning latency, node lifecycle events, and cost efficiency. 5. A configuration editor for Karpenter Custom Resource Definitions(CRDs) using Headlamp’s existing CRD facilities. 6. Documentation and possibly a demo video or blog post.
Description: Kyverno is a Kubernetes native policy engine that secures and automates Kubernetes configurations. This project automates scalability tests for Kyverno on large Kubernetes clusters with several namespaces and resources. The candidate has to propose an automation plan to create clusters and resources and help optimize resource usage of Kyverno for different loads for large Kubernetes clusters.
The objective of this project is to perform a performance and benchmarking analysis of BESU, a Hyperledger project, in private networks (QBFT, IBFT, CLIQUE) using Hyperledger Caliper. This project aims to identify the strengths and weaknesses of BESU in terms of maximum transactions per second, latency, computation power, hard disk space, etc. Additionally, this project aims to add support for more complex and well-known workloads like ERC20, ERC721 in Caliper, which are used by general Ethereum users. This project will provide valuable insights into the performance of BESU and will help developers optimise it for better performance. Learning Objectives Through this project, the mentee will: - Develop skills in benchmarking and performance analysis of blockchain networks - Gain experience in working with Hyperledger Besu and Hyperledger Caliper - Learn to add support for new workloads in Caliper - Improve their programming skills by working on a real-world open-source project - Learn to write technical research reports and documentation. Expected Outcome The expected deliverables of this project are: - A detailed report on the performance of BESU in private networks (QBFT, IBFT, CLIQUE) - A set of benchmarks for BESU in private network with different configurations - Support for ERC20, ERC721, etc workloads in Hyperledger Caliper - Documentation on how to use the benchmarking tool and the new workloads.
Vitess does not yet have support for collations and character-sets. So, to compare varchar strings Vitess needs to rely on [WEIGHT_STRING](https://dev.mysql.com/doc/refman/5.7/en/string-functions.html#function_weight-string) function for now. As per MySQL documentation, WEIGHT_STRING is a debugging function, meant only for internal use. Having the ability to compare strings using collation and character set support we will be able to better implement ORDER BY, GROUP BY, JOIN. It will also allow us to leverage more advanced join techniques than what we currently implement.