WasmEdge

Term 3 · Sep-Nov · 1 project

• Support for the Wide Arithmetic Proposal

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  Add support for the WebAssembly Wide Arithmetic proposal to WasmEdge by implementing the i64.add128, i64.sub128, i64.mul_wide_s, and i64.mul_wide_u instructions. These instructions enable efficient 128-bit addition and subtraction, as well as signed and unsigned 64×64-bit widening multiplication. Since this is not a large proposal, the mentee must implement it in all execution modes, including interpreter, JIT, and AOT.

  • C++
  • WebAssembly
  • LLVM

Term 2 · Jun-Aug · 1 project

• Memory alignment in WASM instructions

  LFX Mentorship · Listed in the official cohort

  @q82419Source IssueLFX portal

  Although WasmEdge checked the memory alignment when accessing the memory instances in WASI functions, the same situation occurs for instructions which would access the addresses on memory instances. For the pointer types, the offset for load/store from/to memory instances should be aligned as 4 in WASM32. In this mentorship, the mentee should collect all the possible situations for alignment checking in WASM instructions, and resolve the related issues.

  • C++
  • WebAssembly
  • Git workflows

Term 1 · Mar-May · 3 projects

• Enable JIT mode support for per-function compilation

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  WasmEdge's JIT mode attempts to compile the entire module before execution, which also includes compiling unused functions in the specific workload. To reduce compilation time and improve performance, we aim to enable compilation on a per-function basis, focusing only on those functions actually used in the workload.

  • C++
  • WebAssembly
  • LLVM
  • JIT

• Extend sub-command of WasmEdge CLI tool

  LFX Mentorship · Listed in the official cohort

  @q82419Source IssueLFX portal

  WasmEdge command line tool currently supports only the sub-command about run and compile the WASM files. As a WebAssembly runtime tool, it's welcome to have more functions about verifying the WASM files. In this mentorship, we expect the mentee to plan and implement the functionality of WasmEdge command line tool about parsing, validating, and instantiating WASM files, which developers can do with WasmEdge C API.

  • C/C++
  • WebAssembly
  • GitHub workflows

• Module instance dependency tree in WASM store

  LFX Mentorship · Listed in the official cohort

  @q82419Source IssueLFX portal

  It's common that there are several modules and linking when running a WebAssemly program. WasmEdge provides the APIs to handle the cases about loading and importing the WASM binaries and register the module instances into store in runtime. But in some complicated cases, the dependencies between module instances occurs. There may be requests to unregister and delete the module instances in store to release the space. In that case, the dependency of module instances should be considered to prevent from causing crash after deleting a module instance. In this mentorship, we expect the mentee to implement the dependency tree and the methodology to handle the module deletion in WasmEdge runtime.

  • C/C++
  • WebAssembly
  • GitHub workflows

Term 3 · Sep-Nov · 4 projects

• Implement the remaining features of wasmedgeup

  LFX Mentorship · Listed in the official cohort

  Source IssueLFX portal

  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, 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.

  • Rust
  • GitHub workflows
  • Cross-platform development

• Pointer alignment checking for WASI host function arguments

  LFX Mentorship · Listed in the official cohort

  @q82419Source IssueLFX portal

  WasmEdge implemented a series of WASI host functions to support the official WASI APIs. There are some arguments of WASI APIs are in pointer types. According to the WASI document, the pointer values are expected to be aligned to the alignment of their pointee type, otherwise the the function shall trap. In this mentorship, the mentee should check all functions of WASI interface in WasmEdge, and implement the alignment checking of pointer type arguments.

  • C/C++
  • WebAssembly
  • GitHub workflows

• Rust Coder for Claude Code

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  This is a continuation of our past two LFX mentorship projects -- the Rust Coder. Users of Rust Coder, which was originally a chatbot and then an MCP server, have told us that they wanted a modern approach like Claude Code. A new focus would also be to port existing Python / C++ projects to Rust, instead of creating Rust projects from scratch. This new proposed LFX mentorship project will 1 Fork or add to the open-source Claude Code project 2 Create new workflows to ask the user to import Python / C++ projects, make plans for how to port, and ask the user for preferred Rust crates 3 Use MCP to add Rust-specific prompts, knowledge base search tools, web-based documentation import tools etc 4 Use open source coding models to evaluate the results

  • Rust
  • Python or C++
  • Vibe coding tools (e.g.
  • Claude Code
  • Qwen Coder etc)

