Skip to content

Serverless Streaming Framework for low-latency geo-distributed system and realtime collaboration application, running atop QUIC protocol, as Metaverse infrastructure, engaging 5G technology.


Switch branches/tags


Failed to load latest commit information.
Latest commit message
Commit time

YoMo Go Discord

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, it makes real-time data processing reliable, secure, and easy.

Official Website:

We care about: The Demand For Real-Time Digital User Experiences

Its no secret that todays users want instant gratification, every productivity application is more powerful when it's collaborative. But, currently, when we talk about distribution, it represents distribution in data center. API is far away from their users from all over the world.

If an application can be deployed anywhere close to their end users, solve the problem, this is Geo-distributed System Architecture:

yomo geo-distributed system


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


Install Go

1. Install CLI

Binary (Recommended)

$ curl -fsSL "" | sh

Or build from source

$ go install

Verify if the CLI was installed successfully

$ yomo -V

YoMo CLI version: v1.0.0

2. Create your stream function

$ yomo init yomo-app-demo

  Initializing the Stream Function...
  Congratulations! You have initialized the stream function successfully.
對   You can enjoy the YoMo Stream Function via the command: 
對   	DEV: 	yomo dev -n Noise yomo-app-demo/app.go
對   	PROD: 	First run source application, eg: go run example/source/main.go
		Second: yomo run -n yomo-app-demo yomo-app-demo/app.go

$ cd yomo-app-demo

CLI will automatically create the app.go:

package main

import (


// NoiseData represents the structure of data
type NoiseData struct {
	Noise float32 `json:"noise"` // Noise value
	Time  int64   `json:"time"`  // Timestamp (ms)
	From  string  `json:"from"`  // Source IP

var echo = func(_ context.Context, i interface{}) (interface{}, error) {
	value := i.(*NoiseData)
	value.Noise = value.Noise / 10
	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

// Handler will handle data in Rx way
func Handler(rxstream rx.Stream) rx.Stream {
	stream := rxstream.
		Unmarshal(json.Unmarshal, func() interface{} { return &NoiseData{} }).

	return stream

func DataTags() []byte {
	return []byte{0x33}

3. Build and run

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

對  YoMo Stream Function file: app.go
  Create YoMo Stream Function instance...
  YoMo Stream Function building...
  Success! YoMo Stream Function build.
對   YoMo Stream Function is running...
2021/11/16 10:02:43 [core:client]  has connected to yomo-app-demo (
[localhost] 1637028164050 > value: 6.575044 ∴=9ms
[StdOut]:  6.5750437
[localhost] 1637028164151 > value: 10.076103 ∴=5ms
[StdOut]:  10.076103
[localhost] 1637028164251 > value: 15.560066 ∴=8ms
[StdOut]:  15.560066
[localhost] 1637028164352 > value: 15.330824 ∴=2ms
[StdOut]:  15.330824
[localhost] 1637028164453 > value: 10.859857 ∴=7ms
[StdOut]:  10.859857

Congratulations! You have done your first YoMo Stream Function.


Metaverse Workplace (Virtual Office) with YoMo


Stream Functions

Output Connectors

Location Insensitive Deployment



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.


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!

Best Practice in Production

Discussion #314 Tips: YoMo/QUIC Server Performance Tuning


Apache License 2.0