# アーキテクチャ設計書

## 概要

本ドキュメントは、mruby（軽量Ruby実装）のソフトウェアアーキテクチャを記述する設計書である。mrubyは、組み込みシステムへの統合を主目的とした軽量なRuby言語処理系であり、ISO標準に準拠しつつ、Ruby 3.x互換の構文をサポートする。C言語で実装されたコアランタイムと、拡張可能なGem（mrbgems）パッケージシステムを中心に構成されている。

## システム全体構成

### アーキテクチャ概要図

[アーキテクチャ構成図](./アーキテクチャ構成図.md) を参照。

### システム境界と外部連携

| 外部システム | 連携方式 | 用途 |
| --- | --- | --- |
| ホストアプリケーション（C/C++） | C API（libmruby リンク） | mrubyをアプリケーションに組み込み、Rubyスクリプトを実行する |
| OS / ランタイム | POSIX / Win32 API | ファイルI/O、ソケット、ディレクトリ操作、メモリ割り当て等のプラットフォーム抽象化 |
| ビルドツールチェーン | Rake / C コンパイラ | ソースコードのコンパイル、テスト、バイナリ生成 |
| 外部mrbgems | Git / mrbgems パッケージマネージャ | 外部GEMの取得とビルド統合 |

## レイヤー構成

### アーキテクチャスタイル

mrubyは **レイヤードアーキテクチャ** と **コンポーネントベースアーキテクチャ** のハイブリッド構成を採用している。コアランタイムがレイヤー構造で構成され、拡張機能はmrbgemsとしてプラグイン的に追加される設計である。

具体的には以下の特徴を持つ:
- **レイヤード構成**: フロントエンド（パーサ/コンパイラ） -> 中間表現（IREP） -> バックエンド（VM） という処理パイプライン
- **コンポーネントベース**: mrbgemsによるモジュラーな拡張システム
- **組み込み指向設計**: メモリ管理やコンフィギュレーションの高いカスタマイズ性

### レイヤー定義

| レイヤー | 責務 | 主なコンポーネント |
| --- | --- | --- |
| フロントエンド（コンパイラ） | Rubyソースコードの解析、AST構築、バイトコード生成 | `mruby-compiler`（parse.y, codegen.c, lex.def） |
| 中間表現（IREP） | コンパイル済みバイトコードの表現、シリアライズ/デシリアライズ | `irep.h`, `load.c`, `dump.c`, `cdump.c` |
| 実行エンジン（VM） | レジスタベースの仮想マシンによるバイトコード実行 | `vm.c`, `opcode.h`, `ops.h` |
| コアランタイム | オブジェクトシステム、クラス階層、組み込みクラスの実装 | `class.c`, `object.c`, `string.c`, `array.c`, `hash.c`, `numeric.c`, `proc.c`, `range.c`, `symbol.c`, `kernel.c`, `enum.c`, `variable.c` |
| メモリ管理 | GC（ガベージコレクション）、メモリプール、メモリ割り当て | `gc.c`, `mempool.c`, `allocf.c` |
| 値表現（Boxing） | Ruby値のC表現方式（Word Boxing, NaN Boxing, No Boxing） | `boxing_word.h`, `boxing_nan.h`, `boxing_no.h`, `value.h` |
| ビルドシステム | コンパイル設定、ツールチェーン管理、GEM管理 | `Rakefile`, `lib/mruby/build.rb`, `tasks/*.rake` |
| Rubyコアライブラリ（mrblib） | Rubyで記述されたコアメソッドの実装 | `mrblib/*.rb` |
| 拡張ライブラリ（mrbgems） | プラグイン式の標準/拡張ライブラリ群 | `mrbgems/mruby-*` |
| HAL（ハードウェア抽象化層） | プラットフォーム固有のI/O、ソケット、タスク等の抽象化 | `mrbgems/hal-posix-*`, `mrbgems/hal-win-*` |

### レイヤー間の依存関係ルール

