Seoul Rust

Find us on Matrix

2026-04-12T00:00:00+00:00

As the Seoul Rust meetup, we try to provide an inclusive space for Rustaceans to gather. Our regular meetups are one part of that mission, but we also provide an online chat space to discuss Rust, among other things.</p>

Over the last few months, we received several reports of new members being unable to join the conversation on Telegram. Telegram recently started requiring most new members in many countries, including South Korea, to pay for a Telegram Premium subscription in order to activate an account. Since Telegram is not widely used in South Korea, this has been a huge barrier to building a welcoming community.</p>

With this in mind, we have decided to create a room on Matrix, a decentralized chat system. It is federated, much like Mastodon, giving users the ability to choose whichever server they like. Though we recommend most new users simply try out the public matrix.org server, which is run by the Matrix Foundation.</p>

How to get started</h1>

1. Get a Matrix client</h2>
There are dozens of apps</a> which let you chat on Matrix. It’s a bit overwhelming, so here are the ones we recommend to get started. (You can always try another app later.)</p>

Element X (iOS and Android)</h3>
Element X</a> provides a well-polished user experience and is our first recommendation for mobile users. If you look around at client comparisons, you’ll often see claims that Element X does not support some features. The most commonly referenced one is “spaces” (a way of grouping “rooms”, much like a Discord server). This is no longer correct, so don’t hesitate to try Element X.</p>

Element Desktop (Linux, macOS, Windows, and Web)</h3>
Also from Element, Element Desktop</a> has a similar UX to Element X and other chat apps. This also works on the web, so you can try it out without installing anything.</p>

2. Create an account</h2>
During the app setup, you will be prompted to set up an account. Choose the matrix.org homeserver and follow the steps.</p>
3. Join the room</h2>
You should be able to join the room by clicking this link</a>. You can also manually join `#rust-seoul:matrix.org</code>.</p>`
`What’s happening to the Telegram channel?</h1> We consider Matrix to be our primary live chat platform going forward. However, we’ll keep our Telegram channel active indefinitely.</p> We have set up a bridge, which ensures that messages are synced between both platforms. Note that some features do not work across the bridge. For example, at the time of this writing, reactions to don carry over. But basic messaging, replies, and images are all synced.</p>`


[WIP][LRW] 3. WASM Meets the Web (feat. Web Browsers)
2026-03-19T00:00:00+00:00
The pub hello_world()</a> function implemented in the previous chapter is a very basic Rust function that returns the string “Hello Word”. Rust itself does not require a separate runtime environment. However, compiled Wasm binaries are designed to run on a Wasm runtime</strong>, and can communicate with the outside world only through that environment.</p>
Therefore, in addition to Rust’s standard library, an additional library(e.g., wasm-bindgen)</strong> is required to bridge the interface with the execution environment. In a web browser — one of the primary execution environments for Wasm — actual functionality is achieved by accessing browser APIs through the JavaScript engine.</p>
We will explore how to communicate with the JavaScript engine from your Rust-based WASM file using wasm-bindgen, and further examine how to pass results produced within a Wasm module to users by leveraging browser APIs. We will also cover how to use wasm-pack to create an efficient and integrated development environment. Following these stages, we will dive deeper into wasm_bindgen_futures to handle Rust’s asynchronous programming style alongside JavaScript’s Promise-based approach. Finally, we will look over web-sys and js-sys—the crates you will use most often to implement real-world apps with minimal JavaScript glue code, even though your Wasm code still accesses the browser DOM through the JavaScript world.</p>
🔗</a>1. Wasm-bindgen</h3>
Wasm-bindgen</a> bridges Wasm modules and the JavaScript engine within your web browser.</p>
🔗</a>1.1 Wasm file with wasm_bindgen</strong></h4>
New project with Cargo</strong> command</p>
> cargo new --lib hello-world
</code></pre>
Let’s replace the contents of Cargo.toml</strong> and src/lib.rs</strong> with the following code.</p>
</span>Cargo.toml</code></p>
[package]
name = "hello-wasm"
version = "0.1.0"
edition = "2024"

[lib]
crate-type = ["cdylib"]

