YoMo Go

    YoMo is an open-source Streaming Serverless Framework for building Low-latency Edge Computing applications. Built atop QUIC Transport Protocol and Functional Reactive Programming interface. makes real-time data processing reliable, secure, and easy.

    Official Website: 🦖


    🌶 Features

    Low-latency Guaranteed by implementing atop QUIC QUIC
    🔐 Security TLS v1.3 on every data packet by design
    📱 5G/WiFi-6 Reliable networking in Celluar/Wireless
    🌎 Geo-Distributed Edge Mesh Edge-Mesh Native architecture makes your services close to end users
    📸 Event-First Architecture leverages serverless service to be event driven and elastic
    🦖 Streaming Serverless Write only a few lines of code to build applications and microservices
    🚀 Y3 a faster than real-time codec
    📨 Reactive stream processing based on Rx

    🚀 Getting Started

    1. Install CLI

    Note: YoMo requires Go 1.15 and above, run go version to get the version of Go in your environment, please follow this link to install or upgrade if it doesn't fit the requirement.

    # Ensure use $GOPATH, golang requires main and plugin highly coupled
    echo $GOPATH

    if $GOPATH is not set, check Set $GOPATH and $GOBIN first.

    $ GO111MODULE=off go get
    $ cd $GOPATH/src/
    $ make install

    YoMo Tutorial 1

    2. Create your serverless app

    $ mkdir -p $GOPATH/src/{YOUR_GITHUB_USERNAME} && cd $_
    $ yomo init yomo-app-demo
    2020/12/29 13:03:57 Initializing the Serverless app...
    2020/12/29 13:04:00 ✅ Congratulations! You have initialized the serverless app successfully.
    2020/12/29 13:04:00 🎉 You can enjoy the YoMo Serverless via the command: yomo dev
    $ cd yomo-app-demo

    YoMo Tutorial 2

    CLI will automatically create the app.go:

    package main
    import (
    	y3 ""
    // NoiseDataKey represents the Tag of a Y3 encoded data packet
    const NoiseDataKey = 0x10
    // NoiseData represents the structure of data
    type NoiseData struct {
    	Noise float32 `y3:"0x11"`
    	Time  int64   `y3:"0x12"`
    	From  string  `y3:"0x13"`
    var printer = func(_ context.Context, i interface{}) (interface{}, error) {
    	value := i.(NoiseData)
    	rightNow := time.Now().UnixNano() / int64(time.Millisecond)
    	fmt.Println(fmt.Sprintf("[%s] %d > value: %f ⚡️=%dms", value.From, value.Time, value.Noise, rightNow-value.Time))
    	return value.Noise, nil
    var callback = func(v []byte) (interface{}, error) {
    	var mold NoiseData
    	err := y3.ToObject(v, &mold)
    	if err != nil {
    		return nil, err
    	mold.Noise = mold.Noise / 10
    	return mold, nil
    // Handler will handle data in Rx way
    func Handler(rxstream rx.RxStream) rx.RxStream {
    	stream := rxstream.
    		Debounce(rxgo.WithDuration(50 * time.Millisecond)).
    	return stream

    3. Build and run

    1. Run yomo dev from the terminal. you will see the following message:

    YoMo Tutorial 3

    Congratulations! You have done your first YoMo application.

    Optional: Set $GOPATH and $GOBIN

    for current session:

    export GOPATH=~/.go
    export PATH=$GOPATH/bin:$PATH

    for shell:

    for zsh users

    echo "export GOPATH=~/.go" >> .zshrc
    echo "path+=$GOPATH/bin" >> .zshrc

    for bash users

    echo 'export GOPATH=~/.go' >> .bashrc
    echo 'export PATH="$GOPATH/bin:$PATH"' >> ~/.bashrc

    🧩 Interop

    event-first processing

    Multiple data sources combined calculation




    🗺 Location Insensitive Deployment


    📚 Documentation

    YoMo Vercel, Our documentation website is

    Vercel Logo

    🎯 Focuses on computings out of data center

    • IoT/IIoT/AIoT
    • Latency-sensitive applications.
    • Networking situation with packet loss or high latency.
    • Handling continuous high frequency generated data with stream-processing.
    • Building Complex systems with Streaming-Serverless architecture.

    🌟 Why YoMo

    • Based on QUIC (Quick UDP Internet Connection) protocol for data transmission, which uses the User Datagram Protocol (UDP) as its basis instead of the Transmission Control Protocol (TCP); significantly improves the stability and throughput of data transmission. Especially for cellular networks like 5G.
    • A self-developed y3-codec optimizes decoding performance. For more information, visit its own repository on GitHub.
    • Based on stream computing, which improves speed and accuracy when dealing with data handling and analysis; simplifies the complexity of stream-oriented programming.
    • Secure-by-default from transport protocol.

    🦸 Contributing

    First off, thank you for considering making contributions. It's people like you that make YoMo better. There are many ways in which you can participate in the project, for example:

    • File a bug report. Be sure to include information like what version of YoMo you are using, what your operating system is, and steps to recreate the bug.
    • Suggest a new feature.
    • Read our contributing guidelines to learn about what types of contributions we are looking for.
    • We have also adopted a code of conduct that we expect project participants to adhere to.

    🤹🏻‍♀️ Feedback

    Any questions or good ideas, please feel free to come to our Discussion. Any feedback would be greatly appreciated!


    Apache License 2.0


    YoMo 是一个为边缘计算领域打造的低时延流式数据处理框架,基于 QUIC 协议通讯,以 Functional Reactive Programming 为编程范式,构建可靠、安全的低时延实时计算应用,挖掘 5G 潜力,释放实时计算价值。



    贡献者 11


    • Go 98.1 %
    • Makefile 1.2 %
    • Shell 0.8 %