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.
Using tried and true processes and tools, modernize a legacy COBOL application to take advantage of cloud, APIs and micro services. Document the process and results, enabling others to modernize their legacy COBOL applications.
WasmEdge is a WebAssembly runtime in both interpreter and ahead-of-time mode. However, WasmEdge only supports the binary format for the input WebAssembly file. To help the text format WebAssembly loader feature in the future, the implementation of serializing a WebAssembly module is necessary. In this mentorship, we hope the mentee should complete the serialization functions already in [the `dev/serialize` branch](https://github.com/WasmEdge/WasmEdge/tree/dev/serialize) of the `WasmEdge` repo. - Expected outcome: Complete the serialization functions of WebAssembly modules, such as the element segment and data segment encoding. Complete the WebAssembly instructions encoding. Generate the unit test data and pass the unit tests. >80% of code coverage for serialization.
Enhance Meshery's existing orchestration capabilities to include support for kro ResourceGraphDefinitions (RGDs) as first-class Meshery Models (https://docs.meshery.io/concepts/logical/models). This involves enabling Meshery to manage and orchestrate RGDs, similar to how it handles other Kubernetes resources. The project will also include generating support for ResourceGraphDefinition in Meshery's Model generator. Expected Outcome: Meshery will be able to orchestrate and manage kro RGDs. This includes the ability to deploy, configure, and manage the lifecycle of RGDs through Meshery. The Meshery Model generator will be updated to automatically generate models for kro RGDs, simplifying their integration and management within Meshery. This will be an officially supported feature of Meshery.
Kubescape's control library includes more than 200 controls, tests that codify Kubernetes best practices derived from the most prevalent security frameworks in the industry. Metadata in the controls is used to generate documentation pages in the ARMO website. This project will update this automation to make this control documentation available on kubescape.io. - Expected Outcome: A full set of documentation for Kubescape controls on kubescape.io. Stretch goals include better README-style documentation inside the repository, and documentation pages on how the controls, frameworks and tests relate.
Description: historically, the Jaeger backend used the OpenTracing API, with Jaeger's own Go SDK `jaeger-client-go`, for instrumenting its own internals for distributed tracing. Since Jaeger's SDKs have been deprecated, we want to upgrade the Jaeger backend to use the OpenTelemetry tracing API and SDK directly. - Expected Outcome: - Replace the use of OpenTracing API with OpenTelemetry - Remove `jaeger-client-go` and `jaeger-lib` as dependencies - Remove `opentracing-go` and `opentracing-contrib/*` as dependencies - Switch to standard instrumentation libraries where available (e.g. for HTTP, gRPC) - Rethink/rework `crossdock` integration tests to test end-to-end flow with OpenTelemetry data - Publish a blog post on medium.com/jaegertracing documenting the experience
Kyverno is a Kubernetes native policy manager that can be used in place of PodSecurityPolicies. OpenEBS helm charts currently set up PSPs for many of its Storage engines. This project is to convert PSPs into corresponding Kyverno policies. The OpenEBS storage engines also uses a custom admission webhook validator. The scope of the project can extend to replacing the custom validators with Kyverno policies.
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. Jaeger-v1 collector can serve sampling configuration to SDKs, and allows either static configuration (with hot reload) or adaptive sampling that continuously re-calculates the desired sampling probabilities. We need to enable all these capabilities in jaeger-v2. Expected Outcome: Support adaptive sampling in jaeger-v2
Hyperledger Cello aims to simplify the deployment and management of blockchain technology across various industries, offering a robust toolkit for creating, managing, and monitoring blockchain networks on demand. Currently, the project is facing an upgrade to Hyperledger Fabric version 2.5 LTS. This upgrade is critical for enhancing the platform's stability, security, and performance, addressing current limitations and opening new avenues for blockchain applications. Interns will contribute directly to Hyperledger Cello by addressing GitHub issues and enhancing the project's features and documentation. Their work will improve the ease of blockchain network management, making blockchain technology more accessible and efficient for users. A significant part of the mentorship involves upgrading Hyperledger Cello to support Hyperledger Fabric version 2.5 LTS. This includes integrating new features, ensuring compatibility, and contributing to the overall stability and performance of blockchain solutions deployed via Cello.
Support specifying the deletion propagation policy in cleanup policies and TTL-based cleanup. Expected Outcome: 1. Support specifying the deletion propagation policy in cleanup policies 2. Support specifying the deletion propagation policy with TTL-based cleanup
Since permissioned blockchain has been adopted widely in various industries, the need to integrate different permissioned blockchains rises up recently. The two core problems of this case are chain contract interoperability and transaction atomic. Many frameworks and solutions proposed currently are a bit complex. We introduced a lightweight protocol and reference implementation inspired by the ‘ServiceMesh’ pattern in the microservice integration area. Combine with a stateless off-chain relay and an extended on-chain contract development kit as a ‘SideCar’ for different permissioned blockchains. Contract developers can focus on writing business logic since the on-chain contract development kit uses an AOP(aspect-oriented programming) approach to delegate the contract interoperability. In addition it also provides a lock API for locking contract state which can be used in two-phase commit cases. The off-chain relay uses an event based architecture to coordinate different permissioned blockchains. Learning Outcome 1) Implement the on-chain contract development kit for Hyperledger fabric using JAVA. 2) Implement the on-chain contract development kit for Consensys quorum or Hyperledger Besu using Solidity. 3) Implement the off-chain relay plugin for Consensys quorum or Hyperledger Besu.
In KubeVela, we use [CUElang](https://cuelang.org/) to code the X-Definition. We want to support auto generation of multiple languages SDK from CUE, so that users can buidling KubeVela Application in their own language. This helps to adoptors to build platform based on KubeVela. - Expected Outcome: Support auto generation of multiple languages SDK from CUE, including Java, Typescript ,Python. This capability should be part of vela CLI command.
Jaeger has always supported Elasticsearch (ES) as an official backend. Unfortunately, the Go driver we are using, `olivere/elastic`, does not support ESv8 and not planning to release any new versions. Despite the licensing changes, Elasticsearch remains a popular choice and v8 support question often comes up. In this project we want to add official support for ESv8. However, we also want to take this opportunity to do a better alignment with the OpenTelemetry Collector, which already has an [ESv8 exporter](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/elasticsearchexporter), perhaps we can use it directly and minimize the amount of code. - Expected Outcomes: - Use OTEL ESv8 exporter from Jaeger, if possible, otherwise build internal implementation - Stretch goal: use ES data as the source for Jaeger SPM views
- Description: KubeVela currently have a variety of addons , including experimental options, that address scenarios such as Continual Delivery and observability. To further enhance the out-of-box functionality for users of KubeVela, we can offer additional useful addons. - Expected Outcome: 10+ eperimetal addons, clear documentation should be provided for enabling and using these addons, including examples of useful use-cases.
In this project, we aim to build a Rust-based log processing framework. Applications built on this framework will be compiled into WebAssembly and run in WasmEdge containers side by side with Linux containers and apps. The WasmEdge app collects logs from other containerized apps and then sends them to a streaming database or processing pipeline. - Expected outcome: * Create a Rust framework with 3 traits similar to the [`Transformer`](https://github.com/second-state/MEGA/blob/main/mega_etl/src/lib.rs#L99) trait in the [MEGA framework](https://github.com/second-state/MEGA). * The `Collector` trait abstracts operations needed for a log collector. * The `Transformer` trait abstracts the transformation algorithms that can be applied to the logs. * The `Destination` trait abstracts operations needed to send transformed to a streaming data pipeline or database. * Implement at least two `Collector`s. One for MySQL database binlog and the other for a generic log file in a Linux container in the same Kubernetes pod. * Implement at least two `Transformer` algorithms supported by [FileBeat](https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-overview.html). * Implement at least three `Destination`s. One for a Kafka queue, one for a Redis database, and the other for ElasticSearch. * Provide CI and demo test cases. * Provide documentation and tutorials.
KWOK (Kubernetes WithOut Kubelet) is a toolkit that enables setting up a cluster of thousands of Nodes in seconds. On the KWOK homepage (https://kwok.sigs.k8s.io/), we aim to document the technical outcomes of using KWOK. These outcomes represent the aggregation of some of KWOK's features to achieve a high-level technical goal. Currently, we have the following areas of focus: Chaos Testing, Performance, Simulation, and Scalability. Expected Outcome: A section of the KWOK website detailing these technical outcomes.
Meshery CLI is a powerful tool to manage all your cloud native resources, Meshery has internal capability called Registry to store and manage models, categories, component and relationship, presently Meshery’s v0.7 release allow users to view all this information from Mehery UI. We also need to expose Meshery’s registry capability through mesheryctl Expected Outcome: Design mesheryctl subcommands and flags for registering, listing, retrieving, updating, and deleting models, components and relationships. Implement validation and error handling for user input and API responses. Integrate with relevant Meshery APIs to interact with the registry backend.
We want to expand the scope of the CloudNativePG tests, introducing a full-fledged chaos testing framework that can be used to better validate the resilience, fault tolerance and recovery mechanisms of CloudNativePG. Expected Outcome: 1. Selection of a Kubernetes-native chaos testing framework (e.g., LitmusChaos or Chaos Mesh). 2. Design and automation of an initial set of chaos experiments covering common failure scenarios. 3. Integration of these experiments into CI/CD to ensure reproducible testing. 4. Collection of clear observability metrics (e.g., failover time, data consistency) to assess resilience and recovery. 5. Documentation and guidelines to help contributors create and run new chaos experiments safely.
Cluster API Provider AWS (CAPA) enables the creation of Kubernetes clusters in AWS with Cluster API. With increasing adoption of Cluster API (CAPI) in general and of CAPA we want to improve the supportability of CAPA, especially for production environments. The first part of this is to add telemetry/tracing using OpenTelemetry so that we can understand and visualize the flow of reconciliation within the provider. This will enable the project and its end users to understand the behavior of reconciliation (including API services called) and will help diagnose issues and performance problems. Expected Outcome: An implementation of OpenTelemetry in CAPA with associated documentation that has been released in a new version of CAPA.
This project continues the work initiated in the etcd - technical scope of the assessment (https://docs.google.com/document/d/1RTXffyDJ8hLoHl_Mo-frQheRQ-8QIVQJ6mqAw69zcP4/edit?pli=1&tab=t.0#heading=h.o524zy9jn6nn). The goal is to dive deep into etcd's architecture in depth by completing and publishing the self-assessment for SIG-Security review. The project has two key components: (1) collaborating with mentors, project maintainers, and Special Interest Groups (SIGs) to investigate etcd and kube-apiserver internals, particularly the lifecycle of requests and consensus mechanisms, and (2) updating and enhancing the etcd.io website (https://etcd.io/) documentation by creating new pages, refining existing content, and publishing blog posts to ensure the documentation reflects current architecture and best practices. Whether you're a new contributor, already active in the community, or simply curious about etcd, we welcome you to join this project! Expected Outcome: 1. Complete the etcd self-assessment draft currently in progress in this document (https://docs.google.com/document/d/1RTXffyDJ8hLoHl_Mo-frQheRQ-8QIVQJ6mqAw69) and prepare it for review by SIG-Security and etcd maintainers. 2. Publish the finalized self-assessment in the SIG-Security repository (see example format - https://github.com/kubernetes/sig-security/blob/main/sig-security-assessments/cluster-api/self-assessment.md)............
Integrate a new architectural component into Meshery: a workflow engine. This project involves shifting Meshery off of bitcask and off of sqlite over to postgres using gorm (golang). Interns will familiarize with concepts of orchestration engines, including chaining workflows, and content lifecycle management.
Description: [TestGrid](http://testgrid.k8s.io) is the test visualization tool attached to Prow to collate and display historical test results for the k8s and k8s-adjacent Expected Outcome: Create Lit-based view components for TestGrid (summary, index, etc.) that display data from the API. Implement Jasmine and Storybook testing for these components.
Microcks (https://microcks.io/) is a cloud native, open source tool under CNCF for API and microservices mocking and testing. This project aims to enhance the [Microcks Hub](https://hub.microcks.io/) by updating the existing sandbox environment or adding new hub entries to mock key APIs IT industry leaders use. The goal is to make it easier for developers to test and prototype integrations with popular APIs like GitHub, Twilio, Stripe, or Salesforce using Microcks. Expected Outcome: Participants can choose to focus on one or both of the following aspects: 1. Update and Refresh the Existing Sandbox: - Improve the sandbox environment provided by Microcks Hub for existing mock APIs. - Ensure compliance with the latest versions of existing APIs. - Enhance documentation, usability, and deployment mechanisms. 2. Add New Hub Entries for Key Industry APIs: - Develop mock entries for leading APIs like GitHub, Twilio, Stripe, or Salesforce, but we welcome any ideas... - Ensure the mocks cover essential endpoints and realistic request-response pairs. - Provide detailed examples and use cases to support integration testing.
As industrial manufacturing accelerates its digital transformation through advancements in robotics, adaptive production lines, and smart testing systems, cloud-edge collaboration has emerged as a critical enabler for deploying embodied intelligence in complex operational environments. Contemporary industry requirements for embodied intelligence now extend beyond basic task execution to encompass multimodal perception-decision integration, dynamic environment adaptation, and distributed device orchestration. Existing benchmarking frameworks exhibit limitations in evaluating scenario-specific embodied attributes inherent to industrial settings. This initiative leverages the KubeEdge-Ianvs collaborative AI framework, integrating domain-specific test datasets, simulation environments, and quantitative metrics to establish a certified industrial-grade evaluation infrastructure for embodied intelligence systems. Expected Outcome: 1. Develop an industrial-grade embodied intelligence dataset through systematic classification and reorganization of existing resources across four standardized task categories 2. Design standardized validation suites within KubeEdge-Ianvs 3. Deploy reference baseline algorithms using the developed validation suites to establish performance benchmarks within KubeEdge-Ianvs
Add new features to the kuttl application used by the Kyverno project to aid in its end-to-end testing process. - Expected Outcome: Kyverno's fork of kuttl has these enhancements allowing more and better test cases to be written.