[dependencies]
chrono = "0.4"
wasm-bindgen = "0.2"
</code></pre>
The difference from the previous Cargo.toml</strong> is that chrono</strong> and wasm-bindgen</strong> have been added to the dependencies. We use chrono</strong> to implement logic for fetching the current time, and wasm-bindgen</strong> is the core library that enables communication between the Rust-built Wasm module and the JavaScript runtime.</p>
</span>src/lib.rs</code></p>
use chrono::Local;
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
  extern "C" {
      fn alert(s: &str);
  }

#[wasm_bindgen]
  pub fn now() -> String {
      Local::now().to_rfc3339()
  }

#[wasm_bindgen]
  pub fn pop_message(msg: &str) {
      alert(msg)
  }

#[wasm_bindgen]
  pub fn add(a: f64, b: f64) -> f64 {
      a + b
  }
</code></pre>
Functions annotated with the #[wasm_bindgen]</strong> attribute macro are intended to be called from JavaScript. You can see the now()</strong> function for returning the current time, pop_message(&str)</strong> for triggering a JavaScript alert()</strong>, and add(f64, f64)</strong> for performing addition.</p>
Generating WASM file</strong></p>
❯ cargo build --release --target wasm32-unknown-unknown
  Finished `release` profile [optimized] target(s) in 0.16s
</code></pre>
You should see target/wasm32-unknown-unknown/release/hello_wasm.wasm</code>.</p>
🔗</a>1.2. Creating Java(Type)Script files with wasm-bindgen</h4>
wasm-bindgen</strong> serves as both a Rust crate and a CLI tool. As a crate, it handles the interoperability between the Wasm modules generated by the compiler and JavaScript. As a CLI tool, it automatically generates the necessary bindings and glue code, allowing you to seamlessly call your Wasm functions from JavaScript or TypeScript.</p>
Installation</p>
> cargo binstall wasm-bindgen-cli
</code></pre>
Alternatively, you can clone the code directly from the wasm-bindgen repository</a> and build it yourself (which is the approach I personally prefer).</p>
> git clone --depth 1 https://github.com/wasm-bindgen/wasm-bindgen.git && cd wasm-bindgen
> cargo build --release --package wasm-bindgen-cli
> install -s -Dm755 target/release/wasm-bindgen -t ~/.cargo/bin
</code></pre>
Now, let’s use the wasm-bindgen</strong> command to generate the JavaScript(and/or TypeScript) bindings that will allow your browser to interface with the Wasm file we built earlier.</p>
> wasm-bindgen ./target/wasm32-unknown-unknown/release/hello_wasm.wasm --target web --out-dir ./pkg
</code></pre>
Set --target</code> to web</code> and --out-dir</code> to ./pkg</code>. The output will be generated in the pkg</code> directory.</p>
❯ eza --tree pkg/
pkg
├── hello_wasm.d.ts
├── hello_wasm.js
├── hello_wasm_bg.wasm
└── hello_wasm_bg.wasm.d.ts
</code></pre>
If you open pkg/hello_wasm.js</strong>, you will find the exported Wasm functions ready to be called directly from JavaScript. A major benefit of using wasm-bindgen</strong> is that developers don’t have to manually redefine function interfaces for JavaScript interoperability; the tool automatically generates all the complex glue code for you.</p>
Now, it’s time to create the index.html</strong> file to see it in action. Create index.html</strong> in the project root, the same directory where your Cargo.toml</strong> is located.</p>
</span>index.html</code></p>
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <title>The Little Rust and Wasm Guide</title>
  </head>
  <body>
    <script type="module">
      import init, {now, pop_message}
      from './pkg/hello_wasm.js';

      async function run() {
        await init();
        pop_message("Current time is " + now());
      }

      run();
    </script>

    <h1>The Little Rust and Wasm Guide</h1>
    <form id="sumForm">
      <input type="number" id="num1" placeholder="First number" required>
      <input type="number" id="num2" placeholder="Second number" required>
      <button type="submit">Add</button>
    </form>

    <p>Result: <span id="result">0</span></p>

  <script type="module">
   import init, { add }
      from './pkg/hello_wasm.js';

    const form = document.getElementById('sumForm');
    const resultDisplay = document.getElementById('result');

    form.addEventListener('submit', (event) => {
      event.preventDefault();
      const val1 = document.getElementById('num1').value;
      const val2 = document.getElementById('num2').value;

      const sum = add(val1, val2);

      resultDisplay.textContent = sum;
    }
    );
  </script>

  </body>