• Support the Responses API in Llama Nexus

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  The llama nexus project is an API proxy to provide OpenAI-compatible and unified API endpoints for multiple downstream API servers, including LLamaEdge API servers running open-source LLMs. Currently, the Llama Nexus supports the stateless /chat/completions API endpoint for LLMs. We would like to expand this to support the /responses stateful API from OpenAI as well. In particular, we aim to implement support for MCP Code interpreter Web search File search Browser use (optional)

  • Rust
  • OpenAI API
  • MCP Rust SDK

Term 2 · Jun-Aug · 4 projects

• Create an MCP-based AI agent to help LF certificate prep

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  You will create an AI agent based on open-source Large Language Models (LLMs) running on the CNCF WasmEdge runtime and an MCP server. The application will tie together key components in a modern AI agent stack to create a useful application. The AI agent will ask, answer, and explain practice questions for a specific tech certification program. It enables students to study for the certificate tests more effectively.

  • AI agent concepts
  • LLM and tool calls
  • Running open-source LLMs locally
  • Running MCP servers
  • Rust
  • Python

• Port WasmEdge and the WASI-NN ggml backend to the s390x platform

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  WasmEdge provides cross-platform support for amd64 and arm64 for executing AI/LLM applications. We would like to support as many new hardware platforms as possible, so developers and users will no longer need to worry about the actual hardware. All they need to do is develop their AI agent or LLM applications once and deploy their services anywhere. For more information, please check the upstream issue.

  • C++
  • s390x
  • LLVM

• Support bitnet.cpp as a new WASI-NN plugin

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  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.

  • C++
  • WASI-NN
  • GitHub workflows
  • LLMs

• Use Runwasi with WasmEdge runtime to test multiple WASM apps as cloud services

  LFX Mentorship · Listed in the official cohort

  @CaptainVincentSource IssueLFX portal

  With WasmEdge serving as one of Runwasi’s standard runtimes, and as our C++-implemented library continues to evolve, we also need a verification process integrated into Runwasi to streamline and validate the stability of both container and cloud environments.

  • Rust
  • C++
  • GDB
  • git / github workflow
  • shell script

Term 1 · Mar-May · 4 projects

• Create a Japanese translation agent for CNCF videos

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  WasmEdge is a cross-platform and lightweight runtime for AI models. It can run a variety of GenAI models, such as LLM, whisper (voice to text), and GPT-SoVITS (text to voice) on your own computers. By combining those 3 models together, developers in the WasmEdge community has created “video translation” applications that can translate video and audio content into another language. One such application is VideoLangua.com In this mentorship, we would like to build a Japanese translator agent that are specifically tailored to CNCF technical content.

  • The mentee must speak Japanese fluently.
  • He or she needs to be familiar with technical content in CNCF videos.
  • He or she should also be familiar with GenAI APIs (eg OpenAI API) and be able use PyTorch.

• Implement a new WasmEdge installer in Rust

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  Create a new tool in Rust that provides: Support cross-operating systems, including Linux(amd64 and aarch64), macOS(Intel models and Apple Silicon models), and Windows(amd64); Simplifies installation of the WasmEdge runtime and its plugins in a single tool called wasmedgeup; Automatically handles versioning, dependencies, OS/ARCH detection, and ensure the same user experience across operating systems and architectures. For more details, please refer to the upstream issue.

• Implement component model's validator

  LFX Mentorship · Listed in the official cohort

  @dannypsnlSource IssueLFX portal

  The current validator of component model inside of WasmEdge only check nested module and ensure VM can run the nested modules without problem, but the validations from component model are mostly skipped.

  • Since component model proposal separate their validation spec
  • one should able to
  • find requirements from https://github.com/WebAssembly/component-model/tree/main/design/mvp
  • Implements it in C++.

• Improve the WasmEdge-based Rust coding assistant for inference-time scaling

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  In a previous LFX mentorship project, we have created an LLM-based coding assistant grounded in Rust programming language skills. We aim to further improve the Rust coding assistant by incorporating inference-time compute that utilizes the Rust compiler for feedback. One of the greatest advantages of Rust is its powerful and strict compiler, and the detailed error message generated by the compiler. The Rust compiler could give valuable feedbacks to code generating LLMs to improve the code quality.

  • Rust
  • LlamaEdge
  • LLMs like ChatGPT
  • Coding assistant like GitHub Copilot

Term 3 · Sep-Nov · 4 projects

