{"id":1063,"date":"2026-07-02T06:51:42","date_gmt":"2026-07-01T23:51:42","guid":{"rendered":"https:\/\/sumberlaba.com\/index.php\/2026\/07\/02\/how-to-use-rust-for-webassembly-a-step-by-step-guide-to-building-blazing-fast-web-applications\/"},"modified":"2026-07-02T06:51:42","modified_gmt":"2026-07-01T23:51:42","slug":"how-to-use-rust-for-webassembly-a-step-by-step-guide-to-building-blazing-fast-web-applications","status":"publish","type":"post","link":"https:\/\/sumberlaba.com\/index.php\/2026\/07\/02\/how-to-use-rust-for-webassembly-a-step-by-step-guide-to-building-blazing-fast-web-applications\/","title":{"rendered":"How to Use Rust for WebAssembly: A Step-by-Step Guide to Building Blazing Fast Web Applications"},"content":{"rendered":"<h1>How to Use Rust for WebAssembly: A Step-by-Step Guide to Building Blazing Fast Web Applications<\/h1>\n<p>WebAssembly (Wasm) has revolutionized client-side performance by enabling near-native execution speeds in the browser. While JavaScript remains the lingua franca of the web, its dynamic nature imposes overhead that can cripple computationally intensive tasks\u2014think image processing, data compression, game physics, or real-time audio synthesis. Rust, a systems programming language that guarantees memory safety without a garbage collector, pairs perfectly with Wasm to deliver both speed and reliability. This tutorial will take you from a clean slate to a fully functioning Rust\u2011powered WebAssembly module integrated into a web application. You&#8217;ll learn how to set up the development environment, write idiomatic Rust code that compiles to Wasm, bridge the gap between JavaScript and Rust using binding libraries, and deploy optimised modules. By the end, you&#8217;ll have a solid foundational understanding of the entire workflow and be ready to tackle your own high\u2011performance browser projects.<\/p>\n<p>The synergy between Rust and WebAssembly is no accident. Rust\u2019s zero\u2011cost abstractions, strong type system, and ownership model produce binaries that are both small and fast\u2014critical for web delivery. The WebAssembly specification was designed with languages like Rust in mind, offering a portable compilation target that runs inside a sandboxed virtual machine. With the help of tools like <code>wasm\u2011pack<\/code> and <code>wasm\u2011bindgen<\/code>, the process of compiling Rust to Wasm and exposing functions to JavaScript becomes nearly frictionless. This tutorial assumes you have basic familiarity with Rust syntax and JavaScript, but even if you&#8217;re new to Rust, the steps are explained in enough detail to follow along. Let&#8217;s begin by setting up the toolchain and then dive into writing our first Rust\u2011Wasm module.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/via.placeholder.com\/800x600\/4a90d9\/ffffff?text=how%20to%20use%20Rust%20for%20web%20assembly\" alt=\"Article illustration\" style=\"display:block;margin:20px auto;max-width:100%;height:auto;border-radius:8px;\" \/><\/p>\n<h2>Step 1: Setting Up the Development Environment<\/h2>\n<p>Before you can compile Rust to WebAssembly, you need a few key pieces of software: the Rust compiler (<code>rustc<\/code>) and its package manager <code>cargo<\/code>, the Wasm target, and the <code>wasm\u2011pack<\/code> tool that orchestrates building and binding. If you don&#8217;t already have Rust installed, head to <a href=\"https:\/\/rustup.rs\">rustup.rs<\/a> and follow the instructions for your operating system. This will install <code>rustup<\/code>, which manages Rust toolchains. Once installed, open a terminal and run:<\/p>\n<pre><code>rustup update\nrustup target add wasm32-unknown-unknown<\/code><\/pre>\n<p>The <code>wasm32\u2011unknown\u2011unknown<\/code> target tells the Rust compiler to produce a WebAssembly binary that doesn&#8217;t rely on any operating system abstractions (no system calls). This is exactly what we need for the browser. Next, install <code>wasm\u2011pack<\/code>, the Swiss Army knife for Rust\u2011Wasm development. You can install it via cargo:<\/p>\n<pre><code>cargo install wasm-pack<\/code><\/pre>\n<p>Alternatively, you can use npm if you prefer: <code>npm install -g wasm-pack<\/code>. After installation, verify everything works by checking the version: <code>wasm-pack --version<\/code>. You should see something like <code>0.13.0<\/code> or later. With these tools ready, we can create a new project.<\/p>\n<h2>Step 2: Creating a New Rust Wasm Project<\/h2>\n<p>Rust projects are managed by cargo, and <code>wasm\u2011pack<\/code> can scaffold a complete library tailored for WebAssembly. Run the following command in your terminal:<\/p>\n<pre><code>wasm-pack new hello-wasm<\/code><\/pre>\n<p>This generates a directory called <code>hello\u2011wasm<\/code> with a standard Rust project structure: a <code>src\/lib.rs<\/code> file, <code>Cargo.toml<\/code>, and several configuration files. It also adds the <code>wasm\u2011bindgen<\/code> dependency in <code>Cargo.toml<\/code>, which is the library that allows Rust functions to be called from JavaScript and vice versa. If you prefer to manually create the project (e.g., inside an existing monorepo), you can run <code>cargo init --lib my-wasm-crate<\/code> and then add <code>wasm\u2011bindgen<\/code> as a dependency. The generated <code>Cargo.toml<\/code> should include:<\/p>\n<pre><code>[lib]\ncrate-type = [\"cdylib\"]\n\n[dependencies]\nwasm-bindgen = \"0.2\"<\/code><\/pre>\n<p>The <code>cdylib<\/code> crate type instructs cargo to produce a dynamic library suitable for WebAssembly. Without this, no <code>.wasm<\/code> file would be emitted. Now open <code>src\/lib.rs<\/code>; it will contain a simple &#8220;Hello, world!&#8221; function annotated with <code>#[wasm_bindgen]<\/code>. This annotation is what generates the JavaScript bindings automatically.<\/p>\n<h2>Step 3: Writing Rust Code with wasm\u2011bindgen<\/h2>\n<p>The heart of Rust\u2011Wasm development is the <code>wasm\u2011bindgen<\/code> crate (and its companion libraries <code>web\u2011sys<\/code> and <code>js\u2011sys<\/code>). <code>wasm\u2011bindgen<\/code> allows you to expose Rust functions, structs, and even closures to JavaScript, and conversely to call JavaScript APIs from Rust. Let&#8217;s replace the boilerplate with a more interesting function that adds two numbers and returns the result. In <code>src\/lib.rs<\/code>:<\/p>\n<pre><code>use wasm_bindgen::prelude::*;\n\n#[wasm_bindgen]\npub fn add(a: i32, b: i32) -> i32 {\n    a + b\n}<\/code><\/pre>\n<p>The <code>#[wasm_bindgen]<\/code> attribute above the function tells the code generator to create JavaScript stubs that marshal arguments and return values. Rust types that implement <code>wasm_bindgen<\/code>&#8216;s <code>JsCast<\/code> or <code>FromWasmAbi<\/code> traits can be used. For simple numeric types like <code>i32<\/code>, <code>f64<\/code>, and <code>bool<\/code>, the conversion is automatic and zero\u2011cost. For more complex types such as strings, <code>Vec<\/code>, or custom structs, there are helper macros. For example, returning a <code>String<\/code> requires <code>#[wasm_bindgen]<\/code> on the function; the string will be copied across the boundary. To work with the browser DOM, you&#8217;d add the <code>web\u2011sys<\/code> crate, which provides Rust bindings for all Web APIs. For now, let&#8217;s keep it simple and compile our library.<\/p>\n<h2>Step 4: Compiling Rust to WebAssembly<\/h2>\n<p>With the code written, we compile to Wasm using <code>wasm\u2011pack<\/code>. Inside the project directory, run:<\/p>\n<pre><code>wasm-pack build --target web<\/code><\/pre>\n<p>The <code>--target web<\/code> flag produces output that can be loaded directly as an ES module (or via a <code>&lt;script type=\"module\"&gt;<\/code>). Other targets include <code>--target no-modules<\/code> (for older bundlers) and <code>--target bundler<\/code> (for Webpack, etc.). When the build finishes, a new directory called <code>pkg\/<\/code> appears. Inside, you&#8217;ll find a <code>.wasm<\/code> binary, a JavaScript shim (<code>hello_wasm.js<\/code>), TypeScript definitions, and a <code>package.json<\/code>. The JS shim is crucial; it handles loading and instantiating the WebAssembly module and exposes the functions you annotated with <code>#[wasm_bindgen]<\/code>. For example, the generated <code>hello_wasm.js<\/code> will export an <code>add<\/code> function that delegates to the Wasm implementation. You can inspect the file to see how it uses <code>WebAssembly.instantiateStreaming<\/code> or other methods.<\/p>\n<p>If you want to verify the Wasm binary size, use <code>ls -lh pkg\/hello_wasm_bg.wasm<\/code>. A simple addition function yields a binary of just a few kilobytes, but as you add dependencies, the size grows. Rust\u2019s LTO (link time optimisation) and <code>wasm\u2011opt<\/code> (from Binaryen) can further reduce size. <code>wasm\u2011pack<\/code> automatically runs <code>wasm\u2011opt<\/code> in release mode; you can enable release builds with <code>wasm-pack build --release<\/code> for even smaller output.<\/p>\n<h2>Step 5: Integrating the Wasm Module into a Web Application<\/h2>\n<p>Now we have a compiled module ready to be used in a web page. Create a simple <code>index.html<\/code> in the project root (or anywhere you serve files from). Because we used <code>--target web<\/code>, we can load the module as an ES module. Here&#8217;s a minimal HTML file:<\/p>\n<pre><code>&lt;!DOCTYPE html&gt;\n&lt;html&gt;\n&lt;head&gt;\n    &lt;title&gt;Rust + Wasm Example&lt;\/title&gt;\n&lt;\/head&gt;\n&lt;body&gt;\n    &lt;p id=\"result\"&gt;&lt;\/p&gt;\n    &lt;script type=\"module\"&gt;\n        import init, { add } from '.\/pkg\/hello_wasm.js';\n\n        async function run() {\n            await init();\n            const sum = add(40, 2);\n            document.getElementById('result').textContent = `40 + 2 = ${sum}`;\n        }\n\n        run();\n    &lt;\/script&gt;\n&lt;\/body&gt;\n&lt;\/html&gt;<\/code><\/pre>\n<p>The <code>init()<\/code> function (which is the default export from the JS shim) pre\u2011loads and instantiates the Wasm module. Once it resolves, the <code>add<\/code> function becomes available. Load the page in a local server (e.g., <code>python3 -m http.server<\/code> or <code>npx serve<\/code>) and you&#8217;ll see the result printed. This basic pattern works for any exported Rust function. For larger projects, you&#8217;d bundle everything with Webpack or Vite, but the core integration is the same. If you need to call DOM APIs from Rust directly, you&#8217;ll add <code>web\u2011sys<\/code> and use its methods\u2014but that&#8217;s a more advanced topic. For most use cases, keeping Rust for pure computation and JavaScript for UI interactions is the cleanest separation.<\/p>\n<h2>Step 6: Optimising and Debugging Rust Wasm Modules<\/h2>\n<p>Performance and debugging differ from typical JavaScript development. First, always compile with <code>--release<\/code> for production. Release mode enables Rust&#8217;s optimisations and <code>wasm\u2011opt<\/code> passes, often reducing binary size by 50% or more. Second, handle panics gracefully. By default, a Rust panic in Wasm will abort the module with an unhelpful error. Add the <code>console_error_panic_hook<\/code> crate to your <code>Cargo.toml<\/code>:<\/p>\n<pre><code>[dependencies]\nconsole_error_panic_hook = \"0.1.10\"<\/code><\/pre>\n<p>Then in your code, call <code>console_error_panic_hook::set_once();<\/code> at the start of your module. This redirects panic messages to the browser&#8217;s console. Third, measure the size of your Wasm binary. Use <code>wasm-pack build --release<\/code> and then inspect the <code>.wasm<\/code> file. If it&#8217;s too large, review your dependencies\u2014avoid using the standard library unless necessary (it pulls in a lot). You can compile with <code>#![no_std]<\/code> and use only the <code>core<\/code> crate, though <code>wasm\u2011bindgen<\/code> requires <code>std<\/code> for some features. Additionally, use <code>twiggy<\/code> or <code>wasm\u2011gc<\/code> to analyse what&#8217;s bloating your binary. Finally, for debugging, you can output WebAssembly source maps (though support is limited) or use <code>console.log<\/code> from Rust via <code>web_sys::console::log_1(&amp;value.into());<\/code>.<\/p>\n<h2>Tips and Best Practices for Rust\u2011Wasm Development<\/h2>\n<h3>Tip 1: Minimise Cross\u2011Boundary Copies<\/h3>\n<p>Every call between JavaScript and Rust incurs overhead, especially when passing large data like arrays or strings. Instead of passing a single number at a time, batch operations. For example, if you&#8217;re processing an image, pass the entire pixel array as a <code>Vec&lt;u8&gt;<\/code> once, process it inside Rust, and return the modified vector. Use <code>wasm\u2011bindgen<\/code>&#8216;s support for <code>JsValue<\/code> and typed arrays to share memory without copying. The <code>js_sys::Uint8Array<\/code> type allows direct access to the underlying buffer. This zero\u2011copy strategy is crucial for performance\u2011sensitive applications.<\/p>\n<h3>Tip 2: Use web\u2011sys and js\u2011sys Wisely<\/h3>\n<p>While you can call browser APIs from Rust, doing so often ties your logic to the DOM and makes testing harder. Isolate pure computation in Rust and keep DOM manipulation in JavaScript or a lightweight framework. If you must use web\u2011sys, prefer subscribing to events rather than polling, and avoid allocating unnecessary objects on the Rust side. Also note that web\u2011sys bindings are generated from Web IDL, so they closely mirror the JavaScript API; you&#8217;ll often need to convert between Rust types and <code>JsValue<\/code>.<\/p>\n<h3>Tip 3: Profile and Use `#[inline]` Judiciously<\/h3>\n<p>WebAssembly execution is not identical to native because browsers apply additional optimisation passes. Use the browser&#8217;s performance profiler to see where time is spent. For hot functions, consider marking them with <code>#[inline(always)]<\/code> or <code>#[inline]<\/code> to encourage the compiler to inline them across the Wasm module boundary. Also, prefer simple integer and floating\u2011point calculations; complex pattern matching with many branches can bloat the binary.<\/p>\n<h2>Reference Tables<\/h2>\n<p>The following tables provide quick lookups for common Rust\u2011to\u2011JavaScript type conversions and for essential libraries in the ecosystem.<\/p>\n<h3>Table 1: Rust to JavaScript Type Mappings via wasm\u2011bindgen<\/h3>\n<table border=\"1\" cellpadding=\"5\" style=\"border-collapse: collapse;\">\n<thead>\n<tr>\n<th>Rust Type<\/th>\n<th>JavaScript Type<\/th>\n<th>Notes<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>i32<\/code>, <code>u32<\/code>, <code>f64<\/code><\/td>\n<td><code>Number<\/code><\/td>\n<td>Zero\u2011cost conversion; 64\u2011bit floats are native in JS.<\/td>\n<\/tr>\n<tr>\n<td><code>bool<\/code><\/td>\n<td><code>Boolean<\/code><\/td>\n<td>Direct mapping.<\/td>\n<\/tr>\n<tr>\n<td><code>String<\/code><\/td>\n<td><code>String<\/code><\/td>\n<td>Copied on both sides; avoid frequent conversions.<\/td>\n<\/tr>\n<tr>\n<td><code>Vec&lt;T&gt;<\/code> (T: scalar)<\/td>\n<td><code>TypedArray<\/code> (e.g., <code>Int32Array<\/code>)<\/td>\n<td>If T is <code>u8<\/code>, it becomes <code>Uint8Array<\/code>; memory can be shared.<\/td>\n<\/tr>\n<tr>\n<td><code>JsValue<\/code><\/td>\n<td>Any JavaScript value<\/td>\n<td>Allows passing arbitrary objects without type checks.<\/td>\n<\/tr>\n<tr>\n<td>Struct with <code>#[wasm_bindgen]<\/code><\/td>\n<td>JavaScript object with same fields<\/td>\n<td>Fields become properties; methods are exposed.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h3>Table 2: Essential Crates for Rust\u2011Wasm Development<\/h3>\n<table border=\"1\" cellpadding=\"5\" style=\"border-collapse: collapse;\">\n<thead>\n<tr>\n<th>Crate Name<\/th>\n<th>Purpose<\/th>\n<th>Example Use<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>wasm-bindgen<\/code><\/td>\n<td>Core binding generation; exports and imports for JS\u2194Rust<\/td>\n<td>Annotating functions; calling <code>alert<\/code> from Rust.<\/td>\n<\/tr>\n<tr>\n<td><code>web-sys<\/code><\/td>\n<td>Raw bindings to all Web APIs (DOM, CSS, WebGL, etc.)<\/td>\n<td>Manipulating <code>document<\/code>, creating <code>&lt;canvas&gt;<\/code>.<\/td>\n<\/tr>\n<tr>\n<td><code>js-sys<\/code><\/td>\n<td>Bindings to JavaScript built\u2011ins (Math, JSON, Array, etc.)<\/td>\n<td>Using <code>Math.random()<\/code> or <code>JSON.parse()<\/code> from Rust.<\/td>\n<\/tr>\n<tr>\n<td><code>console_error_panic_hook<\/code><\/td>\n<td>Redirects Rust panic messages to browser console<\/td>\n<td>Call <code>set_once()<\/code> to debug crashes.<\/td>\n<\/tr>\n<tr>\n<td><code>gloo<\/code><\/td>\n<td>High\u2011level, ergonomic wrappers over web\u2011sys<\/td>\n<td>Easier timers, storage, file APIs.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2>Frequently Asked Questions<\/h2>\n<h3>1. Can I use the full Rust standard library with WebAssembly?<\/h3>\n<p>Yes, to a large extent. The default <code>wasm32\u2011unknown\u2011unknown<\/code> target includes a partially implemented standard library. Features like <code>Vec<\/code>, <code>String<\/code>, <code>HashMap<\/code>, and most of <code>std::io<\/code> work, but file system and networking are not available in the browser. The <code>std::time<\/code> module uses the browser&#8217;s <code>performance.now()<\/code>. If you need <code>std::thread<\/code>, that requires WebAssembly threads (shared memory), which is experimental and requires specific HTTP headers.<\/p>\n<h3>2. How does Rust\u2011Wasm performance compare to plain JavaScript?<\/h3>\n<p>For number\u2011crunching, sorting, parsing, and algorithms with predictable control flow, Rust\u2011Wasm is typically 2x to 10x faster than equivalent JavaScript. JavaScript&#8217;s JIT can sometimes surprise you, but Rust&#8217;s compiled WebAssembly generally wins for tight loops and heavy math. The biggest gains come when you can avoid garbage collection pauses. However, DOM interactions and frequent small function calls may negate the advantage due to the cross\u2011boundary overhead.<\/p>\n<h3>3. What about debugging? Can I set breakpoints inside Rust code?<\/h3>\n<p>Yes, but limited. If you compile with debug symbols and source maps (using <code>wasm-pack build --debug<\/code> or a custom <code>.cargo\/config.toml<\/code>), you can step through Rust source in Chrome DevTools. However, the mapping isn&#8217;t perfect\u2014variables may appear as raw WebAssembly locals. A more practical approach is to write unit tests in Rust using <code>cargo test<\/code> and keep the browser\u2011specific logic minimal. Use <code>console.log<\/code> from Rust to print state during development.<\/p>\n<h3>4. Must I use wasm\u2011pack, or can I compile with cargo directly?<\/h3>\n<p>You can compile with <code>cargo build --target wasm32\u2011unknown\u2011unknown<\/code> and then manually generate JavaScript bindings using <code>wasm\u2011bindgen<\/code>. However, <code>wasm\u2011pack<\/code> automates the entire pipeline\u2014compilation, binding generation, and optimisation\u2014and is the recommended tool. It also integrates with npm, making publishing to npm registries trivial.<\/p>\n<h3>5. How do I handle asynchronous operations like fetching data in Rust?<\/h3>\n<p>Rust&#8217;s async\/await works in Wasm, but you must use a runtime like <code>wasm\u2011bindgen\u2011futures<\/code> (crate <code>wasm\u2011bindgen\u2011futures<\/code>). This crate bridges Rust futures to JavaScript promises. For example, you can write an <code>async fn fetch_data()<\/code> that uses <code>web_sys::window().unwrap().fetch_with_str(url)<\/code> and then <code>.await<\/code> its result. The JavaScript event loop drives the future. Alternatively, you can pass closures to JavaScript callbacks, though that pattern is more verbose.<\/p>\n<h3>6. Can I share memory between multiple Wasm instances?<\/h3>\n<p>WebAssembly itself does not support shared memory between multiple instances of the same module unless you explicitly create a <code>WebAssembly.Memory<\/code> object with <code>shared: true<\/code>. Rust&#8217;s standard library does not yet expose shared memory easily. For multi\u2011threaded Wasm, you need to enable the <code>atomics<\/code> and <code>bulk\u2011memory<\/code> proposals and use <code>std::sync::atomic<\/code> carefully. This is an advanced scenario and not recommended for beginners.<\/p>\n<h2>Conclusion<\/h2>\n<p>Rust and WebAssembly together offer a compelling path for developers who need to push the boundaries of what&#8217;s possible inside a web browser. By following the steps outlined in this tutorial\u2014setting up the toolchain, creating a project with <code>wasm\u2011pack<\/code>, writing bindings with <code>wasm\u2011bindgen<\/code>, compiling, and integrating into a web page\u2014you now have the foundation to build high\u2011performance modules for anything from image filters to cryptographic hashing to game engines. The journey doesn&#8217;t end here; the Rust\u2011Wasm ecosystem is growing rapidly, with libraries like <code>yew<\/code> (React\u2011like framework) and <code>leptos<\/code> (fine\u2011grained reactivity) blurring the line between frontend and systems programming. Remember to keep a sharp eye on binary size, minimise cross\u2011boundary traffic, and always measure before and after optimisation. Armed with Rust&#8217;s safety guarantees and WebAssembly&#8217;s speed, you are equipped to create web applications that were previously the domain of native apps. Now go forth, compile, and make the web faster\u2014one Wasm module at a time.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>How to Use Rust for WebAssembly: A Step-by-Step Guide to Building Blazing Fast Web Applications WebAssembly (Wasm) has revolutionized client-side performance by enabling near-native execution speeds in the browser. While JavaScript remains the lingua franca of the web, its dynamic nature imposes overhead that can cripple computationally intensive tasks\u2014think image processing, data compression, game physics, &hellip; <\/p>\n","protected":false},"author":2716,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"footnotes":""},"categories":[],"tags":[],"class_list":["post-1063","post","type-post","status-publish","format-standard","hentry"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/posts\/1063","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/users\/2716"}],"replies":[{"embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/comments?post=1063"}],"version-history":[{"count":0,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/posts\/1063\/revisions"}],"wp:attachment":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/media?parent=1063"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/categories?post=1063"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/tags?post=1063"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}