- **フロントエンド -> 中間表現**: コンパイラはIREP構造体を出力する。逆方向の依存は存在しない。
- **中間表現 -> 実行エンジン**: VMはIREPを読み込み実行する。IREPはVMに依存しない。
- **実行エンジン -> コアランタイム**: VMはオブジェクトシステム、クラス階層、メソッドテーブルを利用する。
- **コアランタイム -> メモリ管理**: 全てのオブジェクト生成・破棄はGCとメモリアロケータを通じて行われる。
- **mrbgems -> コアランタイム**: GEMはコアのC APIおよびmrblib APIを利用して拡張を提供する。コアはGEMに依存しない（コンパイラGEMを除く）。
- **mrblib -> コアランタイム**: Rubyで記述されたコアライブラリは、Cで実装されたプリミティブの上に構築される。
- **禁止される参照**: コアランタイムから個別のmrbgemsへの直接依存は禁止。mrbgemsからVMの内部実装への直接アクセスは禁止。

## モジュール構成

### ドメイン分割

| ドメイン | 責務 | 関連モジュール |
| --- | --- | --- |
| 言語処理（コンパイル） | Rubyソースの解析とバイトコードへの変換 | `mruby-compiler` (parse.y, codegen.c, lex.def, keywords) |
| 仮想マシン | バイトコードのフェッチ・デコード・実行 | `vm.c`, `opcode.h`, `ops.h` |
| オブジェクトシステム | クラス/モジュール/メソッドの管理 | `class.c`, `object.c`, `proc.c`, `variable.c` |
| 組み込み型 | 基本データ型の実装 | `string.c`, `array.c`, `hash.c`, `numeric.c`, `range.c`, `symbol.c` |
| 例外処理 | 例外の生成・発生・捕捉 | `error.c`, `backtrace.c` |
| メモリ管理 | オブジェクトのライフサイクル管理 | `gc.c`, `mempool.c`, `allocf.c` |
| バイナリI/O | mrbcバイナリのダンプ・ロード | `dump.c`, `load.c`, `cdump.c` |
| デバッグ | デバッグ情報の管理 | `debug.c`, `codedump.c` |
| 状態管理 | mrb_stateのライフサイクル管理 | `state.c`, `init.c`, `version.c` |
| 標準ライブラリ | コア型の拡張・追加クラス | `mrbgems/mruby-*` |
| コマンドラインツール | mruby, mrbc, mirb, mrdb 等の実行ファイル | `mrbgems/mruby-bin-*` |
| プラットフォーム抽象化 | OS固有機能のHAL | `mrbgems/hal-posix-*`, `mrbgems/hal-win-*` |

### パッケージ構造