• Create a Wasm-based LLM app for financial analysts

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  We would like to develop an LLM-based financial data analytics application using open source LLMs, embedding models, the LlamaEdge application server, vector databases, and data processing tools. It will provide an open source "template" and showcase "best practices" for similar applications in this fast growing application area.

  • Python
  • LlamaEdge -- see a tutorial
  • ChatGPT and LLMs
  • The RAG process
  • Rust (optional)

• Create an LLM app with deep understanding of a GitHub repo

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  LLM assisted coding is one of the most promising application areas for modern AI. It will also have profound impact on open source software development. As many projects have demonstrated, "feeding" an LLM with contents from a GitHub repo will make it better at understanding coding tasks for this project. In this project, we will take a modern approach to build LLM agents based on LlamaEdge / WasmEdge, and supplement it with deep knowledge of open source projects on GitHub. The goal is for the agent to answer questions and solve problems raised by the open source community.

  • Rust
  • LlamaEdge -- see a tutorial
  • ChatGPT and LLMs
  • The RAG process

• Fix bugs found by fuzzer

  LFX Mentorship · Listed in the official cohort

  Source IssueLFX portal

  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.

  • git
  • C++
  • WebAssembly

• WASM Serializer with new proposals

  LFX Mentorship · Listed in the official cohort

  @q82419Source IssueLFX portal

  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.

  • C++
  • WASM
  • git

Term 2 · Jun-Aug · 4 projects

• Create a search-enabled API server for local LLMs

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  WasmEdge is a lightweight inference runtime for AI and LLM applications. The LlamaEdge project has developed an OpenAI-compatible API server and a server-side RAG app based on WasmEdge. In this project, we aim to use the LlamaEdge components to build a new API server that incorporates real-time Internet search results into LLM answers.

  • Rust language
  • LlamaEdge

• Enabling LLM fine tuning in the WASI-NN ggml plugin

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  WasmEdge is a lightweight and cross-platform runtime for LLM applications. It allows developers to create LLM apps on a Mac or Windows dev machine, compile them to Wasm, and deploy them on Nvidia machines without any changes to the binary app. It achieves application portability across CPUs and GPUs by supporting a W3C standard API called WASI-NN, which abstracts GPU-related AI functions as high-level APIs. At this stage, however, only inference functions are supported. In this project, we aim to support fine-tuning features in WasmEdge. It will improve the developer experience for WasmEdge-enabled LLM tools. To achieve this, we plan to extend the current WASI-NN spec by adding a set of extra APIs, and then implement them by delegating to corresponding functions in llama.cpp embedded in the WasmEdge GGML plugin.

  • C++
  • WebAssembly
  • LLM fine-tuning

• Finetune LLM models for Rust coding assistance

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  WasmEdge is a lightweight inference runtime for AI and LLM applications. We want to build specialized and finetuned models for WasmEdge community. The model should be supported by WasmEdge and its applications should benefit the WasmEdge community. In this project, we will build and compare two finetuned model for Rust coding assistance. A code review model. It aims to be a new backend for the PR review bot we currently use in the community. A QA model. It should be able to answer user questions about the Rust language and provide explanations. Our goal is to provide an alternative to our Learn Rust app.

  • Rust language
  • ChatGPT and Claude
  • LlamaEdge
  • llama.cpp

• Support piper as a new backend of the WASI-NN WasmEdge plugin

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  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, A fast, local neural text-to-speech system in C++ as a new WASI-NN backend.

  • C++
  • Wasm

Term 1 · Mar-May · 4 projects

• Integrate burn.rs as a new WASI-NN backend

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  WasmEdge supports PyTorch, TensorFlow Lite, llama.cpp, and more NN backend. Burn.rs is a new deep learning framework built using Rust. The portability, flexibility, and compute efficiency are important to Wasm. That's why we would love to have burn.rs as a new WASI-NN backend.

  • Rust
  • Wasm

• Integrate Intel Extension for Transformers as a new WASI-NN backend

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  LLM is a hot topic, there are more and more frameworks to make the execution of LLM faster. WasmEdge already integrated the llama.cpp as one of the backend. Running LLM with CPU only is huge for those users who don't have GPU. We would like to integrate Intel Extension for Transformers as a new WASI-NN backend to provide a faster CPU inference performance.

  • C++
  • Wasm

