Baike.dev
All toolsOnline toolsAI codingTrendingOpen sourceNewsSubmit
Log in
< Back to tools
M

marine

> 编程语言
Open source

Marine runs multi-module WebAssembly applications with interface-types and shared-nothing linking scheme

200 stars0 likes0 views
WebsiteGitHub

About

Marine runs multi-module WebAssembly applications with interface-types and shared-nothing linking scheme

Marine

Marine is a modern general purpose Wasm runtime based on the component model capable of running multi-module Wasm applications, aka services, with interface-types and a shared-nothing linking scheme. This execution model is well suited for a variety of scenarios and especially applicable to implementations following the entity component system (ECS) pattern or plugin-based architectures.

Fluence peers, such as Fluence Rust node, include Marine to execute the hosted Wasm services composed with Aqua.

Motivational example

To illustrate the capabilities of Marine, let's have a look at a multi-module Wasm service as implemented in this example.

cd into the examples/motivational-example directory and have a look at the shrek/src/main.rs file:

rust
// examples/motivational-example/shrek/src/main.rs
use marine_rs_sdk::marine;

fn main() {}

#[marine]
pub fn greeting(name: &str) -> Vec {
    let donkey_greeting = donkey::greeting(name);         // 1
    let shrek_greeting = format!("Shrek: hi, {}", name);  // 2
    
    vec![shrek_greeting, donkey_greeting]                 
}

mod donkey {                                               // 3
    use super::*;

    #[marine]
    #[link(wasm_import_module = "donkey")]                 // 4
    extern "C" {
        pub fn greeting(name: &str) -> String;
    }
}

In this Marine (Wasm) module (and namespace) shrek, we declare a function greeting that creates a donkey_greeting (1) from the donkey module's (3)greeting function, which itself is dependent on importing the donkey Wasm module with Rust's FFI link (4) from donkey/src/main.rs (see below).

rust
// examples/motivational-example/donkey/src/main.rs
use marine_rs_sdk::marine;

fn main() {}

#[marine]
pub fn greeting(name: &str) -> String {
    format!("Donkey: hi, {}", name)
}

In summary, our example is comprised of two independent Wasm modules, shrek and donkey, and illustrates how to link one module into another one, i.e., use the donkey module in the shrek module. Please note that the shrek module is called a facade module following the facade pattern and there can only be one facade module per service.

Make sure you have the Marine tools installed and compile the donkey and shrek, respectively, which we can do with the build.sh script:

bash
$> ./build.sh

which creates two independent Wasm modules that are placed in the artifacts directory:

bash
$> ls artifacts
donkey.wasm    shrek.wasm

Now that we have our modules, we can explore them with the Marine REPL. Note that we use the Config.toml file to help out the REPL by providing the module location and names. Once we got the REPL up and running, we can interact with both modules and, as expected, the shrek module is successfully able to access the donkey module's exposed functions.

bash
$> marine repl Config.toml
...
1> interface
Loaded modules interface:

shrek:
  fn greeting(name: string) -> []string
donkey:
  fn greeting(name: string) -> string

2> call donkey greeting "no link module"
result: "Donkey: hi, no link module"
 elapsed time: 42.985µs

3> call shrek greeting "facade with link module"
result: [
  "Shrek: hi, facade with link module",
  "Donkey: hi, facade with link module"
]
 elapsed time: 39.25µs

4> q

Looks like everything is in order and the modules are ready for deployment to the network and composition with Aqua.

Documentation

  • Marine Book
  • Marine Examples
  • Marine Quick start

Do not forget to check our YouTube channel.

Repository structure

  • crates
    • it-generator: a generator of IT
    • it-interfaces: a handy structure for interface types handling
    • it-json-serde: a crate for conversion between IT and JSON
    • min-it-version keeps minimal supported versions of IT and SDK by runtime
    • module-info-parser: a parser of the module manifest and the SDK version
    • module-interface: a parser of module IT
    • utils: some utility functions and consts
  • examples: several Marine examples used mostly for tests
  • fluence-faas: a Fluence FaaS layer that provides host closures, ITJSON conversion, logger, config handling and other things
  • fluence-app-service: a Fluence Application Service layer that provides basic API for service running
  • runtime: a runtime layer that provides basic functionality for loading, unloading and calling modules
  • marine-js: a web runtime layer aimed to run Marine in a browser
  • tools
    • REPL: a REPL intended to test Marine Wasm modules
    • CLI: a CLI intended to build and extract some info from Marine Wasm modules

Support

Please, file an issue if you find a bug. You can also contact us at Discord or Telegram. We will do our best to resolve the issue ASAP.

Contributing

Any interested person is welcome to contribute to the project. Please, make sure you read and follow some basic rules.

License

All software code is copyright (c) Fluence DAO under the AGPLv3 license.

Issues· 27 open

View all issuesOpen on GitHub

No open issues yet, or sync has not completed.

> Tags

Rustinterface-typesruntimevirtual-machinewasm

No comments yet. Be the first to share.

> Details

PublishedAug 1, 2026
UpdatedSep 18, 2026
Category编程语言
PricingOpen source

> Related tools

T
TypeScript
JavaScript 的超集,为前端与全栈提供静态类型
P
Python
通用编程语言,广泛用于 Web、数据与 AI
G
Go
Google 推出的简洁高效系统语言