```
mruby/
├── include/                    # C APIヘッダファイル
│   ├── mruby.h                 # メインヘッダ（mrb_state, mrb_value等の定義）
│   ├── mrbconf.h               # ビルド時設定（boxing, int size, GC等）
│   └── mruby/                  # サブヘッダ群
│       ├── value.h             # mrb_value型定義、型判定マクロ
│       ├── boxing_word.h       # Word Boxing実装
│       ├── boxing_nan.h        # NaN Boxing実装
│       ├── boxing_no.h         # No Boxing実装
│       ├── gc.h                # GC構造体定義
│       ├── class.h             # クラス構造体定義
│       ├── proc.h              # Proc/メソッド構造体定義
│       ├── irep.h              # IREP（中間表現）構造体定義
│       ├── compile.h           # コンパイラ/パーサインターフェース
│       ├── opcode.h            # VM命令セット定義
│       ├── ops.h               # 命令テーブル
│       ├── string.h            # String構造体定義
│       ├── array.h             # Array構造体定義
│       ├── hash.h              # Hash構造体定義
│       ├── error.h             # 例外関連定義
│       ├── dump.h              # バイナリダンプ定義
│       ├── variable.h          # 変数テーブル定義
│       ├── numeric.h           # 数値関連定義
│       ├── range.h             # Range構造体定義
│       ├── data.h              # Cデータラッパー定義
│       ├── debug.h             # デバッグ情報定義
│       ├── internal.h          # 内部API（公開APIに含まれない）
│       ├── khash.h             # ハッシュテーブル実装
│       ├── mempool.h           # メモリプール定義
│       ├── presym.h            # 事前定義シンボル
│       └── version.h           # バージョン情報
├── src/                        # コアCソースコード
│   ├── state.c                 # mrb_stateのopen/close
│   ├── init.c                  # コア初期化シーケンス
│   ├── vm.c                    # 仮想マシン実行エンジン
│   ├── gc.c                    # ガベージコレクタ（Tri-color Incremental GC）
│   ├── class.c                 # クラス/モジュールシステム
│   ├── object.c                # Objectクラス
│   ├── string.c                # Stringクラス
│   ├── array.c                 # Arrayクラス
│   ├── hash.c                  # Hashクラス
│   ├── numeric.c               # Numeric/Integer/Floatクラス
│   ├── symbol.c                # Symbolクラス
│   ├── proc.c                  # Procクラス
│   ├── range.c                 # Rangeクラス
│   ├── kernel.c                # Kernelモジュール
│   ├── enum.c                  # Enumerableモジュール
│   ├── error.c                 # 例外クラス
│   ├── variable.c              # 変数テーブル管理
│   ├── load.c                  # mrbcバイナリローダ
│   ├── dump.c                  # mrbcバイナリダンパ
│   ├── cdump.c                 # C配列形式ダンパ
│   ├── allocf.c                # デフォルトメモリアロケータ
│   ├── mempool.c               # メモリプール
│   ├── debug.c                 # デバッグ情報管理
│   ├── codedump.c              # バイトコードダンプ（デバッグ用）
│   ├── backtrace.c             # バックトレース生成
│   ├── etc.c                   # ユーティリティ関数
│   ├── fmt_fp.c                # 浮動小数点フォーマット
│   ├── print.c                 # 出力関数
│   ├── readfloat.c             # 浮動小数点読み取り
│   ├── readint.c               # 整数読み取り
│   ├── readnum.c               # 数値読み取りユーティリティ
│   ├── numops.c                # 数値演算
│   └── version.c               # バージョン情報
├── mrblib/                     # Rubyで記述されたコアライブラリ
│   ├── array.rb                # Array拡張メソッド
│   ├── hash.rb                 # Hash拡張メソッド
│   ├── string.rb               # String拡張メソッド
│   ├── numeric.rb              # Numeric拡張メソッド
│   ├── range.rb                # Range拡張メソッド
│   ├── enum.rb                 # Enumerable拡張メソッド
│   ├── compar.rb               # Comparable拡張メソッド
│   ├── kernel.rb               # Kernel拡張メソッド
│   ├── symbol.rb               # Symbol拡張メソッド
│   └── 10error.rb              # 例外クラス定義
├── mrbgems/                    # 拡張ライブラリパッケージ
│   ├── *.gembox                # GEM集約定義（default, stdlib, math等）
│   ├── mruby-compiler/         # コンパイラ（パーサ + コード生成）
│   ├── mruby-bin-mrbc/         # mrbcコマンド（バイトコードコンパイラ）
│   ├── mruby-bin-mruby/        # mrubyコマンド（インタプリタ）
│   ├── mruby-bin-mirb/         # mirbコマンド（対話型シェル）
│   ├── mruby-bin-debugger/     # mrdbコマンド（デバッガ）
│   ├── mruby-bin-strip/        # mruby-stripコマンド
│   ├── mruby-bin-config/       # mruby-configコマンド
│   ├── mruby-eval/             # eval実装
│   ├── mruby-fiber/            # Fiberクラス
│   ├── mruby-io/               # I/Oクラス
│   ├── mruby-socket/           # Socketクラス
│   ├── mruby-dir/              # Dirクラス
│   ├── mruby-time/             # Timeクラス
│   ├── mruby-math/             # Mathモジュール
│   ├── mruby-bigint/           # BigInteger実装
│   ├── mruby-error/            # 拡張エラーハンドリング
│   ├── mruby-sprintf/          # sprintf/format実装
│   ├── mruby-random/           # Random実装
│   ├── mruby-struct/           # Struct実装
│   ├── mruby-set/              # Set実装
│   ├── mruby-complex/          # Complex実装
│   ├── mruby-rational/         # Rational実装
│   ├── mruby-enumerator/       # Enumerator実装
│   ├── mruby-task/             # Task（スケジューラ）実装
│   ├── hal-posix-*/            # POSIX HAL（I/O, ソケット, ディレクトリ, タスク）
│   └── hal-win-*/              # Windows HAL（I/O, ソケット, ディレクトリ, タスク）
├── lib/                        # ビルドシステム用Rubyスクリプト
│   └── mruby/
│       ├── build.rb            # ビルドシステムコア
│       ├── gem.rb              # GEM管理
│       ├── core_ext.rb         # Rubyコア拡張
│       ├── presym.rb           # 事前定義シンボル生成
│       ├── lockfile.rb         # ロックファイル管理
│       ├── source.rb           # ソース管理
│       ├── doc.rb              # ドキュメント生成
│       └── amalgam.rb          # アマルガメーション（単一ファイルビルド）
├── tasks/                      # Rakeタスク定義
│   ├── core.rake               # コアビルドタスク
│   ├── mrblib.rake             # mrblibコンパイルタスク
│   ├── mrbgems.rake            # GEMビルドタスク
│   ├── libmruby.rake           # libmrubyリンクタスク
│   ├── bin.rake                # バイナリ生成タスク
│   ├── presym.rake             # 事前定義シンボルタスク
│   ├── test.rake               # テストタスク
│   ├── benchmark.rake          # ベンチマークタスク
│   ├── doc.rake                # ドキュメント生成タスク
│   ├── install.rake            # インストールタスク
│   ├── amalgam.rake            # アマルガメーションタスク
│   └── toolchains/             # ツールチェーン定義
├── build_config/               # ビルド設定ファイル群
│   ├── default.rb              # デフォルトビルド設定
│   ├── minimal.rb              # 最小構成
│   ├── host-debug.rb           # デバッグ構成
│   └── *.rb                    # 各種プラットフォーム向け設定
├── test/                       # テストコード
├── tools/                      # 外部ツール
│   └── lrama/                  # LALRパーサジェネレータ
├── benchmark/                  # ベンチマーク
├── examples/                   # 使用例
├── doc/                        # ドキュメント
└── oss-fuzz/                   # ファジングテスト
```