</html>
</code></pre>
</span>`
Now, let’s serve the HTML, JavaScript, and Wasm files we created using miniserve</strong>.</p>
> miniserve -p 9099 --index index.html .
</code></pre>
Open your web browser and navigate to http://localhost:9099.</p>
</p>
What is `miniserve`?  
Miniserve: a CLI tool to serve files and dirs over HTTP  
https://github.com/svenstaro/miniserve
</code></pre>
🔗</a>2. wasm-pack</h3>
wasm-pack</a> streamlines the development process by integrating various commands like cargo</strong> and ****wasm-bindgen</strong> into a single tool. If you use wasm-pack</strong>, there’s no need to install wasm-bindgen-cli</strong> separately, as it handles the underlying environment for you.“</p>
🔗</a>2.1 Installation</h4>
You can install wasm-pack using the official installer</a>. Alternatively, you can build it from source if you prefer.</p>
> git clone --depth 1 https://github.com/drager/wasm-pack.git && cd wasm-pack
> cargo build --release
> install -s -Dm755 target/release/wasm-pack -t ~/.cargo/bin
</code></pre>
Once installed, you can view the usage instructions using the help</code> command.</p>
❯ wasm-pack help
📦 ✨  pack and publish your wasm!

Usage: wasm-pack [OPTIONS] <COMMAND>

Commands:
  build    🏗️  build your npm package!
  pack     🍱  create a tar of your npm package but don't publish!
  new      🐑 create a new project with a template
  publish  🎆  pack up your npm package and publish!
  login    👤  Add an npm registry user account! (aliases: adduser, add-user)
  test     👩‍🔬  test your wasm!
  help     Print this message or the help of the given subcommand(s)

Options:
  -v, --verbose...             Log verbosity is based off the number of v used
  -q, --quiet                  No output printed to stdout
      --log-level <LOG_LEVEL>  The maximum level of messages that should be logged by wasm-pack. [possible values: info, warn, error] [default: info]
  -h, --help                   Print help
  -V, --version                Print version
</code></pre>
🔗</a>2.2. Create your project with “wasm-pack”</h4>
❯ wasm-pack new hello-wasm
[INFO]: ⬇️  Installing cargo-generate...
🐑  Generating a new rustwasm project with name 'hello-wasm'...
🔧   Destination: /tmp/hello-wasm ...
🔧   project-name: hello-wasm ...
🔧   Generating template ...
[ 1/14]   Done: .appveyor.yml
[ 2/14]   Done: .github/dependabot.yml
[ 3/14]   Done: .github
[ 4/14]   Done: .gitignore
[ 5/14]   Done: .travis.yml
[ 6/14]   Done: Cargo.toml
[ 7/14]   Done: LICENSE_APACHE
[ 8/14]   Done: LICENSE_MIT
[ 9/14]   Done: README.md
[10/14]   Done: src/lib.rs
[11/14]   Done: src/utils.rs
[12/14]   Done: src
[13/14]   Done: tests/web.rs
[14/14]   Done: tests
🔧   Moving generated files into: `/tmp/hello-wasm`...
🔧   Initializing a fresh Git repository
✨   Done! New project created /tmp/hello-wasm
[INFO]: 🐑 Generated new project at /hello-wasm
> 
</code></pre>
Generated project structure</strong></p>
❯ eza --tree hello-wasm
hello-wasm
├── Cargo.toml
├── LICENSE_APACHE
├── LICENSE_MIT
├── README.md
├── src
│   ├── lib.rs
│   └── utils.rs
└── tests
    └── web.rs
</code></pre>
🔗</a>2.3 Code</h4>
We will use the same Cargo.toml</a> and src/lib.rs</a> files created in the previous wasm-bindgen</strong> example.</p>
🔗</a>2.4 Build</h4>
Let’s perform the build using wasm-pack</strong>. By setting the –target</strong> to web</strong>, the generated files will be placed in the default ./pkg</strong> directory. Unlike using wasm-bindgen directly</strong>, there is no need to manually build the Wasm file with cargo</strong> beforehand; wasm-pack</strong> automatically handles both the Wasm compilation and the generation of JavaScript (and TypeScript) bindings in a single step</p>
> wasm-pack build --target web
</code></pre>
Generated files in ‘pkg’ folder after the build</strong></p>
❯ eza --tree pkg/
pkg
├── hello_wasm.d.ts
├── hello_wasm.js
├── hello_wasm_bg.js
├── hello_wasm_bg.wasm
├── hello_wasm_bg.wasm.d.ts
├── package.json
└── README.md
</code></pre>
🔗</a>2.5 Calling from HTML and Viewing the Results</h4>
Create index.html</a> with the same index.html file we created at wasm_bindgen</strong> example. Then check the result on your web browser</a> .</p>
You should see the same results as we did with wasm-bindgen</strong>. By integrating the tasks previously handled separately by Cargo</strong> and wasm-bindgen</strong>, wasm-pack</strong> significantly improves development efficiency.</p>
🔗</a>3. wasm_bindgen_futures</h3>
wasm_bindgen_futures</a> bridges the gap between JavaScript Promises and Rust Futures.</p>
To demonstrate this, let’s build an example that fetches the current temperatures of Seoul, New York, and Berlin using the reqwest</strong> crate and the Open-Meteo API, then displays them in the browser.“</p>
Cargo.toml</strong></p>
[package]
name = "hello-wasm"
version = "0.1.0"
edition = "2024"

[lib]
crate-type = ["cdylib"]

[dependencies]
reqwest = "0.13.2"
wasm-bindgen = "0.2.114"
wasm-bindgen-futures = "0.4.64"
</code></pre>
src/lib.rs</strong></p>
use reqwest::{self, StatusCode};
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub async fn get_http(url: String) -> Result<String, JsError> {
    let client = reqwest::Client::new();

    let res = client
        .get(&url)
        .send() 
        .await
        .map_err(|e| JsError::new(&format!("Request failed: {}", e)))?;

    if res.status() == StatusCode::OK {
        let text = res
            .text()
            .await
            .map_err(|e| JsError::new(&format!("Text parse failed: {}", e)))?;
        return Ok(text);
    }

    Err(JsError::new(&format!("HTTP Error: {}", res.status())))
}
</code></pre>
index.html</strong></p>
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <title>The Little Rust and Wasm Guide</title>
  </head>
  <body>
    <script type="module"> 
      import init, {get_http}
      from './pkg/hello_wasm.js';

      const cities = [
      { name: "Seoul", url: "https://api.open-meteo.com/v1/forecast?latitude=37.566&longitude=126.9784&current=temperature_2m&timezone=Asia%2FTokyo"},
      { name: "NewYork", url: "https://api.open-meteo.com/v1/forecast?latitude=40.7143&longitude=-74.006&current=temperature_2m&timezone=Asia%2FTokyo"},
      { name: "Berlin", url: "https://api.open-meteo.com/v1/forecast?latitude=52.5244&longitude=13.4105&current=temperature_2m&timezone=Asia%2FTokyo"},
      ]

      async function run() {
        await init();
        for (const city of cities) {
          try {
            const weather = JSON.parse(await get_http(city.url));
            const temp = weather.current.temperature_2m;
            const unit = weather.current_units.temperature_2m;
            document.getElementById(city.name).innerText = `${temp}${unit}`;
          } catch (err) {
            console.error("Rust Error:", err);
          }
        }
      }

      run();
    </script>

    <h1>The Little Rust and Wasm Guide</h1>

    <ul>
    <li>Seoul: <span id="Seoul">Loading...</span></li>
    <li>New York: <span id="NewYork">Loading...</span></li>
    <li>Berlin: <span id="Berlin">Loading...</span></li>
    </ul>

  </body>
</html>
</code></pre>
Open your web browser and navigate to http://localhost:9099.</strong>

</p>


[WIP][LRW] 1. Build your first WASM
2026-03-15T00:00:00+00:00
Code First.</strong>

A wise man once said, ‘Talk is cheap. Show me the code.’</em>

Keep Calm and Code On.</p>
🔗</a>1. Check your Rust compiler can handle WASM build</h3>
      ❯ rustc --print target-list | grep wasm
      wasm32-unknown-emscripten
      wasm32-unknown-unknown
      wasm32-wali-linux-musl
      wasm32-wasip1
      wasm32-wasip1-threads
      wasm32-wasip2
      wasm32-wasip3
      wasm32v1-none
      wasm64-unknown-unknown
</code></pre>
If you don’t see the wasm32-unknown-unknown entry in the list, it means you aren’t ready to compile WASM files yet.</p>
  wasm32-unknown-unkown means  
  wasm32: Indicates that the target CPU architecture is 32-bit WebAssembly.  
  unknown(Vendor): Signifies that no specific vendor (manufacturer) is defined for producing or distributing this binary.
  unknown(OS/ABI): Signifies that the target operating system or System Interface(ABI) is not defined.  
  Taken together, it refers to a "pure" 32-bit WebAssembly binary that can run anywhere, free from specific OS or hardware constraints.  

  Examples of Other Targets  
  x86_64-unknown-linux-gnu: Targets the 64-bit environment of the x86 architecture and is not limited to a specific vendor. It requires the Linux operating system and the GNU C library (glibc). This is the standard target used when compiling Linux C code.  
  aarch64-apple-darwin: Targets the aarch64 (Apple Silicon) architecture and is dependent on Apple devices and the Darwin OS/runtime.  
</code></pre>
Installing wasm32-unknown-unknown</code> build target</p>
  > rustup target add wasm32-unknown-unknown
</code></pre>
Once the installation is complete, run the rustc --print target-list</code> command again to verify that the wasm32-unknown-unknown</code> target has been successfully added to the list.</p>
🔗</a>2. Code Hello World</h3>
Creating a hello-world project using Cargo</p>
     ❯ cargo new --lib hello-world
     Creating library `hello-world` package
     note: see more `Cargo.toml` keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
</code></pre>
The command cargo new hello-wasm --lib</code> creates the following directory structure:</p>
  ❯ eza --tree hello-world
  hello-world
  ├── Cargo.toml
  └── src
  └── lib.rs
</code></pre>
What is `eza`?
eza는 기존의 ls 명령어를 현대적으로 재해석하여 대체하기 위한 도구이다. Rust 언어로 작성되어 매우 빠른 속도를 자랑하며, 사용자에게 더 직관적이고 풍부한 정보를 제공한다. You can find more at eza.rocks(https://eza.rocks) site.
</code></pre>
Generating a WASM binary requires adding a [lib] section and configuring the crate-type in Cargo.toml.</p>
[lib]
crate-type = ["cdylib"]
</code></pre>
Completed Cargo.toml</code></p>
[package]
name = "hello-world"
version = "0.1.0"
edition = "2024"

[lib]
crate-type = ["cdylib"]

[dependencies]
</code></pre>
Write the contents of src/lib.rs</code> as follows:</p>
pub fn hello_world() -> &'static str' {
  "Hello World"
}
</code></pre>
🔗</a>3.Compiling</h3>
wasm</code> file build with cargo build</code></p>
❯ cargo build --target wasm32-unknown-unknown --release
  Finished `release` profile [optimized] target(s) in 0.01s  
</code></pre>
The hello_world.wasm</code> file can now be found in the target/wasm32-unknown-unknown/release</code> folder.</p>
❯ file target/wasm32-unknown-unknown/release/hello_world.wasm
target/wasm32-unknown-unknown/release/hello_world.wasm: WebAssembly (wasm) binary module version 0x1 (MVP)
</code></pre>
We have successfully created a hello_world.wasm</code> file using a very simple Rust code. Running the file</code> command on it confirms that it is indeed a WebAssembly (wasm) binary.</p>
Now, you might be wondering how to execute and utilize this .wasm file</code>. Unlike other languages, there is quite a lot to discuss here. This is where the true journey into the world of WebAssembly begins.</p>
In the next post, we will take a closer look at what this WASM file actually is and how it can be executed in various environments.</p>


[WIP] The Little Rust & Wasm Guide
2026-03-15T00:00:00+00:00
This is a series of blog posts originally written in Korean for The Little Rust and WASM Guide</a>.</p>

Diving Headfirst into Creating a WASM File</a>

1.1 Rust Compiler: Are your Cargo ready?</a>

1.2 Code ‘Hello World’</a>

1.3 Compiling to Wasm</a></li>
What is WASM?</a>

2.1 WASM, First Appearance

2.3 WASI - Wasm Beyond the Browser</li>
WASM Meets the Web (feat. Web Browsers)</a>

3.1 wasm-bindgen</a>

3.2 wasm-pack</a>

3.3 wasm_bindgen_futures</a>

3.4 web_sys (incl. js_sys)</a></li>
The Story of WASI: WASM Beyond the Browser</a>

4.1 Wasmtime

4.2 Wasmer

4.3 WasmEdge

4.5 Spinframework

4.6 FaaS(Function as a Service) and WASM

4.7 Container and WASM</li>
Cookbook

5.1 WebSocket Client on Browser

5.2 Rss Feeder in Spinframework

5.3 ActivityPub in WASI

5.4 ActivityPub in Browser

5.5 Graphics</li>
</ol>


How to write on seoul.rs
2026-03-13T00:00:00+00:00
This post was originally written in Korean How to Contribute here</a> and translated into English with the help of an LLM.</p>
seoul.rs is built with zola</a>, a Rust-based Static Site Generator (SSG), and utilizes the zola-bearblog</a> template.</p>
To contribute a blog post or news article, please fork github.com/seoul-rs/seoul-rs</a>. Create a Markdown (.md) file under the blog or news directory within the content folder. Each post must include a header in the format shown below, followed by your content in Markdown. For posts written in Korean, please include the .ko</code> language tag in the filename (e.g., my-first-writing.ko.md). For English posts, simply use the .md extension (e.g., my-first-writing.md).</p>
+++
title = "How to write on seoul.rs"
date = "2026-03-03"
[taxonomies]
authors = ["John Smith"]
tags = ["first"]
+++

Start writing here...

</code></pre>
Once you have finished writing, please submit a Pull Request to the github.com/seoul-rs/seoul-rs</a> repository. Your post will be reviewed and merged, after which it will be automatically published via GitHub Actions.</p>
When creating a Pull Request, please ensure that all commits are signed with your encryption key. We only merge commits that are Verified using keys registered with GitHub. If you do not have a GitHub account, please submit your patch files signed with your GPG key.</p>
For more detailed information on the Static Site Generator (SSG), please refer to Zola</a>.</p>


Monthly Seoul Rust Meetup at March 19, 2026
2026-03-13T00:00:00+00:00
Meetup location and details: Meetup.com page</a>

This meetup is held in English.</p>
This Month’s talk</p>

Chat History the Database the Search Engine the TUI the CLI the Local-First Matrix Archiver in Rust (Zeeshan Lakhani)</a></li>
Continuously Deploying Rust servers to production without rebuilding the universe (Charles Jonhson)</li>
</ul>


[Link] Writing Complex Macro in Rust: Reverse Polish Notation
2026-03-12T00:00:00+00:00
If you aren’t very familiar with Rust macros and have always wondered if they are actually necessary for everyday programming—and if you’re a math or CS enthusiast who prefers RPN and HP calculators over TI ones—this is for you.</p>
https://rreverser.com/writing-complex-macros-in-rust/</a></p>


Tokio Conf 2026
2026-03-02T00:00:00+00:00
Tokio Conf 2026, Portland, Oregon, April 20 - 22, 2026</p>
Tickets are now on sale:
https://www.eventbrite.com/e/tokioconf-2026-tickets-1595919270499</p>

Seoul Rust

Find us on Matrix

How to get started</h1>

1. Get a Matrix client</h2> There are dozens of apps</a> which let you chat on Matrix. It’s a bit overwhelming, so here are the ones we recommend to get started. (You can always try another app later.)</p>

[WIP][LRW] 3. WASM Meets the Web (feat. Web Browsers)

[WIP][LRW] 1. Build your first WASM

[WIP] The Little Rust & Wasm Guide

How to write on seoul.rs

Monthly Seoul Rust Meetup at March 19, 2026

[Link] Writing Complex Macro in Rust: Reverse Polish Notation

Tokio Conf 2026

1. Get a Matrix client</h2>
There are dozens of apps</a> which let you chat on Matrix. It’s a bit overwhelming, so here are the ones we recommend to get started. (You can always try another app later.)</p>