• Integrate MLX as a new WASI-NN backend

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  LLM is a hot topic, there are more and more frameworks to make the execution of LLM faster. WasmEdge already integrated the llama.cpp as one of the backend. And we want to bring more. 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.

  • C++
  • Wasm

• Integrate whisper.cpp as a new WASI-NN backend

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  WasmEdge supports PyTorch, TensorFlow Lite, llama.cpp, and more NN backend. Dealing with the Voice to Text is a big thing that we want to achieve. To make it possible, we would like to integrate whisper.cpp, a port of OpenAI's Whisper model in C/C++ as a new WASI-NN backend.

  • C++
  • Wasm

Term 3 · Sep-Nov · 4 projects

• Add matrix operations for OpenCVMini-Wasm-Plugin

  LFX Mentorship · Listed in the official cohort

  @dannypsnlSource IssueLFX portal

  WasmEdge is a WebAssembly runtime that supports both interpreter and ahead-of-time modes. To expand its capabilities, WasmEdge provides a plugin system that helps people attach more existing software. OpenCVMini is one of them, intended to help users get a limited OpenCV interface. With this feature, AI inference will have more flexible helper functions for pre-processing and post-processing. In this mentorship, we aim to add more OpenCV capabilities to the WasmEdge environment.

  • C++
  • Basic understanding of the Wasm spec
  • Basic understanding of using OpenCV
  • Basic understanding of writing Rust programs

• Create a ffmpeg plugin

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  The mediapipe-rs project provides a Rust SDK to support mediapipe AI models. The SDK provides utility functions to pre-process application data (such as images, audio and video) into TFLite / PyTorch formats, and convert the inference results back into application data. In order to accomplish this, the mediapipe-rs project has made extensive use of the ffmpeg library. It compiles ffmpeg to Wasm and then builds it together with the application binary. However, the issue with this approach is that those Wasm-compiled ffmpeg functions are slow. We believe a better approach is to create a ffmpeg plugin for WasmEdge, and allow Wasm applications to call native ffmpeg functions as host functions.

  • C/C++
  • ffmpeg
  • Rust
  • WebAssembly

• Create a Rust crate for YOLO model

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  With WASI-NN plugins, WasmEdge is well-suited for running AI applications. However, AI applications are more than just the model. The application must pre-process data (such as images, audio and video) into TFLite / PyTorch formats, and convert the inference results back into application data in post-processing. Here are some examples: The mediapipe-rs project provides a Rust SDK to build applications for the mediapipe AI models. The llama2.c application is compiled to Wasm and runs in WasmEdge to generate text using the llama2 models. In this project, we would like to build a Rust SDK to support applications on the YOLO models.

  • OpenCV
  • Rust
  • Tensorflow / Pytorch
  • WebAssembly

• Support AOT mode in proxy-wasm

  LFX Mentorship · Listed in the official cohort

  @q82419Source IssueLFX portal

  WasmEdge is a WebAssembly runtime that supports both interpreter and ahead-of-time modes. For proxy-wasm support, WasmEdge only provides the interpreter mode currently. Such as the other runtimes, WasmEdge should be able to support the AOT mode for better performance. In this mentorship, the mentees will help the WasmEdge project to complete the AOT mode in proxy-wasm proposal and write the docs for examples of running with proxy-wasm.

  • C++
  • Basic understanding of bazel

Term 2 · Jun-Aug · 4 projects

• A stream log processing framework for WasmEdge

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  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.

  • Proficient in the Rust programming language
  • Familiarity with MySQL
  • Kafka
  • ElasticSearch
  • and FileBeat
  • Familiarity with Kubernetes and related container management tools
  • +1

• Serialization Completion

  LFX Mentorship · Listed in the official cohort

  @q82419Source IssueLFX portal

  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 of the WasmEdge repo.

  • C/C++
  • WebAssembly

• Support Tensorflow and PyTorch in WasmEdge’s Python runtime

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  In this project, you will incorporate WasmEdge’s NN (Neural Network) extensions into the Python interpreter. WasmEdge provides C and Rust APIs for guest applications to access host functions in the underlying Tensorflow and PyTorch libraries. You will make those functions accessible from the CPython-based interpreter as Python wrappers. This way, Python applications can do lightweight AI inference on the WasmEdge container.

  • Proficient in C programming including creating dynamic libraries
  • Proficient in Python and machine learning programming. Basic understanding of WebAssembly and WasmEdge.