### コンポーネント依存関係

主要コンポーネント間の依存関係は以下の通りである:

1. **mrb_state（状態管理）** が全コンポーネントの中心。全てのコンポーネントはmrb_stateを通じて相互作用する。
2. **VM（vm.c）** はIREP、クラスシステム、GC、全ての組み込み型に依存する。
3. **コンパイラ（mruby-compiler）** はIREP構造体とメモリプールに依存する。コアランタイムのクラスシステムには間接的に依存する。
4. **GC（gc.c）** は全てのオブジェクト型のマーキング処理に依存するが、個別の型実装には依存しない（コールバック方式）。
5. **組み込み型** は相互に依存関係を持つ（例: Stringとsymbol変換、ArrayとHash変換等）。
6. **mrbgems** はコアAPIのみに依存し、相互依存は個別のGEM定義（mrbgem.rake）で管理される。

## ミドルウェア構成

### データベース

mrubyは言語処理系であり、外部データベースへの依存は存在しない。

| 種類 | ミドルウェア | バージョン | 用途 |
| --- | --- | --- | --- |
| 該当なし | - | - | mrubyは組み込み型言語処理系のため、外部DBへの依存なし |

### キャッシュ

| ミドルウェア | バージョン | 用途 | TTL |
| --- | --- | --- | --- |
| メソッドキャッシュ（内部実装） | - | メソッドルックアップの高速化。`MRB_METHOD_CACHE_SIZE` で設定可能（デフォルト256エントリ） | キャッシュ無効化はクラス階層変更時 |

### メッセージキュー

| ミドルウェア | バージョン | 用途 |
| --- | --- | --- |
| 該当なし | - | 外部メッセージキューへの依存なし |

### 検索エンジン

| ミドルウェア | バージョン | 用途 |
| --- | --- | --- |
| 該当なし | - | 外部検索エンジンへの依存なし |

### その他ミドルウェア

| ミドルウェア | バージョン | 用途 |
| --- | --- | --- |
| khash（内部ハッシュテーブル） | - | シンボルテーブル、変数テーブル等の高速ルックアップに使用。`include/mruby/khash.h` でマクロベースに実装 |
| mempool（内部メモリプール） | - | パーサのAST/トークン等の一時的なメモリ割り当て。`src/mempool.c` で実装 |
| lrama（LALRパーサジェネレータ） | - | parse.yからパーサを生成するビルドツール。`tools/lrama/` に配置 |

## データフロー

### リクエスト処理の流れ

mrubyにおける「リクエスト」はRubyスクリプトの実行である。以下は文字列からの実行フローを示す。

