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.
Prometheus recently [announced the second version of it's remote-write protocol](https://prometheus.io/docs/specs/remote_write_spec_2_0/), with support for new features on top of performance and cost savings. The work to be done is contribute support for this new protocol in the OpenTelemtry-Collector-Contrib repository, more specifically to the `prometheusremotewriteexporter` component. Expected Outcome: `prometheusremotewriteexporter` component with support for PRW v2.
The Solang Solidity Compiler is a new compiler project, which compiles Solidity to wasm or bpf. The compiler does not yet detect if a variable is used before it is assigned, or detecting that a value set is never used. For example: For example: contract test { function f(bool condition) public return (int) { int x; int y = 5; if (condition) { x = 102; } return x; } } This code has two problems: y is never used, and the value of x might be returned without it being given a value. In compiler theory this is done with reaching definitions. Solang already has an implementation of reaching definitions for the constant propagation pass, which will have to be generalized. Unused variables should be removed from the generated code. Secondly, implement a common subexpression elimination pass, which also uses the same reaching definitions implementation, to ensure subexpressions can safely be substituted. Learning Objectives 1) learn how to be a positive collaborator and contributor in an active open source project. 2) Learn how to work within the Hyperledger open source ecosystem and culture. 3) Understand smart contracts and the Solidity language 4) Gain a greater understanding of compiler optimizations and compiler theory Expected Outcome 1) Solang gives errors when undefined variables are used 2) Solang gives warnings when variables are not used, and removes them from the generated code 3) Solang does a common subexpression elimination pass
Here in we propose to develop a set of Zowe plugins for the IntelliJ family of development environments. This will ensure uniform user experience, while adding the possibility to work in their favorite development environment. The plugins will share a common foundation to interface with the IntelliJ platform SDK and to access the Zowe resources through Zowe API ML.
The rapid advancement of AI has led to the widespread application of deep learning models across various fields. However, the resource demands for model inference tasks can fluctuate significantly, especially during peak periods, posing a challenge to the system's computing capabilities. To address this varying load demand, we propose an elastic inference solution leveraging KubeEdge and Horizontal Pod Autoscaling (HPA) to enable dynamic scaling of inference tasks. By utilizing KubeEdge, we can distribute inference tasks across different edge devices and cloud resources, achieving efficient resource utilization and task processing. Expected Outcome: - Based on kubeedge to complete an elastic scaling AI inference example - Based on kubeedge and sedna to complete the joint inference task elastic scaling development and output example - Output blog Recommended Skills: - KubeEdge and its subproject Sedna frameworks. - Experience in deploying and managing Kubernetes, including configuring and tuning the HPA mechanism. - Expertise in developing and tuning deep learning models. - Programming experience, particularly in Python and Go.
The goal of this project is to get syzkaller, a coverage-guided OS kernel fuzzer, working under FreeBSD/RISC-V. As syzkaller is written mostly in Go, the first step is to ensure that Go is able to compile syzkaller. Previous work can be harnessed from two projects to make this tractable. First, Go has a RISC-V port targeting GNU/Linux, and second, the CHERI project has a FreeBSD/mips port of Go. The next step is to add FreeBSD/RISC-V support to syzkaller itself. A work-in-progress patch for FreeBSD/arm64 support can be used as a template. Two bonus tasks are: 1. upstream Go support for FreeBSD/RISC-V to the Go Project, and 2. begin fuzzing system calls under FreeBSD/RISC-V. Syzkaller is flexible enough to target OS interfaces other than system calls. For example, it has been used to fuzz the Linux USB stack and has found dozens of bugs in the USB subsystem alone. The details are complicated, but the idea is simple. 1. Generate a program, which invokes one or more system calls. 2. Run the generated program. 3. Check to see if the system diagnosed an error. - If not, collect kernel code coverage information and decide whether to try iterating upon the previous test program, or start anew. - If so, collect information about the crash and try to discover a minimal test case that triggers the crash. The mentors will have weekly meetings with the mentee to discuss progress and strategies for overcoming any challenges.
The Giving Chain is a Social Impact project created by the Hyperledger Princeton Meetup. The Purpose of the project is to decentralize local charity giving by creating the Giving Chain and the R2D application. The application will use participants cell phones to create an asset to be donated. The R2D (Recipient to Donor) then notifies the participant in the giving chain that an asset has been created and ready to be donated. The asset is then track till it is received by someone with need. This donation system lets donors track donation as well as creating a dignified way in which people can receive assistance. Learning Objectives 1) Create a supply chain blockchain. 2) Examine the relationships needed to create a Social Impact Project Expected Outcome An operational blockchain that will revolutionize local charity giving. can also be adapted for targeted disaster relief
Istio extends Kubernetes to establish a programmable, application-aware network. Working with both Kubernetes and traditional workloads, Istio brings standard, universal traffic management, telemetry, and security to complex deployments Istio does not support HTTPs based metric scraping for control plane, gateway, and Envoy sidecar metrics This could have some security related consequences: - An attacker might find some sensitive information that they can use for their advantage. For example, Envoy /stats endpoint can be used to enumerate all upstream services in the cluster. - In theory an attacker could masquerade the metrics endpoint(s) and inject fake data to monitoring systems, in order to e.g. hide an ongoing attack, confuse the system to autoscale up/down etc. It would be nice to protect the metrics endpoints with TLS, using mutual authentication. While this feature is a big one covering multiple components, the easiest component alone is intended to be covered as part of this internship. Expected Outcome: - Implement HTTPS metrics for ztunnel component - Add unit tests and integration tests for the feature - Add documentation for the functionality
Enhance tremor with connectors for the Google Cloud Platform
After WasmEdge provides an experimental API, WASI Socket, for supporting Berkeley Sockets API in Wasm. WasmEdge enabled a new way to open a new socket, listen to an existed socket, and send and receive data. Moreover, it will be nice if we can do more things in the related features such as SSL support. To achieve this feature, one possible way is to compile the OpenSSL library to Wasm and link it as a library. However, the performance may be not good, because all the computation jobs are done at the wasm level. Here is an alternative way, instead of the previous one, we can wrap the OpenSSL library to Wasm external functions. For example, binding `ssl_connect` to `(import "openssl" "ssl_connect" ... )`. Unfortunately, this is not an easy way to do it. To simply the workload, we decide to implement the WASI-crypto proposal first, and then use this proposal to make the above things happen.
When `urunc` is used together with a block-based snapshotter, it can take advantage of block-device backed container root filesystem and pass it directly to the sandbox as a disk image. This approach avoids filesystem conversion and enables efficient access to the container root filesystem. However, in order to spawn the sandbox, urunc requires access to the guest kernel and the initrd (if present). Since these files are part of the container rootfs, `urunc` must first extract and store them elsewhere before attaching the block-based root filesystem to the sandbox. As a result, this process introduces unnecessary file copies and additional I/O overhead. A more efficient approach is to leverage read-only (view) snapshots. Instead of copying files, `urunc` could request a read-only snapshot of the container root filesystem and mount it separately. The kernel binary and other required artifacts could then be read directly from this snapshot without modifying or duplicating data. Since view snapshots simply redirect read requests to the underlying snapshot layers, this approach is expected to introduce little to no additional storage overhead while simplifying the runtime flow. - Expected Outcome: - A document explaining block-based snapshots in containerd, along with the respective APIs to snapshot creation and management. - An implementation in `urunc` that requests and mounts a read-only snapshot of the container root filesystem. - Evaluation of performance
Monitor and troubleshoot transactions in complex distributed systems
Karmada dashboard now supports one-time metric retrieval, but it is difficult to observe the status of multi-clusters with one-time metric retrieval. Therefore, we would like to implement a lightweight metric collection capability to collect Karmada metrics and visualize them on the Karmada dashboard. This will allow cluster administrators to quickly get the status of the clusters and solve problems within the clusters. Expected Outcome: - Metric Collection and Storage Design Document - Query Analysis Interface & Front-end Visualization
WasmEdge provides several AI frameworks as WASI-NN plugins to enable the power of AI/LLM applications for developers and users. We are always eager to add new backends to improve coverage of all models and hardware. BitNet.cpp, released by Microsoft, offers the ability to run 1-bit LLMs quickly without a GPU. We would like to support this framework so that people with limited resources, such as CPU-only hardware, can enjoy the amazing world brought by LLMs. Expected Outcome: i. A new WASI-NN plugin supports BitNet. ii. Use the pure C++ interface from BitNet without any Python dependencies. iii. The plugin must run the model listed in the BitNet repository, e.g., BitNet b1.58 2B4T - Scaling Native 1-bit LLM. iv. A tutorial and example for demonstration. v. A CI workflow for building, testing, and releasing the built assets.
Blockchain Explorer is a GUI tool that allows users to view blocks, transactions, nodes, channels, chaincodes and other associated information about the blockchain network. The aim of this project is to enhance the existing application in-terms of new features and uplift the user-interface with the robust design. Blockchain explorer uses fabric-sdk to get the details from the fabric network and stores the data in the postgres database, which is later used by the explorer UI. The developers will get a chance to get involved in the entire software development life cycle with the proposal-implementation of new features, review the peer developed code, write the unit test cases, refining the existing code efficiently to adhere to the coding standards and much more.
Tenants in Thanos Receivers currently get one external label which indicates their tenant ID. We would like to implement attaching arbitrary external labels to each Thanos Tenant. This functionality is useful for various different use cases, such as improving performance when querying data for tenants which share the same labels.
Fablo is a tool to generate the Hyperledger Fabric blockchain network and run it on Docker. It's main goal is to provide a super-easy start with Hyperledger Fabric. It has a declarative approach - a whole network is described in a single file. Right now only the Docker environment is supported and we want add support for Kubertnetes Operators. Participating in the project will allow you to gain significant experience with Hyperledger Fabric network lifecycle and Kubernetes Operators. You will work with a "translation" of the current Docker-backed flow to Kubernetes. The expertise gained with working on the project is a good start in a broad range of professional careers related with Hyperledger Fabric and/or Kubernetes. It is also a great warmup before Certificated Fabric Administrator and for Kubernetes certifications. Fablo generates Docker compose file and some bash scripts for automation of the network configuration. We want to add an option to generate network configuration for Kubernetes Operators. We expect following outcome: - Fablo is able to generate YAMLs needed for K8S deployment. IIt can be implemented as a single YAML file deployed by single organization (minimal). It can be also split for multiple organizations for independent deployments (nice to have) - Fablo supports current Docker features for K8S (like, up, down, prune, chaincode upgrade.). The scope of supported features is flexible and depends on the work required for adding basic support for K8S.
LLM is a hot topic, there are more and more frameworks to make the execution of LLM faster. WasmEdge already integrated the llama.cpp (https://github.com/ggerganov/llama.cpp) as one of the backend. And we want to bring more. MLX (https://github.com/ml-explore/mlx) is an array framework on Apple silicon created by Apple machine learning research. With MLX, we believe it can have a huge improvement on macOS. Expected Outcome: A new plugin provides a MLX WASI-NN (https://github.com/second-state/wasmedge-wasi-nn) backend, a test suite for validating the plugin, documents and examples for explaining how to use the plugin.
This mentorship builds on the ""Sliderule"" Encoder and Decoder Cheat Sheets project, which is a highly visual and condensed view of the information contained in the RISC-V specification documents for consultation and education purposes. The sliderules are especially designed to facilitate manual encoding and decoding of assembly, placing instructions coherently in the binary address space. This original project was compiled by hand on a Google Sheets document and later exported to PDF: this method has the advantage of producing aesthetically pleasant results, but it is slow to create and expand, error prone, non interactive and version controllable only in a very limited way. The general goal of this mentorship consists in extending the information contained in the slide rule to RV64GC and obtaining a web page that interactively shows subsets of the sliderules to the user thanks to an information selection interface and is able to export PDFs from it. The main goal is to create a tool that serves as an education oriented consultive tool that documents the RISC-V instruction set in a more user-friendly way. The project shall be deployed from a GitHub repository.
AMD chips, with their powerful x86 architecture, exceptional computing performance, and advanced NPUs, demonstrate significant potential in fields such as industrial automation, in-vehicle systems, and high-performance edge computing. Introducing AMD's robust general-purpose and heterogeneous computing capabilities into the KubeEdge ecosystem is crucial for handling increasingly complex and latency-sensitive edge AI applications.However, the deep integration, performance optimization, and best practices between KubeEdge and AMD's high-performance edge platforms—particularly their built-in NPUs and other hardware acceleration units—still require systematic exploration and validation. This project aims to establish a complete link between KubeEdge and AMD edge nodes, building a comprehensive edge computing solution from hardware deployment to NPU acceleration, thereby greatly enriching KubeEdge's hardware ecosystem. Expected Outcome: 1. Debug and support KubeEdge edge nodes running on AMD chips 2. Successfully deploying and managing edge application Pods on AMD-based edge nodes 3. Scheduling and managing AMD NPU resources through KubeEdge to achieve performance acceleration for edge AI inference applications. 4. Implement monitoring and metric collection for nodes, applications, and NPUs 5. Using KubeEdge to achieve the complete platform setup, configuration, and management from the cloud to AMD edge nodes 6. Complete hardware compatib.....
WasmEdge currently offers three installers—v0 (deprecated shell script), v1 (Python-based, Linux/macOS only), and v2 (bash-based, limited functionality). A new cross-platform installer, wasmedgeup (https://github.com/WasmEdge/wasmedgeup), is being developed to unify installation across Linux, macOS, and Windows, simplifying setup and managing versions, dependencies, and hardware detection. Mentees need to implement these key features include uninstall commands, plugin management, and automatic system capability detection. Expected Outcome: 1. Implement the remaining features listed above in wasmedgeup (https://github.com/WasmEdge/wasmedgeup). 2. A document describing how to use. 3. A CI workflow for verifying these new features and ensuring that they can be built and tested on Linux (Ubuntu, Fedora), macOS, and Windows.
While generating Package Repository kctrl to create the tar version of the Package Repository instead of pushing the OCI Image to a registry. - Expected Outcome: - Proposal containing design discussions and options considered.
Ianvs serves as the KubeEdge SIG AI distributed benchmark toolkit. As more and more contributors running, KubeEdge Ianvs now has 25 examples, and the number is still increasing. KubeEdge Ianvs then faces mounting usability issues due to dependency evolution and validation mechanisms. As Python versions, third-party libraries, and Ianvs features advance, partial historical examples fail to execute. This has led to surging user-reported Issues from confused contributors, untested PRs breaking core functionality of legacy features, and severely outdated documentation misaligning with actual capabilities. Without systematic intervention, the example risks becoming obsolete for edge-AI developers and especially newcomers. We then try to resurrect Ianvs’ usability with a comprehensive example restoration. - Expected Outcome: - Diagnose & fix bugs across examples, including dependency manifests, license scan, and runtime configurations. - Documentation Modernization, including revamp tutorials with reproducible step-by-step guides, publish developer-focused debugging playbooks for common failures. Write and upload the corresponding blog to the KubeEdge Website. - Advanced: Build a CI pipeline testing examples with GitHub Actions against multiple Python versions, critical Ianvs/upstream updates, and block PRs that break validated examples
OpenELB is an open-source load balancer implementation designed for exposing the LoadBalancer type of Kubernetes services in bare metal, edge, and virtualization environments. Currently, OpenELB supports the BGP protocol. However, the BGP policy is not fully supported in OpenELB. Therefore, based on the BGP protocol, OpenELB is supposed to support the BGP policy to enable leveraging the GoBGP policy feature for controlling the route advertisement.
Advance the cloud native playground in which any CNCF project can be explored. Meshery’s genesis is that of helping teach people about cloud native technology and enabling to operate various types of cloud native infrastructure confidently. The proposed project is aimed at furthering this mission by infusing multi-user collaboration as a pervasisve feature so that users can learn together in a running instance of Meshery.