• zlib Plugin Support

  LFX Mentorship · Listed in the official cohort

  @q82419Source IssueLFX portal

  The zlib is required for compiling and running many existing C / C++ / Rust apps in Wasm. Most noticeably, it is needed in the Python port to Wasm. The VMWare Wasm Labs team is using a zlib port from Singlestore in their Python Wasm runtime. In WasmEdge, we could support the zlib host functions through our plugin system. This way, any existing zlib apps can be compiled to Wasm and runs inside WasmEdge.

  • C/C++
  • Rust
  • WebAssembly

Term 1 · Mar-May · 4 projects

• A Rust library crate for mediapipe models for WasmEdge NN

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  WasmEdge would like to build a Rust library crate that enables easy integration of Mediapipe models in WasmEdge applications. Each Mediapipe model has a description page that describes its input and output tensors. The models are available in Tensorflow Lite format, which is supported by the WasmEdge Tensorflow Lite plugin.

  • basic knowledge of Rust and experience in working with AI models and image processing.

• Streaming data processing with WasmEdge

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  WasmEdge would like to integrate WasmEdge as an alternative runtime for Fluvio. We would like to create a compile-time feature for the fluvio-smartengine crate. Once this feature is turned on, the compiler will choose to embed WasmEdge into the binary build using the WasmEdge Rust SDK.

  • working knowledge of the Rust language and WebAssembly Rust SDK

• Unified WasmEdge tools

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  WasmEdge provides two tools in the release assets: wasmedgec and wasmedge. However, providing multiple tools will make it too complicated to use. That's why we want a simple entry point, wasmedge. As its subcommands, all the tools above should be collected into this new tool.

  • C++ programming language
  • WebAssembly knowledge.

• WasmEdge C++ SDK

  LFX Mentorship · Listed in the official cohort

  @q82419Source IssueLFX portal

  WasmEdge provides C SDK as the based library and uses this to implement other languages SDK such as Golang, Rust, Java, and Python(developing). We would like to provide C++ SDK in this task.

  • C++ programming language
  • WebAssembly knowledge.

Term 3 · Sep-Nov · 4 projects

• Node API support for WasmEdge QuickJS

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  The WasmEdge QuickJS runtime is a secure, fast, and lightweight JavaScript runtime for cloud-native applications. Compared with more established JavaScript runtimes like Nodejs and Deno, the WasmEdge QuickJS runtime provides runtime isolation and security at a very low overhead. In order for WasmEdge QuickJS to be more widely adopted, it needs to support nodejs applications. WasmEdge QuickJS already supports NPM and CJS modules.

  • Javascript
  • Rust

• OpenCV SDKs for Wasm in WasmEdge

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  WasmEdge is a leading WebAssembly runtime for AI inference. It supports AI frameworks such as Tensorflow, OpenVINO and PyTorch. A compelling use case is computer vision applications on the edge. Computer vision applications need to pre-process images and videos into tensor formats before applying the AI model. They then often need to overlay the tensor results onto the original image. In our existing demos, we use the Rust image crate to process images. However, the crate only has limited features and is inadequate for many computer vision applications. In the Python-based computer vision applications, the image pre-processing is often done with the Python wrapper for OpenCV library. The OpenCV library itself is written in C and can be compiled into WebAssembly. We would like to create an OpenCV SDK that allows WebAssembly applications to call OpenCV functions.

  • C++
  • WebAssembly
  • Rust

• Porting OpenVINO on multiple platforms for the WASI-NN proposal in WasmEdge

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  The OpenVINO official release supports various platforms. WasmEdge supports the WASI-NN proposal with OpenVINO backend now, but only in Ubuntu 20.04. In this project, we want to porting and integrating the OpenVINO installation for the multiple platforms such as MacOS, Windows, or manylinux with the WasmEdge WASI-NN plugin.

  • C++
  • WebAssembly

• Support serialize and deserialize in WasmEdge

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  WasmEdge can load the WASM binary and instantiate into WASM module instances for execution. In an use case, we need to serialize the loaded WASM data structure back into the encoded WASM binary, or deserialize the serialized one into the WASM data structure in WasmEdge. With the serializing mechanism, WasmEdge can control the WASM binary wisely such as caching or snapshotting.

  • C++
  • WebAssembly

Term 0 · 2022 Summer (Jun-Aug) · 4 projects