1. **mrb_open()**: mrb_stateの生成。メモリアロケータ初期化、GC初期化、コアクラス初期化（init.c: mrb_init_core）、mrbgems初期化を実行する。
2. **mrb_load_string() / mrb_load_file()**: ソースコード入力。コンパイラコンテキスト（mrb_ccontext）を任意で生成する。
3. **パース（mrb_parse_string/mrb_parse_file）**: レキサーがトークンを生成し、LALRパーサ（parse.y）がAST（抽象構文木）を構築する。メモリプールを使用して一時メモリを管理する。
4. **コード生成（mrb_generate_code）**: ASTをトラバースし、IREP（中間表現）を生成する。IREPにはバイトコード命令列（iseq）、リテラルプール（pool）、シンボルテーブル（syms）、子IREP（reps）が含まれる。
5. **VM実行（mrb_vm_exec）**: レジスタベースVMがバイトコードをフェッチ・デコード・実行する。コールスタック（mrb_callinfo）とレジスタスタック（mrb_value配列）を用いて関数呼び出しを管理する。
6. **結果返却**: 実行結果がmrb_value として返される。例外発生時はmrb->excにセットされる。
7. **mrb_close()**: atexit関数呼び出し、グローバル変数解放、GC破棄、コンテキスト解放、シンボルテーブル解放、mrb_state自体の解放を実行する。

### 非同期処理の流れ

mrubyのコアは基本的にシングルスレッド・同期実行モデルである。ただし、以下の機構が存在する:

1. **Fiber**: 協調的なコルーチンを提供する。`mruby-fiber` GEMで実装され、mrb_context構造体の切り替えによって状態を管理する。Fiber.yield / Fiber#resume でコンテキストスイッチを行う。
2. **Task（mruby-task GEM）**: `MRB_USE_TASK_SCHEDULER` 定義時に有効化される軽量タスクスケジューラ。dormant/ready/waiting/suspended の4つのキューでタスクを管理し、tick ベースのスケジューリングを行う。
3. **バイナリローダ**: 事前コンパイル済みのmrbcバイナリをランタイムでロードする。`mrb_load_irep()` / `mrb_load_irep_buf()` を使用。

### データ永続化の流れ

mrubyにおけるデータ永続化は、バイトコードのバイナリ形式での保存・復元が該当する:

1. **コンパイル（mrbc）**: Rubyスクリプト -> パース -> コード生成 -> IREP
2. **ダンプ（dump.c）**: IREP -> バイナリ形式（.mrb ファイル）。mrb_dump_irep() でバイナリ化する。
3. **Cダンプ（cdump.c）**: IREP -> C配列形式。コンパイル時にCソースファイルとして埋め込み可能にする。
4. **ロード（load.c）**: バイナリ形式 -> IREP -> RProc。mrb_load_irep() でバイナリからIREPを復元し、実行可能なProcオブジェクトに変換する。

## 横断的関心事

### 認証・認可

mrubyは言語処理系であり、認証・認可機構は含まない。

| 方式 | 実装箇所 | 対象 |
| --- | --- | --- |
| 該当なし | - | 言語処理系のため認証・認可は不要 |

### ロギング・監査

| 種類 | 実装方式 | 保存先 |
| --- | --- | --- |
| デバッグ出力 | `mrb_p()`, `mrb_print()`, `mrb_show_copyright()`, `mrb_show_version()` （print.c） | 標準出力（stdout） |
| バイトコードダンプ | `mrb_codedump_all()` （codedump.c） | 標準出力。コンパイラコンテキストの `dump_result` フラグで制御 |
| デバッグフック | `MRB_USE_DEBUG_HOOK` 定義時に有効。VMの各命令実行時にフックが呼ばれる | デバッガ（mrdb）による制御 |

### エラーハンドリング

mrubyのエラーハンドリングは、Ruby言語の例外機構をCレベルで実装したものである。

| エラー種別 | ハンドリング方式 | レスポンス |
| --- | --- | --- |
| Ruby例外（Exception） | setjmp/longjmp ベースの例外機構（`mruby/throw.h`）。rescue/ensure はIREPの catch handler テーブルで管理 | mrb->exc にRExceptionオブジェクトをセット |
| メモリ不足（NoMemoryError） | GCのout_of_memoryフラグ。mrb_malloc失敗時に発生 | NoMemoryError例外をraise |
| スタックオーバーフロー | `MRB_CALL_LEVEL_MAX`（デフォルト512）によるコールスタック深さ制限、`MRB_STACK_MAX` によるスタックサイズ制限 | SystemStackError相当の例外をraise |
| C API実行エラー | mrb_core_init_protect() で初期化時の例外を捕捉。mrb->excの存在チェックで判定 | mrb->excにエラー情報をセットし、呼び出し元に返す |
| IRep参照カウントオーバーフロー | irep->refcntがUINT16_MAXに達した場合にGCを実行し、それでも解消しなければRuntimeError | RuntimeError例外をraise |