• Create a Tokio-like async runtime in WasmEdge

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  One of the most important features of WasmEdge is its support for non-blocking network sockets. However, the current WasmEdge API for async networking is still cumbersome. Rust developers would prefer to use a Tokio-like async / await API for such tasks. But Tokio is multi-threaded and cannot run correctly in standard single-threaded WebAssembly. Yet, it is possible to provide a single-threaded Tokio runtime. Our goal is to create a WebAssembly compatible Tokio scheduler.

  • Rust
  • tokio
  • wasm

• Implement component-model proposal in WasmEdge

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  The component-model proposal merges and supersedes the Module Linking and Interface Types proposals. With this feature, WasmEdge can execute multiple modules wasm with Module Linking and and more flexible types with Interface Type.

  • C++
  • wasm

• Provide a wasm-compatible Rust TLS implementation

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  The WasmEdge networking socket API provides support for TCP and HTTP connections. But many web services today require HTTPS connections. That means we need to support TLS in WasmEdge. The Rustls crate is the most popular TLS implementation in Rust. However, Rustls is based on the Ring library, which cannot be compiled into WebAssembly. In WasmEdge, we now support the wasi-crypto spec. That allows us to compile the rust-crypto library into WebAssembly and run on WasmEdge. The goal of this project is to create a Rust TLS implementation based on rust-crypto.

  • Rust
  • wasm
  • crypto

• Support Durable Objects (DO) in WasmEdge

  LFX Mentorship · Listed in the official cohort

  @juntaoSource IssueLFX portal

  Durable Objects (DO) are persistent data objects available to applications at runtime. They can be stored in a persistent KV store or a data cache. DOs are important for stateful serverless functions. The Anna KVS project developed by UC Berkeley is an autoscaling KVS ideally suited for edge nodes. It is a good match for WasmEdge to support stateful serverless functions on the edge cloud. The goal of this task is to create Rust and JavaScript clients for Anna KVS using the WasmEdge socket API. It allows Rust-based WasmEdge applications to connect to Anna KVS, and store or retrieve DOs in the KVS. Note: A new Rust-based version of Anna KVS is going to be released soon. We will likely use the new version for this task. The network socket API for accessing the KVS will remain largely unchanged from the old version.

  • Anna KVS
  • Rust
  • wasm
  • JavaScript
  • Database

Term 0 · 2022 Spring (Mar-May) · 4 projects

• Enable OpenVINO backend for WASI-NN

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  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.

  • c++
  • OpenVINO

• Implement typed function references proposal

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  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. This proposal is one of the requirements for GC proposal. Typed function references proposal adds function references that are typed and can be called directly.

  • c++

• Improving the performance of running miniruby

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  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 is designed for the general purpose wasm runtime. However, when running miniruby, we found the performance is worse than other runtimes such as wasmtime, even after using the ahead-of-time compilation.

  • profiling tools
  • c++

• Improving the performance of running rustpython

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  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 is designed for the general purpose wasm runtime. However, when running rustpython, we found the performance is worse than other runtimes such as wasmtime, even after using the ahead-of-time compilation.

  • profiling tools
  • c++

Term 0 · 2021 Fall (Sep-Nov) · 4 projects

• Support WASI-Crypto proposal

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  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.

  • C++
  • Rust

• Support WASI-NN proposal

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  Machine Learning is a big topic nowadays. WasmEdge already provides a set of TensorFlow host functions to enable the ML inference in WebAssembly. However, these TensorFlow host functions are defined by us and they are just a Wasm function binding from the TensorFlow C API. Here comes a standard, the WASI-NN proposal provides a new way to perform neural network inferencing by using a runtime-provided implementation that can leverage host native optimizations, CPU multi-threading, or powerful hardware devices such as GPUs or TPUs.

  • C++
  • Rust

• Support Wasm-C-API proposal

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  The wasm-c-api proposal provides the C and C++ API for WASM runtimes. Even though WasmEdge already provided the C API, it's proper to implement the wasm-c-API proposal for the general C/C++ API. In the current status, we've already implemented the non-runtime data structures on the branch. Then, we need to finish the runtime implementation.

  • C++

• Support Wasm-Signature proposal

  LFX Mentorship · Listed in the official cohort

  @hydaiSource IssueLFX portal

  The wasm-Signature proposal is specifically about embedded digital signatures in WebAssembly modules, not about package/OCI signatures. When distributing WebAssembly modules, it will be nice if we can have a way to verify. To achieve this target, we choose a Wasm-Signature proposal as our implementation standard. With this proposal, WasmEdge can provide sign and verify features.

  • C++
  • Rust