### トランザクション管理

mrubyは言語処理系であり、トランザクション管理機構は含まない。

| 範囲 | 管理方式 | 分離レベル |
| --- | --- | --- |
| GCアリーナ | `mrb_gc_arena_save()` / `mrb_gc_arena_restore()` によるオブジェクト保護範囲の管理。C API利用時にGCからオブジェクトを保護するために使用 | - |
| IREPライフサイクル | 参照カウント方式（`mrb_irep_incref()` / `mrb_irep_decref()`）でIREPの共有と解放を管理 | - |

## 設計原則・コーディング規約

### 適用している設計原則

| 原則 | 適用箇所 | 実装例 |
| --- | --- | --- |
| 関心の分離 | コンパイラ/VM/GC/型システムの明確な分離 | `mruby-compiler` がGEMとして分離。VM（vm.c）とGC（gc.c）が独立したモジュール |
| 依存性逆転 | メモリアロケータのカスタマイズ | `mrb_basic_alloc_func()` をユーザが再定義可能。HAL層によるプラットフォーム抽象化 |
| 開放閉鎖原則 | mrbgemsによる拡張機構 | コアを変更せずにGEMの追加/削除で機能を拡張。gemboxによるGEMセットの定義 |
| コンパイル時設定 | `mrbconf.h` による構成オプション | `MRB_WORD_BOXING`/`MRB_NAN_BOXING`/`MRB_NO_BOXING`、`MRB_INT32`/`MRB_INT64`、`MRB_NO_FLOAT`、`MRB_NO_STDIO`、プロファイル設定等 |
| 最小権限の原則 | 公開API（MRB_API）と内部API（internal.h）の分離 | `MRB_API` マクロで公開関数を明示。`internal.h` は内部専用 |
| ポータビリティ | プラットフォーム非依存のコア設計 | HAL層による抽象化、条件コンパイルによるプラットフォーム対応、boxing方式の選択可能性 |

### コーディング規約

- **命名規則**: 全てのパブリック関数は `mrb_` プレフィックスを使用。マクロは `MRB_` プレフィックスを使用。構造体はPascalCase（例: `RClass`, `RString`）。
- **メモリ管理**: 全てのヒープ割り当ては `mrb_malloc()` / `mrb_realloc()` / `mrb_free()` を通じて行う。直接的な `malloc()` / `free()` の使用はデフォルトアロケータ（`allocf.c`）およびメモリプール（`mempool.c`）のみ。
- **GCアリーナ管理**: C APIからオブジェクトを生成する場合、`mrb_gc_arena_save()` / `mrb_gc_arena_restore()` で保護する。コア初期化では各初期化関数呼び出し後に `DONE` マクロでアリーナを復元する。
- **API安定性**: `MRB_API` マクロで修飾された関数が公開APIであり、安定性が保証される。`internal.h` の関数は内部使用限定で変更可能。
- **条件コンパイル**: 機能の有効化/無効化は `MRB_USE_*` / `MRB_NO_*` マクロで制御する。プラットフォーム固有コードは `#ifdef` で分離する。
- **エラーハンドリング**: C関数からの例外発生は `mrb_raise()` を使用。NULL返却はメモリ割り当て失敗を示す。`mrb->exc` のチェックで例外状態を判定する。

## 備考

- mrubyはバージョン3.4.0が最新安定版であり、ISO標準（ISO/IEC 30170:2012）に準拠しつつ、Ruby 3.x互換の構文を提供する（パターンマッチングを除く）。
- アマルガメーション（`rake amalgam`）により、全ソースを `mruby.c` と `mruby.h` の2ファイルに統合でき、SQLite同様の容易な組み込みが可能。
- ビルド設定は `build_config/*.rb` で管理され、Arduino Due、Android、Emscripten、Nintendo Switch、PlayStation Portable等の多様なプラットフォーム向け設定が提供されている。
- チューニングプロファイル（`MRB_CONSTRAINED_BASELINE_PROFILE`、`MRB_BASELINE_PROFILE`、`MRB_MAIN_PROFILE`、`MRB_HIGH_PROFILE`）により、マイクロコントローラからサーバまでのリソース特性に応じた設定が可能。
