Update version to 4.0.0RC3.

Bumps the pre-commit-hooks group with 1 update: [https://github.com/rhysd/actionlint](https://github.com/rhysd/actionlint).


Updates `https://github.com/rhysd/actionlint` from v1.7.11 to 1.7.12
- [Release notes](https://github.com/rhysd/actionlint/releases)
- [Changelog](https://github.com/rhysd/actionlint/blob/main/CHANGELOG.md)
- [Commits](https://github.com/rhysd/actionlint/compare/v1.7.11...v1.7.12)

---
updated-dependencies:
- dependency-name: https://github.com/rhysd/actionlint
  dependency-version: 1.7.12
  dependency-type: direct:production
  dependency-group: pre-commit-hooks
...

Signed-off-by: dependabot[bot] <support@github.com>

.codespellrc

@@ -0,0 +1,3 @@
+[codespell]
+ignore-words = .github/linters/codespell.txt
+skip = ./build,./doc/api,./doc/capi

.dockerignore

@@ -0,0 +1,14 @@
+.DS_Store
+.idea
+.vscode
+.yardoc
+*.bak
+*.iml
+*.ipr
+*.swp
+*.tmp
+bin
+build
+doc/api
+doc/capi
+node_modules

.editorconfig

@@ -0,0 +1,30 @@
+# About this file, see:
+#   Website: https://editorconfig.org/
+#   For Emacs users: https://github.com/editorconfig/editorconfig-emacs
+#   For Vim users: https://github.com/editorconfig/editorconfig-vim
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+insert_final_newline = true
+tab_width = 8
+trim_trailing_whitespace = true
+
+[{Makefile,Makefile.*,makefile,*.mk}]
+indent_style = tab
+#max_line_length = 80
+
+#[*.{c,cc,C,cxx,cpp,h,hh,H,hxx,hpp,inc,y}]
+#max_line_length = 120
+
+#[{*.rb,Rakefile,rakefile,*.rake,*.gemspec,*.gembox}]
+#max_line_length = 120
+
+# limitation to US-ASCII
+[*.bat]
+end_of_line = crlf
+#max_line_length = 80

.git-blame-ignore-revs

@@ -0,0 +1,8 @@
+# Extend the tab with 8 whitespace
+6fc5dc986a5ffc1a74c63ad0617ea1dcc10d3cdd
+# reformatted doc/opcode.md
+61e8a540869c57ebddac53cf9d243db407d57fff
+# reindent parse.y
+650ffb9d8410e1ae2206890ef6e2a8643c600454
+# reindent build_config/playstationportable.rb
+90ab714fda6825c4e951d47d7e6ecff033dd14e3

.gitattributes

@@ -0,0 +1,4 @@
+*       text=auto eol=lf
+*.bat   text eol=crlf
+*.cmd   text eol=crlf
+*.png   binary

.github/dependabot.yml

@@ -0,0 +1,33 @@
+# https://docs.github.com/en/code-security/dependabot/dependabot-version-updates
+version: 2
+updates:
+  - package-ecosystem: "bundler"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    groups:
+      bundler-dependencies:
+        patterns:
+          - "*"
+    cooldown:
+      default-days: 7
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    groups:
+      github-actions-dependencies:
+        patterns:
+          - "*"
+    cooldown:
+      default-days: 7
+  - package-ecosystem: "pre-commit"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    groups:
+      pre-commit-hooks:
+        patterns:
+          - "*"
+    cooldown:
+      default-days: 7

.github/labeler.yml

@@ -0,0 +1,81 @@
+# https://github.com/actions/labeler
+benchmark:
+  - any:
+      - changed-files:
+          - any-glob-to-any-file:
+              - benchmark/**/*
+build:
+  - any:
+      - changed-files:
+          - any-glob-to-any-file:
+              - Dockerfile
+              - Doxyfile
+              - Makefile
+              - Rakefile
+              - appveyor.yml
+              - build_config.rb
+              - build_config/**/*
+              - docker-compose.yml
+              - lib/**/*
+              - minirake
+              - tasks/**/*
+              - .codespellrc
+              - .dockerignore
+              - .pre-commit-config.yaml
+              - .prettierignore
+              - .prettierrc
+              - .travis.yml
+              - .yardopts
+core:
+  - any:
+      - changed-files:
+          - any-glob-to-any-file:
+              - include/**/*
+              - mrblib/**/*
+              - src/**/*
+              - test/**/*
+doc:
+  - any:
+      - changed-files:
+          - any-glob-to-any-file:
+              - CONTRIBUTING.md
+              - LEGAL
+              - LICENSE
+              - NEWS
+              - README.md
+              - SECURITY.md
+              - TODO.md
+              - doc/**/*
+              - examples/**/*
+github:
+  - any:
+      - changed-files:
+          - any-glob-to-any-file:
+              - .github/**/*
+miscellaneous:
+  - any:
+      - changed-files:
+          - any-glob-to-any-file:
+              - .editorconfig
+              - .git-blame-ignore-revs
+              - .gitattributes
+              - .gitignore
+              - AUTHORS
+              - Gemfile
+              - Gemfile.lock
+              - mruby-source.gemspec
+mrbgems:
+  - any:
+      - changed-files:
+          - any-glob-to-any-file:
+              - mrbgems/**/*
+oss-fuzz:
+  - any:
+      - changed-files:
+          - any-glob-to-any-file:
+              - oss-fuzz/**/*
+tools:
+  - any:
+      - changed-files:
+          - any-glob-to-any-file:
+              - tools/**/*

.github/linters/.ecrc

@@ -0,0 +1,12 @@
+{
+    "verbose": false,
+    "ignore_defaults": false,
+    "exclude": ["oss-fuzz/", "src/"],
+    "disable": {
+        "end_of_line": false,
+        "trim_trailing_whitespace": false,
+        "insert_final_newline": false,
+        "indent_size": true,
+        "indent_style": true
+   }
+}

.github/linters/.hadolint.yaml

@@ -0,0 +1,4 @@
+failure-threshold: info
+ignored:
+  - DL3008 # https://github.com/hadolint/hadolint/wiki/DL3008
+  - DL3013 # https://github.com/hadolint/hadolint/wiki/DL3013

.github/linters/.ls-lint.yml

@@ -0,0 +1,12 @@
+ls:
+  .c: snake_case
+  .cpp: snake_case
+  .h: snake_case
+  .json: snake_case
+  .rb: snake_case
+  .yaml: regex:\.?[a-z]+(-[a-z]+)*
+  .yml: regex:\.?[a-z]+(-[a-z]+)*
+
+ignore:
+  - build_config
+  - mrbgems/mruby-compiler/core/y.tab.c

.github/linters/.markdown-lint.yml

@@ -0,0 +1,33 @@
+# https://github.com/DavidAnson/markdownlint#rules--aliases
+# https://github.com/igorshubovych/markdownlint-cli
+# markdownlint -c .github/linters/.markdown-lint.yml .
+
+# MD001 heading-increment/header-increment - Heading levels should only increment by one level at a time
+MD001: false
+
+# MD013 line-length - Line length
+MD013: false
+
+# MD014 commands-show-output - Dollar signs used before commands without showing output
+MD014: false
+
+# MD024 no-duplicate-heading/no-duplicate-header - Multiple headings with the same content
+MD024: false
+
+# MD025 single-title/single-h1 - Multiple top-level headings in the same document
+MD025: false
+
+# MD026 no-trailing-punctuation - Trailing punctuation in heading
+MD026: false
+
+# MD029/ol-prefix Ordered list item prefix
+MD029: false
+
+# MD033/no-inline-html - Inline HTML
+MD033: false
+
+# MD040 fenced-code-language - Fenced code blocks should have a language specified
+MD040: false
+
+# MD041 first-line-heading/first-line-h1 - First line in a file should be a top-level heading
+MD041: false

.github/linters/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  DisabledByDefault: true
+  TargetRubyVersion: 3.4
+
+Layout/AssignmentIndentation:
+  Enabled: true
+
+Layout/BlockEndNewline:
+  Enabled: true
+
+Layout/IndentationStyle:
+  Enabled: true
+  EnforcedStyle: spaces

.github/linters/.yaml-lint.yml

@@ -0,0 +1,11 @@
+---
+# https://yamllint.readthedocs.io/en/stable/
+# yamllint --strict -c .github/linters/.yaml-lint.yml .
+extends: default
+
+rules:
+  comments:
+    min-spaces-from-content: 1
+  document-start: disable
+  line-length: disable
+  truthy: false

.github/linters/codespell.txt

@@ -0,0 +1,16 @@
+ans
+celler
+clen
+delet
+disabl
+filetest
+fo
+hel
+ist
+nd
+quitt
+remore
+runn
+sting
+strin
+wronly

.github/workflows/build.yml

@@ -1,149 +1,86 @@
+# https://github.com/actions/runner-images#available-images
 name: Build & Test
 
 on: [push, pull_request]
 
+permissions:
+  contents: read
+
 jobs:
-  Check-Skip:
-    if: |
-      !contains(github.event.head_commit.message, '[ci skip]') &&
-      !contains(github.event.head_commit.message, '[skip ci]') &&
-      !contains(github.event.head_commit.message, '[skip gha]')
-    runs-on: ubuntu-latest
-    steps:
-      - run: echo not skip
-
-  Ubuntu-1604:
-    needs: Check-Skip
-    runs-on: ubuntu-16.04
+  GCC-CLANG:
+    name: "${{ matrix.os }}-${{ matrix.altname || matrix.cc }}"
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 10
+    strategy:
+      fail-fast: false
+      max-parallel: 8
+      matrix:
+        include:
+          - {os: ubuntu-24.04, cc: gcc, cxx: g++}
+          - {os: ubuntu-24.04, cc: clang, cxx: clang++}
+          - {os: ubuntu-22.04, cc: gcc, cxx: g++}
+          - {os: ubuntu-22.04, cc: clang, cxx: clang++}
+          - {os: macos-15, cc: clang, cxx: clang++}
+          - {os: macos-14, cc: clang, cxx: clang++}
+          - {os: windows-2025, cc: gcc, cxx: g++, altname: "mingw-gcc"}
+          - {os: windows-2022, cc: gcc, cxx: g++, altname: "mingw-gcc"}
     env:
       MRUBY_CONFIG: ci/gcc-clang
-      CC: gcc
+      CC: ${{ matrix.cc }}
+      CXX: ${{ matrix.cxx }}
+      LD: ${{ matrix.cc }}
     steps:
-      - uses: actions/checkout@v2
-      - name: Ruby version
-        run: ruby -v
-      - name: Compiler version
-        run: ${{ env.CC }} --version
-      - name: Build and test
-        run: rake -m test:build && rake test:run
-
-  Ubuntu-1804-gcc:
-    needs: Check-Skip
-    runs-on: ubuntu-18.04
-    env:
-      MRUBY_CONFIG: ci/gcc-clang
-      CC: gcc
-    steps:
-      - uses: actions/checkout@v2
-      - name: Ruby version
-        run: ruby -v
-      - name: Compiler version
-        run: ${{ env.CC }} --version
-      - name: Build and test
-        run: rake -m test:build && rake test:run
-
-  Ubuntu-1804-clang:
-    needs: Check-Skip
-    runs-on: ubuntu-18.04
-    env:
-      MRUBY_CONFIG: ci/gcc-clang
-      CC: clang
-    steps:
-      - uses: actions/checkout@v2
-      - name: Ruby version
-        run: ruby -v
-      - name: Compiler version
-        run: ${{ env.CC }} --version
-      - name: Build and test
-        run: rake -m test:build && rake test:run
-
-  macOS:
-    needs: Check-Skip
-    runs-on: macos-latest
-    env:
-      MRUBY_CONFIG: ci/gcc-clang
-      CC: clang
-    steps:
-      - uses: actions/checkout@v2
-      - name: Ruby version
-        run: ruby -v
-      - name: Compiler version
-        run: ${{ env.CC }} --version
-      - name: Build and test
-        run: rake -m test:build && rake test:run
-
-  Windows-MinGW:
-    needs: Check-Skip
-    runs-on: windows-latest
-    env:
-      MRUBY_CONFIG: ci/gcc-clang
-      CC: gcc
-    steps:
-      - uses: actions/checkout@v2
-      - name: Ruby version
-        run: ruby -v
-      - name: Compiler version
-        run: ${{ env.CC }} --version
-      - name: Build and test
-        run: rake -m test:build && rake test:run
-
-  Windows-Cygwin:
-    needs: Check-Skip
-    runs-on: windows-latest
-    env:
-      ACTIONS_ALLOW_UNSECURE_COMMANDS: true
-      MRUBY_CONFIG: ci/gcc-clang
-      CC: gcc
-      installer-path: '%TMP%\cygwin-setup.exe'
-      cygwin-root: C:\cygwin
-      package-dir: C:\cygwin-package
-      cache-version: v1
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/cache@v2
+      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
+        uses: actions/checkout@v6
         with:
-          path: ${{ env.package-dir }}
-          key: ${{ runner.os }}-cygwin-${{ env.cache-version }}
-      - name: Download Cygwin installer
-        shell: cmd
-        run: >
-          bitsadmin /transfer download /priority foreground
-          https://cygwin.com/setup-x86_64.exe ${{ env.installer-path }}
-      - name: Install Cygwin
-        shell: cmd
-        run: >
-          ${{ env.installer-path }}
-          --quiet-mode --no-shortcuts --no-startmenu --no-desktop --no-admin
-          --only-site --site http://mirrors.kernel.org/sourceware/cygwin/
-          --root ${{ env.cygwin-root }}
-          --local-package-dir ${{ env.package-dir }}
-          --packages gcc-core,gcc-g++,ruby
-      - name: Set PATH for Cygwin
-        run: |
-          echo '::set-env name=PATH::${{ env.cygwin-root }}\bin;${{ env.cygwin-root }}\usr\bin'
+          persist-credentials: false
       - name: Ruby version
-        shell: cmd
         run: ruby -v
       - name: Compiler version
         run: ${{ env.CC }} --version
       - name: Build and test
-        shell: cmd
-        run: ruby /usr/bin/rake -m test:build && ruby /usr/bin/rake test:run
-      - name: Set PATH for cache archiving (tar)
-        # set Windows path so that Cygwin tar is not used for cache archiving
-        run: echo '::set-env name=PATH::C:\windows\System32'
+        run: rake -m test:run:serial
+
+  Cosmopolitan:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 15
+    steps:
+      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - name: Ruby version
+        run: ruby -v
+      - name: Cache cosmocc
+        uses: actions/cache@v5
+        id: cache-cosmocc
+        with:
+          path: ~/cosmo
+          key: cosmocc-${{ runner.os }}-20260104
+      - name: Install cosmocc
+        if: steps.cache-cosmocc.outputs.cache-hit != 'true'
+        run: |
+          mkdir -p ~/cosmo && cd ~/cosmo
+          wget https://cosmo.zip/pub/cosmocc/cosmocc.zip
+          unzip cosmocc.zip
+      - name: Build and test
+        run: |
+          COSMO_ROOT=~/cosmo rake -m test:run:serial MRUBY_CONFIG=cosmopolitan
 
   Windows-VC:
-    needs: Check-Skip
-    runs-on: windows-latest
+    runs-on: windows-2022
+    timeout-minutes: 10
     env:
       MRUBY_CONFIG: ci/msvc
     steps:
-      - uses: actions/checkout@v2
+      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
       - name: Ruby version
         run: ruby -v
       - name: Build and test
         shell: cmd
         run: |
-          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
-          rake -m test:build && rake test:run
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+          rake -m test:run:serial

.github/workflows/codeql-analysis.yml

@@ -1,55 +1,33 @@
-name: "Code scanning - action"
-
+name: CodeQL Analysis
 on:
   push:
+    branches: [master]
   pull_request:
-  schedule:
-    - cron: '0 19 * * 4'
-
+    branches: [master]
+permissions:
+  actions: read
+  contents: read
+  security-events: write
 jobs:
-  CodeQL-Build:
-    if: |
-      !contains(github.event.head_commit.message, '[ci skip]') &&
-      !contains(github.event.head_commit.message, '[skip ci]') &&
-      !contains(github.event.head_commit.message, '[skip gha]')
-
+  codeql:
+    name: CodeQL
     runs-on: ubuntu-latest
-
+    strategy:
+      fail-fast: false
+      matrix:
+        language: ["actions"]
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v2
+        uses: actions/checkout@v6
         with:
-          # We must fetch at least the immediate parents so that if this is
-          # a pull request then we can checkout the head.
-          fetch-depth: 2
-
-      # If this run was triggered by a pull request event, then checkout
-      # the head of the pull request instead of the merge commit.
-      - run: git checkout HEAD^2
-        if: ${{ github.event_name == 'pull_request' }}
-
-      # Initializes the CodeQL tools for scanning.
+          persist-credentials: false
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v1
-        # Override language selection by uncommenting this and choosing your languages
-        # with:
-        #   languages: go, javascript, csharp, python, cpp, java
-
-      # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-      # If this step fails, then you should remove it and run the build manually (see below)
+        uses: github/codeql-action/init@v4
+        with:
+          languages: ${{ matrix.language }}
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v1
-
-      # ℹ️ Command-line programs to run using the OS shell.
-      # 📚 https://git.io/JvXDl
-
-      # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
-      #    and modify them (or add more) to build your code if your project
-      #    uses a compiled language
-
-      # - run: |
-      #    make bootstrap
-      #    make release
-
+        uses: github/codeql-action/autobuild@v4
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v1
+        uses: github/codeql-action/analyze@v4
+        with:
+          category: "Security"

.github/workflows/coverage.yml

@@ -0,0 +1,46 @@
+name: Coverage
+
+on: [push]
+
+permissions:
+  contents: read
+
+jobs:
+  coverage:
+    name: Coverage
+    runs-on: ubuntu-24.04
+    env:
+      MRUBY_CONFIG: ci/gcc-clang
+      CC: clang-18
+      CXX: clang++-18
+      LD: clang-18
+      CFLAGS: -O0 -g --coverage
+      CXXFLAGS: -O0 -g --coverage
+      LDFLAGS: --coverage
+    steps:
+      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - name: Ruby version
+        run: ruby -v
+      - name: Compiler version
+        run: ${{ env.CC }} --version
+      - name: Build and test
+        run: rake test
+      - name: Install gcovr
+        run: pip install gcovr
+      - name: Generate coverage report
+        run: |
+          {
+            echo "# Coverage report"
+            echo \`\`\`
+            gcovr --gcov-executable "llvm-cov-18 gcov" -e ".*_test.c" -e ".*/test/.*" -s --html-details -o coverage/ build
+            echo \`\`\`
+          } > "$GITHUB_STEP_SUMMARY"
+      - name: Upload coverage report
+        uses: actions/upload-artifact@v7
+        with:
+          name: coverage-${{ github.sha }}
+          path: coverage/
+          retention-days: 3

.github/workflows/labeler.yml

@@ -0,0 +1,15 @@
+# https://github.com/actions/labeler
+name: Pull Request Labeler
+on:
+  - pull_request_target
+jobs:
+  triage:
+    permissions:
+      contents: read
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/labeler@v6
+        with:
+          repo-token: "${{ secrets.GITHUB_TOKEN }}"
+          sync-labels: true

.github/workflows/lint.yml

@@ -1,23 +0,0 @@
-name: ❄️ Lint
-
-on: [pull_request]
-
-jobs:
-  yamllint:
-    name: 🍶 YAML
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: 🧹 YAML Lint
-        uses: ibiqlik/action-yamllint@v3
-  markdownlint:
-    name: 🍸 Markdown
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: 🚀 Use Node.js
-        uses: actions/setup-node@v2.1.4
-        with:
-          node-version: '12.x'
-      - run: npm install -g markdownlint-cli@0.25.0
-      - run: markdownlint '**/*.md'

.github/workflows/ls-lint.yml

@@ -0,0 +1,19 @@
+# https://github.com/loeffel-io/ls-lint
+name: Lint
+
+on: [pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  ls-lint:
+    name: Run ls-lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: ls-lint/action@v2.3.1
+        with:
+          config: .github/linters/.ls-lint.yml

.github/workflows/oss-fuzz.yml

@@ -1,26 +1,26 @@
+# https://github.com/google/oss-fuzz
 name: CIFuzz
 on: [pull_request]
+permissions:
+  contents: read
+
 jobs:
   Fuzzing:
-    if: |
-      !contains(github.event.head_commit.message, '[ci skip]') &&
-      !contains(github.event.head_commit.message, '[skip ci]') &&
-      !contains(github.event.head_commit.message, '[skip gha]')
     runs-on: ubuntu-latest
     steps:
       - name: Build Fuzzers
         uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
         with:
-          oss-fuzz-project-name: 'mruby'
+          oss-fuzz-project-name: "mruby"
           dry-run: false
       - name: Run Fuzzers
         uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
         with:
-          oss-fuzz-project-name: 'mruby'
+          oss-fuzz-project-name: "mruby"
           fuzz-seconds: 600
           dry-run: false
       - name: Upload Crash
-        uses: actions/upload-artifact@v1
+        uses: actions/upload-artifact@v7
         if: failure()
         with:
           name: artifacts

.github/workflows/pre-commit-manual.yml

@@ -0,0 +1,22 @@
+# https://github.com/j178/prek
+name: Manual hooks
+
+on: [pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  pre-commit:
+    name: Run pre-commit
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: j178/prek-action@v2
+        with:
+          install-only: true
+      - name: Run manual pre-commit hooks
+        run: prek run --color=always --all-files --hook-stage manual

.github/workflows/pre-commit.yml

@@ -0,0 +1,20 @@
+# https://github.com/j178/prek
+name: pre-commit
+
+on: [pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  pre-commit:
+    name: Run pre-commit
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: j178/prek-action@v2
+        with:
+          extra-args: --all-files

.github/workflows/release.yml

@@ -0,0 +1,48 @@
+name: Release Builds
+
+on:
+  push:
+    tags:
+      - "*.*.*"
+
+permissions: read-all
+
+jobs:
+  source:
+    name: Source Code Releasing
+    if: ${{ github.repository == 'mruby/mruby' }}
+    permissions:
+      contents: write
+    runs-on: ubuntu-22.04
+    timeout-minutes: 10
+    strategy:
+      fail-fast: false
+    steps:
+      - name: "Checkout ${{ github.ref_name }} ( ${{ github.sha }} )"
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - name: Builds
+        id: builds
+        run: |
+          tagname="$GITHUB_REF_NAME"
+          packagename="mruby-$tagname"
+          destdir=packages
+
+          mkdir -p "$destdir"
+          git archive --format zip --prefix "$packagename/" -o "$destdir/$packagename.zip" "$GITHUB_REF"
+          git archive --format tar.gz --prefix "$packagename/" -o "$destdir/$packagename.tar.gz" "$GITHUB_REF"
+          gunzip -c "$destdir/$packagename.tar.gz" | xz > "$destdir/$packagename.tar.xz"
+
+          (
+            cd "$destdir" || exit
+            sha256sum -- * > .sha256
+            mv .sha256 "$packagename.sha256"
+          )
+      - name: Release
+        uses: softprops/action-gh-release@v2
+        with:
+          draft: true
+          prerelease: ${{ contains(github.ref_name, '-rc') }}
+          body_path: NEWS
+          files: packages/*

.github/workflows/spell-checker.yml

@@ -1,17 +0,0 @@
-name: 💎 Spellchecker
-
-on: [pull_request]
-
-jobs:
-  misspell:
-    name: 🧹 Check Spelling
-    runs-on: ubuntu-latest
-    steps:
-      - name: 🍒 Check Out
-        uses: actions/checkout@v2
-      - name: 🍅 Install
-        run: |
-          wget -O - -q https://git.io/misspell | sh -s -- -b .
-      - name: 🌶️ Misspell
-        run: |
-          git ls-files --empty-directory | xargs ./misspell -error

.github/workflows/super-linter.yml

@@ -0,0 +1,32 @@
+# https://github.com/super-linter/super-linter
+name: Super-Linter
+
+on: [pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    permissions:
+      contents: read # for actions/checkout to fetch code
+      statuses: write # for super-linter/super-linter/slim to mark status of each linter run
+    name: Lint Code Base
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
+        uses: actions/checkout@v6
+        with:
+          # Full git history is needed to get a proper list of changed files within `super-linter`
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Lint Code Base
+        uses: super-linter/super-linter/slim@v8.5.0
+        env:
+          # VALIDATE_BASH_EXEC: true
+          VALIDATE_DOCKERFILE_HADOLINT: true
+          # VALIDATE_EDITORCONFIG: true
+          # VALIDATE_SHELL_SHFMT: true
+          DEFAULT_BRANCH: master
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          VALIDATE_ALL_CODEBASE: true

.gitignore

@@ -1,8 +1,8 @@
-*.lock
 *.bak
 *.bc
 *.d
 *.i
+*.lock
 *.o
 *.orig
 *.pdb
@@ -13,25 +13,27 @@
 *.tmp
 *~
 .DS_Store
+.cache
+.ccls*
 .ccmalloc
+.git
 .svn
 .vscode
 .yardoc
-.ccls*
-compile_flags.txt
+benchmark/**/*.dat
+benchmark/*.pdf
+benchmark/*.png
+bin
+/build
+doc/api
+doc/capi
 compile_commands.json
+compile_flags.txt
 cscope.files
 cscope.out
+gmon.out
+mruby-source-*.gem
+node_modules
+perf.data*
 tags
-
-/.git
-/bin
-/build
-/mruby-source-*.gem
-
-/benchmark/**/*.dat
-/benchmark/*.pdf
-/benchmark/*.png
-
-/doc/api
-/doc/capi
+!Gemfile.lock

.markdownlint.yml

@@ -1,16 +0,0 @@
-MD001: false
-MD003: false
-MD004: false
-MD005: false
-MD007: false
-MD010: false
-MD011: false
-MD013: false
-MD014: false
-MD024: false
-MD025: false
-MD026: false
-MD034: false
-MD040: false
-MD041: false
-MD046: false

.pre-commit-config.yaml

@@ -0,0 +1,130 @@
+---
+# https://github.com/j178/prek
+default_stages: [pre-commit, pre-push]
+default_language_version:
+  python: python3
+  node: 24.14.0
+minimum_pre_commit_version: "3.2.0"
+exclude: "^tools/lrama/"
+repos:
+  - repo: meta
+    hooks:
+      - id: identity
+        name: run identity
+        description: check your identity
+      - id: check-hooks-apply
+        name: run check-hooks-apply
+        description: check hooks apply to the repository
+  - repo: local
+    hooks:
+      - id: prettier
+        name: run prettier
+        description: format files with prettier
+        entry: prettier --write '**/*.md' '**/*.yaml' '**/*.yml'
+        files: \.(md|ya?ml)$
+        language: node
+        additional_dependencies: ["prettier@3.7.4"]
+        pass_filenames: false
+        stages: [manual]
+      - id: check-zip-file-is-not-committed
+        name: disallow zip files
+        description: Zip files are not allowed in the repository
+        language: fail
+        entry: |
+          Zip files are not allowed in the repository as they are hard to
+          track and have security implications. Please remove the zip file from the repository.
+        files: \.zip$
+  - repo: https://github.com/gitleaks/gitleaks
+    rev: v8.30.1
+    hooks:
+      - id: gitleaks
+        name: run gitleaks
+        description: detect hardcoded secrets with gitleaks
+  - repo: https://github.com/oxipng/oxipng
+    rev: v10.1.0
+    hooks:
+      - id: oxipng
+        name: run oxipng
+        description: use lossless compression to optimize PNG files
+        args: ["--fix", "-o", "4", "--strip", "safe", "--alpha"]
+        stages: [manual]
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: check-added-large-files
+      - id: check-case-conflict
+      - id: check-executables-have-shebangs
+        exclude: ^test/t/lang\.rb$
+      - id: check-illegal-windows-names
+      - id: check-merge-conflict
+      - id: check-shebang-scripts-are-executable
+      - id: check-vcs-permalinks
+      - id: check-yaml
+      - id: destroyed-symlinks
+      - id: detect-aws-credentials
+        args: [--allow-missing-credentials]
+      - id: detect-private-key
+      - id: end-of-file-fixer
+      - id: file-contents-sorter
+        args: [--unique]
+        files: ^\.github/linters/codespell\.txt$
+      - id: fix-byte-order-marker
+      - id: forbid-submodules
+      - id: mixed-line-ending
+      - id: trailing-whitespace
+  - repo: https://github.com/Lucas-C/pre-commit-hooks
+    rev: v1.5.6
+    hooks:
+      - id: forbid-tabs
+        name: run no-tabs checker
+        description: check the codebase for tabs
+        exclude: Makefile$
+      - id: remove-tabs
+        name: run tabs remover
+        description: find and convert tabs to spaces
+        args: [--whitespaces-count, "2"]
+        exclude: Makefile$
+  - repo: https://github.com/rhysd/actionlint
+    rev: v1.7.12
+    hooks:
+      - id: actionlint
+        name: run actionlint
+        description: lint GitHub Actions workflow files
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.4.2
+    hooks:
+      - id: codespell
+        name: run codespell
+        description: check spelling with codespell
+  - repo: https://github.com/igorshubovych/markdownlint-cli
+    rev: v0.48.0
+    hooks:
+      - id: markdownlint
+        name: run markdownlint
+        description: checks the style of Markdown files
+        args: [--config=.github/linters/.markdown-lint.yml]
+        types: [markdown]
+        files: \.md$
+  - repo: https://github.com/rubocop/rubocop
+    rev: v1.86.0
+    hooks:
+      - id: rubocop
+        name: run rubocop
+        description: RuboCop is a Ruby code style checker (linter) and formatter based on the community-driven Ruby Style Guide
+        exclude: ^test/t/syntax\.rb$
+        args: [--config=.github/linters/.rubocop.yml]
+  - repo: https://github.com/shellcheck-py/shellcheck-py
+    rev: v0.11.0.1
+    hooks:
+      - id: shellcheck
+        name: run shellcheck
+        description: check shell scripts with a static analysis tool
+  - repo: https://github.com/adrienverge/yamllint
+    rev: v1.38.0
+    hooks:
+      - id: yamllint
+        name: run yamllint
+        description: check YAML files with yamllint
+        args: [--strict, -c=.github/linters/.yaml-lint.yml]
+        types: [yaml]
+        files: \.ya?ml$

.prettierignore

@@ -0,0 +1,6 @@
+# Ignore artifacts:
+build
+coverage
+doc/internal/opcode.md
+tools/lrama
+.venv

.prettierrc

@@ -0,0 +1,3 @@
+{
+  "bracketSpacing": false
+}

.travis.yml

@@ -8,4 +8,4 @@ env:
   - MRUBY_CONFIG=ci/gcc-clang
 
 script:
-  - rake -m test:build && rake test:run
+  - rake -m test:run:serial

.yamllint

@@ -1,8 +0,0 @@
----
-
-extends: default
-
-rules:
-  document-start: disable
-  line-length: disable
-  truthy: false

.yardopts

@@ -11,7 +11,13 @@ mrbgems/*/src/**/*.c
 mrbgems/*/mrblib/**/*.rb
 mrbgems/*/include/**/*.h
 -
-AUTHORS
-LICENSE
 CONTRIBUTING.md
+SECURITY.md
+TODO.md
+doc/*.md
 doc/guides/*.md
+doc/internal/*.md
+AUTHORS
+LEGAL
+LICENSE
+NEWS

AUTHORS

@@ -1,48 +1,348 @@
-This is the (likely incomplete) list of "mruby developers".
-If you submit a patch to mruby, please add your name to the end
-of this list.
+# Authors of mruby (mruby developers)
 
-   Yukihiro Matsumoto (Matz)
+## The List of Contributors sorted by number of commits (as of 2026-03-02 02877f0)
+
+   7532 Yukihiro "Matz" Matsumoto (@matz)*
+    712 dearblue (@dearblue)*
+    587 KOBAYASHI Shuji (@shuujii)
+    353 Daniel Bovensiepen (@bovi)*
+    345 Takeshi Watanabe (@take-cheeze)*
+    333 Masaki Muranaka (@monaka)
+    255 John Bampton (@jbampton)
+    234 Jun Hiroe (@suzukaze)
+    228 Tomoyuki Sahara (@tsahara)*
+    220 Cremno (@cremno)*
+    209 Yuki Kurihara (@ksss)+
+    144 Yasuhiro Matsumoto (@mattn)*
+    113 Carson McDonald (@carsonmcdonald)
+    104 Tomasz Pędraszewski (@dabroz)*
+     83 Akira Yumiyama (@akiray03)*
+     83 skandhas (@skandhas)
+     80 Masamitsu MURASE (@masamitsu-murase)
+     73 Hiroshi Mimaki (@mimaki)*
+     71 Tatsuhiko Kubo (@cubicdaiya)*
+     71 Yuichiro MASUI (@masuidrive)
+     62 Yuichiro Kaneko (@yui-knk)+
+     59 Kurebayashi, Takahiro (@crimsonwoods)*
+     56 h2so5 (@h2so5)
+     52 Ralph Desir (@Mav7)*
+     48 Paolo Bosetti (@pbosetti)*
+     45 Rory O'Connell (@RoryO)*
+     42 fleuria (@flaneur2020)
+     40 Christopher Aue (@christopheraue)
+     40 Seba Gamboa (@sagmor)
+     39 Kouhei Sutou (@kou)*
+     38 Koji Yoshioka (@kyab)*+
+     32 Masayoshi Takahashi (@takahashim)+
+     31 MATSUMOTO Ryosuke (@matsumotory)*
+     30 Nobuyoshi Nakada (@nobu)
+     26 Hoshiumi Arata (@hoshiumiarata)*
+     25 Julian Aron Prenner (@furunkel)*
+     22 Clayton Smith (@clayton-shopify)
+     22 Uchio Kondo (@udzura)*
+     22 Zachary Scott (@zzak)*
+     21 Ryan Lopopolo (@lopopolo)
+     20 Ryan Scott (@ryan-scott-dev)*
+     20 google-labs-jules[bot] (@google-jules)
+     19 Bouke van der Bijl (@bouk)
+     19 Jared Breeden (@jbreeden)*
+     19 go kikuta (@gkta)*
+     18 Corey Powell (@IceDragon200)
+     18 Hidetaka Takano (@TJ-Hidetaka-Takano)
+     18 Jon Maken (@jonforums)+
+     18 leviongit (@leviongit)
+     18 mirichi (@mirichi)
+     17 Mitchell Blank Jr (@mitchblank)*
+     16 HASUMI Hitoshi (@hasumikin)
+     16 bggd (@bggd)
+     16 kano4 (@kano4)
+     15 Felix Jones (@felixjones)*
+     14 Blaž Hrastnik (@archseer)*
+     14 Kazuki Tsujimoto (@k-tsj)
+     14 Tadashi FUKUZAWA (@FUKUZAWA-Tadashi)+
+     14 fn ⌃ ⌥ (@FnControlOption)
+     13 Jose Narvaez (@goyox86)
+     13 Patrick Hogan (@pbhogan)
+     12 Akira Kuroda (@akuroda)
+     12 Kouki Ooyatsu (kaishuu0123)*
+     12 NAKAMURA Usaku (@unak)*
+     12 Ray Chason (@chasonr)*
+     12 SiZiOUS (@suzious)
+     12 Takashi Sawanaka (@sdottaka)*
+     12 Ukrainskiy Sergey (@ukrainskiysergey)
+     12 Xuejie "Rafael" Xiao (@xxuejie)*
+     11 Julien Ammous (@schmurfy)
+     11 Kazuho Oku (@kazuho)
+     11 RIZAL Reckordp (@Reckordp)+
+     11 Seeker (@SeekingMeaning)
+     11 takkaw (@takkaw)
+     10 Hendrik (@Asmod4n)
+     10 Miura Hideki (@miura1729)
+     10 Narihiro Nakamura (@authorNari)
+     10 YAMAMOTO Masaya (pandax381)
+     10 Yuichi Nishiwaki (@nyuichi)
+      9 Akira Mitsui (@murasesyuka)*
+      9 Frank Celler (@fceller)
+      9 Tatsuya Matsumoto (@tmash06)*
+      8 Takashi Sogabe (@sogabe)
+      8 Wataru Ashihara (@wataash)*
+      7 Bhargava Shastry (@bshastry)*
+      7 Kouichi Nakanishi (@keizo042)
+      7 Rubyist (@expeditiousRubyist)
+      7 Simon Génier (@simon-shopify)
+      7 Terence Lee (@hone)
+      7 roco (@rystyle)*
+      7 vickash (@vickash)
+      6 Akito Mochizuki (@ak-mochi)
+      6 Beoran (@beoran)
+      6 David Siaw (@davidsiaw)*
+      6 Frederick John Milens III (@fjmilens3)
+      6 Hiro Asari (@BanzaiMan)
+      6 INOUE Yasuyuki (@yasuyuki)
+      6 Junji Sawada (@junjis0203)
+      6 Kenji Okimoto (@okkez)+
+      6 Paweł Świątkowski (@katafrakt)
+      6 Selman ULUG (@selman)
+      6 Yusuke Endoh (@mame)*
+      6 buty4649 (@buty4649)
+      6 masahino (@masahino)
+      5 Chris Reuter (@suetanvil)
+      5 Davide D'Agostino (@DAddYE)
+      5 Eric Hodel (@drbrain)
+      5 Ichito Nagata (@i110)
+      5 Keita Obo (@ktaobo)*
+      5 Max Anselm (@silverhammermba)
+      5 Rodrigo Malizia (@rmalizia44)+
+      5 Ryan Davis (@zenspider)
+      5 Syohei YOSHIDA (@syohex)
+      5 TOMITA Masahiro (@tmtm)
+      5 Yurie Yamane (@yurie)+
+      5 dreamedge (@dreamedge)
+      5 nkshigeru (@nkshigeru)
+      5 xuejianqing (@joans321)
+      4 Chris Hasiński (@khasinski)
+      4 Dante Catalfamo (@dantecatalfamo)
+      4 Goro Kikuchi (@gorogit)
+      4 Herwin Weststrate (@herwinw)
+      4 Horimoto Yasuhiro (@komainu8)
+      4 Jon Moss (@maclover7)
+      4 Ken Muramatsu (@ken-mu)+
+      4 Kohei Suzuki (@eagletmt)
+      4 Lanza (@LanzaSchneider)
+      4 Li Yazhou (@flaneur2020)
+      4 Marcus Stollsteimer (@stomar)
+      4 Mark Delk (@jethrodaniel)
+      4 NARUSE, Yui (@nurse)
+      4 Ravil Bayramgalin (@brainopia)*+
+      4 Satoshi Odawara (@SatoshiOdawara)
+      4 UENO, M. (@eunos-1128)
+      4 Yuhei Okazaki (@Yuuhei-Okazaki)*
+      4 Yuji Yamano (@yyamano)
+      4 kurodash (@kurodash)*
+      4 wanabe (@wanabe)*
+      3 Anton Davydov (@davydovanton)
+      3 Aurora Nockert (@auroranockert)
+      3 Carlo Prelz (@asfluido)*
+      3 Daniel K. Sierpiński (@513ry)+
+      3 David Turnbull (@AE9RB)
+      3 Franck Verrot (@franckverrot)
+      3 Hirohito Higashi (@HirohitoHigashi)
+      3 J. Mutua (@katmutua)+
+      3 Jan Berdajs (@mrbrdo)
+      3 Jonas Minnberg (@sasq64)
+      3 Joseph McCullough (@joequery)
+      3 Mark McCurry (@fundamental)
+      3 Meder Kydyraliev (@meder)
+      3 Nobuhiro Iwamatsu (@iwamatsu)
+      3 Per Lundberg (@perlun)*
+      3 Rob Fors (@robfors)*
+      3 Robert Rowe (@CaptainJet)
+      3 Sebastián Katzer (@katzer)*
+      3 Shuta Kimura (@kimushu)+
+      3 TERAJIMA, Motoyuki (@trmmy)
+      3 Taichi AOKI (@aoki1980taichi)
+      3 Takashi Kokubun (@k0kubun)
+      3 Tatsuhiro Tsujikawa (@tatsuhiro-t)
+      3 Thiago Scalone (@scalone)
+      3 Vladimir Dementyev (@palkan)*
+      3 William Light (@wrl)
+      3 bamchoh (@bamchoh)
+      3 sasaki takeru (@takeru)
+      3 windwiny (@windwiny)
+      2 Akira Moroo (@retrage)
+      2 Artur K (@nemerle)
+      2 Christian Mauceri (@mauceri)
+      2 Craig Lehmann (@craiglrock)*
+      2 Dominic Sisneros (@dsisnero)*
+      2 Dusan D. Majkic (@dmajkic)
+      2 Emiliano Lesende (@3miliano)
+      2 Francois Chagnon (@EiNSTeiN-)*
+      2 Gilad Zohari (@gzohari)
+      2 Go Saito (@govm)
+      2 Hiroyuki Iwatsuki (@iwadon)
+      2 Huei-Horng Yo (@hiroshiyui)
+      2 Jonas Kulla (@Ancurio)
+      2 Jun Takeda (@takjn)
+      2 Kazuaki Tanaka (@kaz0505)
+      2 Kazuhiko Yamashita (@pyama86)+
+      2 Kazuhiro Sera (@seratch)
+      2 Kuroda Daisuke (@dycoon)+
+      2 Lothar Scholz (@llothar)
+      2 Lukas Joeressen (@kext)
+      2 Masahiro Wakame (@vvkame)+
+      2 Minao Yamamoto (@tarosay)+
+      2 Nihad Abbasov (@NARKOZ)
+      2 Robert Mosolgo (@rmosolgo)
+      2 Russel Hunter Yukawa (@rhykw)+
+      2 Ryunosuke SATO (@tricknotes)
+      2 Santa Zhang (@santazhang)
+      2 Serg Podtynnyi (@shtirlic)
+      2 Shannen Saez (@shancat)
+      2 Shouji Kuboyama (@Shokuji)*
+      2 SouthWolf (@southwolf)
+      2 TJ Singleton (@tjsingleton)
+      2 Taiyo Mizuhashi (@taiyoslime)+
+      2 Tomás Pollak (@tomas)*
+      2 Yutaka HARA (@yhara)*+
+      2 Zhang Xiaohui (@hifoolno)
+      2 icm7216 (@icm7216)
+      1 A-Sat (@asatou)+
+      1 AN Long (@aisk)
+      1 Abinoam Praxedes Marques Junior (@abinoam)
+      1 Alex Wang (@nanamiwang)+
+      1 AlexDenisov (@AlexDenisov)
+      1 Andrew Nordman (@cadwallion)
+      1 Ashish Kurmi (@boahc077)
+      1 Atsushi Morimoto (@mynz)
+      1 Ben A Morgan (@BenMorganIO)
+      1 Benoit Daloze (@eregon)
+      1 Bradley Whited (@esotericpig)
+      1 Colin MacKenzie IV (@sinisterchipmunk)
+      1 Daehyub Kim (@lateau)
+      1 Daniel Varga (@vargad)
+      1 Diamond Rivero (@diamant3)
+      1 Edgar Boda-Majer (@eboda)
+      1 Fangrui Song (@MaskRay)
+      1 Flavio Medeiros (@flaviommedeiros)
+      1 Francis Bogsanyi (@fbogsany)
+      1 Guo Xiao (@guoxiao)
+      1 Gwen Boatrite (@boatrit)
+      1 Gwendolyn Boatrite (@boatrite)
+      1 HARADA Makoto (@haramako)
+      1 HAYASHI Kentaro (@kenhys)
+      1 Hiroki Mori (@yamori813)+
+      1 Hiromasa Ishii (@Hir0)+
+      1 Hiroyuki Matsuzaki (@Hiroyuki-Matsuzaki)
+      1 Hugo Logmans (@hlogmans)
+      1 Jack Danger Canty (@JackDanger)
+      1 Jeff Federman (@jefffederman)
+      1 Jeffrey Crowell (@crowell)
+      1 Jeremy Ong (@jeremyong)
+      1 Jiro Nishiguchi (@spiritloose)
+      1 Joachim Baran (@indiedotkim)
+      1 Joe Kutner (@jkutner)
+      1 Jun Aruga (@junaruga)
+      1 Junichi Kajiwara (@kjunichi)
+      1 Jurriaan Pruis (@jurriaan)
+      1 Katsuhiko Kageyama (@kishima)+
+      1 Katsuyoshi Ito (@katsuyoshi)
+      1 Kazuhiro NISHIYAMA (@znz)
+      1 Kei Sawada (@remore)
+      1 Kim H Madsen (@kimhmadsen)
+      1 Koichi ITO (@koic)
+      1 Konstantin Haase (@rkh)
+      1 Leo Neat (@Leo-Neat)
+      1 Lian Cheng (@liancheng)
+      1 Luis Lavena (@luislavena)
+      1 Lukas Elmer (@lukaselmer)
+      1 Lukas Stabe (@Ahti)
+      1 M.Naruoka (@fenrir-naru)
+      1 Marcelo Juchem (@juchem)
+      1 Martin Bosslet (@emboss)+
+      1 Masahiko Sawada (@MasahikoSawada)
+      1 Matt Aimonetti (@mattetti)
+      1 Max Base (@MaxFork)
+      1 Maxim Abramchuk (@MaximAbramchuck)
+      1 Megumi Tomita (@tomykaira)+
+      1 Mitchell Hashimoto (@mitchellh)
+      1 Mitsutaka Mimura (@takkanm)
+      1 Nathan Ladd (@ntl)
+      1 Nicholas (@knf)
+      1 Nozomi SATO (@nozomiS)
+      1 Okumura Takahiro (@hfm)
+      1 Oliver Chang (@oliverchang)
+      1 Patrick Ellis (@pje)
+      1 Patrick Pokatilo (@SHyx0rmZ)
+      1 Pavel Evstigneev (@Paxa)+
+      1 Pete Kinnecom (@petekinnecom)
+      1 Piotr Usewicz (@pusewicz)
+      1 Prayag Verma (@pra85)
+      1 Ranmocy (@ranmocy)
+      1 Robert McNally (@wolfmcnally)
+      1 Ryan Scott Lewis (@RyanScottLewis)
+      1 Ryo Okubo (@syucream)
+      1 SAkira a.k.a. Akira Suzuki (@sakisakira)
+      1 Santiago Rodriguez (@sanrodari)
+      1 Satoh, Hiroh (@cho45)+
+      1 Satoru Naba (@snaba)+
+      1 Sayed Abdelhaleem (@visualsayed)
+      1 Sergey Ukrainskiy (@ukrainskiysergey)
+      1 Shugo Maeda (@shugo)
+      1 Sinkevich Artem (@ArtSin)
+      1 Sorah Fukumori (@sorah)
+      1 Stephen Jothen (@sjothen)
+      1 Stuart Hinson (@stuarth)
+      1 Takuma Kume (@takumakume)+
+      1 Takuya ASADA (@syuu1228)
+      1 Thomas Schmidt (@digitaltom)
+      1 Timo Schilling (@timoschilling)
+      1 Tom Black (@blacktm)
+      1 Utkarsh Kukreti (@utkarshkukreti)
+      1 W (@graywolf)
+      1 Wuffers Lightwolf (@w-x-l)
+      1 YAMAMOTO Yuji (@igrep)
+      1 Yevhen Viktorov (@yevgenko)
+      1 Yoji SHIDARA (@darashi)
+      1 Yoshiori SHOJI (@yoshiori)
+      1 Yuji Yokoo (@yujiyokoo)
+      1 Yukang (@chenyukang)
+      1 Yurii Nakonechnyi (@inobelar)
+      1 Yusuke Suzuki (@Constellation)+
+      1 Yusuke Tanaka (@csouls)
+      1 alpha.netzilla (@alpha-netzilla)
+      1 arton (@arton)
+      1 duangsuse (@duangsuse)
+      1 fl0l0u (@fl0l0u)
+      1 hasse (@hasse09052)
+      1 hhc0null (@hhc0null)
+      1 iTitou (@titouanc)
+      1 javier ramírez (@javier)
+      1 liyuray (@liyuray)
+      1 lucas dicioccio (@lucasdicioccio)
+      1 n4o847 (@n4o847)
+      1 niyarin (@niyarin)
+      1 robert (@R-obert)
+      1 sbsoftware (@sbsoftware)
+      1 ssmallkirby (@smallkirby)
+      1 taku toyama (@tsuichu)
+
+`*` - Entries unified according to names and addresses
+`+` - Entries with names different from commits
+
+## Contributors without named commits
+
+   Yuichi Osawa (Mitsubishi Electric Micro-Computer Application Software)
+   Shota Nakano (Manycolors)
+   Bjorn De Meyer
+
+## Corporate contributors
+
+   Ministry of Economy, Trade and Industry, Japan
+   Kyushu Bureau of Economy, Trade and Industry
    SCSK KYUSHU CORPORATION
    Kyushu Institute of Technology
    Network Applied Communication Laboratory, Inc.
-   Daniel Bovensiepen
-   Jon Maken
-   Bjorn De Meyer
-   Yuichiro MASUI
-   Masamitsu MURASE
-   Masaki Muranaka
    Internet Initiative Japan Inc.
-   Tadashi FUKUZAWA
-   MATSUMOTO Ryosuke
-   Yasuhiro Matsumoto
-   Koji Yoshioka
-   Jun Hiroe
-   Narihiro Nakamura
-   Yuichi Nishiwaki
-   Tatsuhiko Kubo
-   Takeshi Watanabe
-   Yuki Kurihara
-   specified non-profit corporation mruby Forum
-   Kazuaki Tanaka
-   Hiromasa Ishii
-   Hiroshi Mimaki
-   Satoshi Odawara
+   Specified non-profit organization mruby Forum
    Mitsubishi Electric Micro-Computer Application Software Co.,Ltd.
-   Ralph Desir(Mav7)
-   Hiroyuki Matsuzaki
-   Yuhei Okazaki
    Manycolors, Inc.
-   Shota Nakano
-   Yuichi Osawa
-   Terence Lee
-   Zachary Scott
-   Tomasz Dąbrowski
-   Christopher Aue
-   Masahiro Wakame
-   YAMAMOTO Masaya
-   KOBAYASHI Shuji
-   RIZAL Reckordp
-   Rory O'Connell
-   John Bampton
-   Seeker

CONTRIBUTING.md

@@ -8,16 +8,128 @@ Contributors agree to license their contribution(s) under MIT license.
 To make it easy to review and understand your change please keep the following
 things in mind before submitting your pull request:
 
-* Work on the latest possible state of **mruby/master**
-* Create a branch which is dedicated to your change
-* Test your changes before creating a pull request (```rake test```)
-* If possible write a test case which confirms your change
-* Don't mix several features or bug-fixes in one pull request
-* Create a meaningful commit message
-* Explain your change (i.e. with a link to the issue you are fixing)
-* Use mrbgem to provide non ISO features (classes, modules and methods) unless
+- Work on the latest possible state of **mruby/master**
+- Create a branch which is dedicated to your change
+- Test your changes before creating a pull request (`rake test`)
+- If possible write a test case which confirms your change
+- Don't mix several features or bugfixes in one pull request
+- Create a meaningful commit message
+- Explain your change (i.e. with a link to the issue you are fixing)
+- Use mrbgem to provide non ISO features (classes, modules and methods) unless
   you have a special reason to implement them in the core
 
+## Security Issues
+
+If you discover a security vulnerability:
+
+- **High priority security vulnerabilities** (RCE): Report via email to <matz@ruby.or.jp>
+- **VM crashes from valid Ruby code**: Please report as regular bug reports on our issue tracker
+
+For detailed guidance on what qualifies as a security issue and what doesn't, see [SECURITY.md](SECURITY.md).
+
+## prek
+
+We use [prek](https://github.com/j178/prek), a fast Rust-based pre-commit hook manager.
+It reads the standard `.pre-commit-config.yaml` format.
+
+Install `prek` following the [installation guide](https://github.com/j178/prek#installation),
+then install the hooks with `prek install`.
+Now `prek` will run automatically on git commit!
+
+It's usually a good idea to run the hooks against all the files when adding new hooks (usually `prek`
+will only run on the changed files during git hooks). Use `prek run --all-files` to check all files.
+
+To run a single hook use `prek run --all-files <hook_id>`
+
+To update use `prek autoupdate`
+
+Sometimes you might need to skip one or more hooks which can be done with the `SKIP` environment variable.
+
+`$ SKIP=yamllint git commit -m "foo"`
+
+For convenience, we have added `prek run --all-files`, `prek install` and `prek autoupdate`
+to both the Makefile and the Rakefile. Run them with:
+
+- `make check` or `rake check`
+- `make checkinstall` or `rake checkinstall`
+- `make checkupdate` or `rake checkupdate`
+
+To configure hooks you can modify the config file [.pre-commit-config.yaml](.pre-commit-config.yaml).
+We use [GitHub Actions](.github/workflows/pre-commit.yml) to run `prek` on every pull request.
+
+### prek quick links
+
+- [prek GitHub](https://github.com/j178/prek)
+- [Installation](https://github.com/j178/prek#installation)
+- [Usage](https://github.com/j178/prek#usage)
+
+## Docker
+
+We have both a `Dockerfile` and `docker-compose.yml` files in the repository root.
+You can run these with the command line or use
+[Docker Desktop](https://www.docker.com/products/docker-desktop/).
+
+The Docker image is running Debian bullseye with Ruby and Python installed.
+You can build the Docker image with:
+
+`$ docker-compose build test`
+
+So far we just have one service: `test`. Running the default `docker-compose`
+command will create the Docker image, spin up a container and then build and
+run all mruby tests.
+
+The default `docker-compose` command is:
+
+`$ docker-compose -p mruby run test`
+
+You can also use Make or Rake to run the default `docker-compose`
+command from above:
+
+- `make composetest`
+- `rake composetest`
+
+List your Docker images with:
+
+```console
+$ docker images
+REPOSITORY   TAG       IMAGE ID       CREATED          SIZE
+mruby-test   latest    ec60f9536948   29 seconds ago   1.29GB
+```
+
+You can also run any custom `docker-compose` command which will override
+the default. For example to run `prek run --all-files` type:
+
+`$ docker-compose -p mruby run test prek run --all-files`
+
+For convenience, you can also run `prek` with:
+
+- `make composecheck`
+- `rake composecheck`
+
+The bonus of running `prek` with `docker-compose` is that you won't need
+to install `prek` and the hooks on your local machine.
+
+Note limitation: currently running `prek` with `docker-compose` we
+skip the `check-executables-have-shebangs` hook.
+
+Two more examples of custom `docker-compose` commands are:
+
+- `$ docker-compose -p mruby run test ls`
+- `$ docker-compose -p mruby run test rake doc:api`
+
+If you want to test using a different `docker-compose` YAML config file you
+can use the `-f` flag:
+
+`$ docker-compose -p mruby -f docker-compose.test.yml run test`
+
+- <https://docs.docker.com/compose/>
+- <https://docs.docker.com/engine/reference/commandline/cli/>
+
+## Spell Checking
+
+We are using `prek` to run [codespell](https://github.com/codespell-project/codespell)
+to check code for common misspellings. We have a small custom dictionary file [codespell.txt](.github/linters/codespell.txt).
+
 ## Coding conventions
 
 How to style your C and Ruby code which you want to submit.
@@ -32,7 +144,7 @@ C code:
 
 mruby should be highly portable to other systems and compilers. For this it is
 recommended to keep your code as close as possible to the C99 standard
-(http://www.open-std.org/jtc1/sc22/WG14/www/docs/n1256.pdf).
+(<http://www.open-std.org/jtc1/sc22/WG14/www/docs/n1256.pdf>).
 
 Visual C++ is also an important target for mruby (supported version is 2013 or
 later). For this reason features that are not supported by Visual C++ may not
@@ -48,13 +160,13 @@ on-demand.
 
 #### Insert a break after the function return value:
 
-    ```C
-    int
-    main(void)
-    {
-      ...
-    }
-    ```
+```c
+int
+main(void)
+{
+  ...
+}
+```
 
 ### Ruby code
 
@@ -64,5 +176,18 @@ language itself. Please note the following hints for your Ruby code:
 #### Comply with the Ruby standard (ISO/IEC 30170:2012)
 
 mruby is currently targeting to execute Ruby code which complies to ISO/IEC
-30170:2012 (https://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=59579),
+30170:2012 (<https://www.iso.org/standard/59579.html>),
 unless there's a clear reason, e.g. the latest Ruby has changed behavior from ISO.
+
+## Building documentation
+
+### mruby API
+
+- [YARD](https://yardoc.org/) - YARD is a documentation generation tool for the Ruby programming language
+- [yard-mruby](https://rubygems.org/gems/yard-mruby) - Document mruby sources with YARD
+- [yard-coderay](https://rubygems.org/gems/yard-coderay) - Adds coderay syntax highlighting to YARD docs
+
+### C API
+
+- [Doxygen](https://www.doxygen.nl/) - Generate documentation from source code
+- [Graphviz](https://graphviz.org/) - Graphviz is open source graph visualization software

Dockerfile

@@ -0,0 +1,13 @@
+FROM ruby:3.2.2-bullseye
+
+RUN apt-get update && apt-get install --no-install-recommends -y python3-pip shellcheck \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY Gemfile Gemfile.lock .pre-commit-config.yaml ./
+
+RUN bundle install && pip3 install --no-cache-dir pre-commit && git init . && pre-commit install-hooks
+
+COPY . .

Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gem 'rake'
+gem 'yard'
+gem 'yard-coderay'
+gem 'yard-mruby'

Gemfile.lock

@@ -0,0 +1,25 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.3)
+    rake (13.3.1)
+    yard (0.9.38)
+    yard-coderay (0.1.0)
+      coderay
+      yard
+    yard-mruby (0.3.0)
+      yard (~> 0.9.0)
+
+PLATFORMS
+  ruby
+  x86_64-darwin-21
+  x86_64-linux
+
+DEPENDENCIES
+  rake
+  yard
+  yard-coderay
+  yard-mruby
+
+BUNDLED WITH
+   2.4.10

LEGAL

@@ -4,3 +4,59 @@ LEGAL NOTICE INFORMATION
 All the files in this distribution are covered under the MIT license
 (see the file LICENSE) except some files mentioned below:
 
+- src/string.c (memsearch_swar): 2 clause BSD license code by Wojciech Muła (@WojciechMula)
+- src/fmt_fp.c: public domain by Dave Hylands (@dhylands)
+- mrbgems/mruby-dir/src/Win/dirent.c: MIT-like license by Kevlin Henney
+
+[src/string.c]
+The implementation of mrb_memsearch_ss() is taken from
+https://github.com/WojciechMula/sse4-strstr.git
+
+Copyright (c) 2008-2016, Wojciech Muła
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+[src/fmt_fp.c]
+
+The code in this function was inspired from Fred Bayer's pdouble.c.
+Since pdouble.c was released as Public Domain, I'm releasing this
+code as public domain as well.
+
+Dave Hylands
+
+The original code can be found in https://github.com/dhylands/format-float
+
+[mrbgems/mruby-dir/src/Win/dirent.c] used only for Windows platform
+
+Copyright Kevlin Henney, 1997, 2003, 2012. All rights reserved.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose is hereby granted without fee, provided
+that this copyright and permissions notice appear in all copies and
+derivatives.
+
+This software is supplied "as is" without express or implied warranty.
+
+But that said, if there are any problems please get in touch.

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2021 mruby developers
+Copyright (c) 2010- mruby developers
 
 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the "Software"),
@@ -17,4 +17,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.
-

Makefile

@@ -1,15 +1,63 @@
 # mruby is using Rake (https://ruby.github.io/rake/) as a build tool.
 
 RAKE = rake
+DOCKER_COMPOSE = docker-compose
+PRE_COMMIT = prek
 
-all :
+define check_command
+	@command -v $(1) >/dev/null 2>&1 || { \
+		echo "Error: $(1) is not installed or not in PATH."; \
+		exit 1; \
+	}
+endef
+
+# For colors
+ifneq ($(shell tty -s),)
+	CYAN := $(shell tput setaf 6)
+	RESET := $(shell tput sgr0)
+else
+	CYAN :=
+	RESET :=
+endif
+
+.PHONY: all test clean check checkinstall checkupdate composecheck composetest check_rake check_docker_compose check_pre_commit help
+.DEFAULT_GOAL := all
+
+all: check_rake ## build all targets, install (locally) in-repo
 	$(RAKE)
-.PHONY : all
 
-test : all
+test: check_rake all ## build and run all mruby tests
 	$(RAKE) test
-.PHONY : test
 
-clean :
+clean: check_rake ## clean all built and in-repo installed artifacts
 	$(RAKE) clean
-.PHONY : clean
+
+check: check_pre_commit ## run all prek hooks against all files
+	$(PRE_COMMIT) run --all-files
+
+checkinstall: check_pre_commit ## install the prek hooks
+	$(PRE_COMMIT) install
+
+checkupdate: check_pre_commit ## check the prek hooks for updates
+	$(PRE_COMMIT) autoupdate
+
+composecheck: check_docker_compose check_pre_commit ## run all prek hooks against all files with docker-compose
+	$(DOCKER_COMPOSE) -p mruby run test $(PRE_COMMIT) run --all-files
+
+composetest: check_docker_compose ## build and run all mruby tests with docker-compose
+	$(DOCKER_COMPOSE) -p mruby run test
+
+check_rake: ## check if Rake is installed
+	$(call check_command, $(RAKE))
+
+check_docker_compose: ## check if docker-compose is installed
+	$(call check_command, $(DOCKER_COMPOSE))
+
+check_pre_commit: ## check if prek is installed
+	$(call check_command, $(PRE_COMMIT))
+
+help: ## display this help message
+	@echo "Usage: make <target>"
+	@echo
+	@echo "Available targets:"
+	@grep -E '^[a-z_-]+:.*##' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*## *"}; {printf "  $(CYAN)%-20s$(RESET) %s\n", $$1, $$2}'

NEWS

@@ -1,13 +0,0 @@
-* NEWS
-
-This document is a list of user visible feature changes made between
-releases except for bug fixes.
-
-Note that each entry is kept so brief that no reason behind or
-reference information is supplied with.  For a full list of changes
-with all sufficient information, see the ChangeLog file.
-
-
-** Information about first release v1.0.0
-
-

NEWS.md

@@ -0,0 +1,323 @@
+# User visible changes in `mruby4.0` from `mruby3.4`
+
+"**_NOTE_**:" are changes to be aware of.
+
+# The language
+
+## Pattern Matching
+
+mruby now supports pattern matching (case/in) syntax:
+
+- Basic pattern matching with `case`/`in` syntax ([dadfac6](https://github.com/mruby/mruby/commit/dadfac6))
+- Array pattern matching ([ec67fd9](https://github.com/mruby/mruby/commit/ec67fd9))
+- Hash pattern matching ([2147263](https://github.com/mruby/mruby/commit/2147263))
+- Find pattern matching (`[*pre, target, *post]`) ([6c4d98b](https://github.com/mruby/mruby/commit/6c4d98b))
+- Pin operator (`^variable`) ([1de6340](https://github.com/mruby/mruby/commit/1de6340))
+- Guard clauses (`if`/`unless` conditions) ([07ac110](https://github.com/mruby/mruby/commit/07ac110))
+- One-line pattern matching (`expr in pattern`) ([e76ce24](https://github.com/mruby/mruby/commit/e76ce24))
+- Brace-less hash pattern support ([e8096bf](https://github.com/mruby/mruby/commit/e8096bf))
+
+## Other Language Changes
+
+- `&nil` in formal parameters to explicitly opt out of block arguments ([b07518e](https://github.com/mruby/mruby/commit/b07518e))
+- Trailing comma in method definition parameters: `def foo(a, b,)` ([f78334b](https://github.com/mruby/mruby/commit/f78334b))
+- Array/Hash/String subclasses can now override `[]` and `[]=` methods ([#6675](https://github.com/mruby/mruby/pull/6675))
+- `OP_SETIDX` optimization for Array and Hash ([ddd8fe1](https://github.com/mruby/mruby/commit/ddd8fe1))
+
+# Changes in C API
+
+- **_NOTE_**: `mrb_alloca()` renamed to `mrb_temp_alloc()` ([7fe5c2e](https://github.com/mruby/mruby/commit/7fe5c2e))
+- **_NOTE_**: `mruby/ext/io.h` renamed to `mruby/io.h` ([2813f79](https://github.com/mruby/mruby/commit/2813f79))
+- `mrb_gc_add_region()` for contiguous heap region support ([072855a](https://github.com/mruby/mruby/commit/072855a))
+- `mrb_class_outer()` to get the outer class/module ([3a1b771](https://github.com/mruby/mruby/commit/3a1b771))
+- `MRB_ENSURE()` macro for exception-safe cleanup ([3ac682b](https://github.com/mruby/mruby/commit/3ac682b))
+- `mrb_time_get_tm()` for accessing struct tm ([daaaafe](https://github.com/mruby/mruby/commit/daaaafe))
+- `MRB_OPEN_FAILURE()` macro for checking mrb_open result ([40b0cb9](https://github.com/mruby/mruby/commit/40b0cb9))
+- `mrb_print_error()` now handles NULL gracefully ([8e50a45](https://github.com/mruby/mruby/commit/8e50a45))
+- `mrb_open()` returns mrb_state with exc set on init failure ([05ffe0c](https://github.com/mruby/mruby/commit/05ffe0c))
+- `mrb_utf8_to_buf()` for UTF-8 encoding consolidation ([7e28e68](https://github.com/mruby/mruby/commit/7e28e68))
+- `kh_is_end()` macro for safe khash iteration ([893cc75](https://github.com/mruby/mruby/commit/893cc75))
+
+# ROM Method Tables
+
+All built-in classes and most extension gems now use read-only method
+tables stored in `.rodata` instead of heap-allocated hash tables. Method
+definitions no longer consume heap memory, significantly reducing memory
+footprint for embedded use.
+
+Core classes converted: BasicObject, Object, Module, Class, Kernel,
+String, Array, Hash, Numeric, Integer, Float, NilClass, TrueClass,
+FalseClass, Range, Symbol, Exception, Proc.
+
+Extension gems converted: mruby-string-ext, mruby-array-ext, mruby-set,
+mruby-struct, mruby-class-ext, mruby-numeric-ext, mruby-random,
+mruby-kernel-ext, mruby-complex, mruby-rational, mruby-io, mruby-socket,
+mruby-method, mruby-metaprog, mruby-time, mruby-hash-ext, mruby-proc-ext,
+mruby-symbol-ext, mruby-range-ext, mruby-object-ext.
+
+# GC and Memory
+
+- **_NOTE_**: `MRB_NO_PRESYM` removed; presym is now always enabled ([81689045](https://github.com/mruby/mruby/commit/81689045))
+- Replace `gcnext` gray linked list with fixed-size gray stack, reducing per-object overhead ([31fea170](https://github.com/mruby/mruby/commit/31fea170))
+- `mrb_gc_add_region()` for providing contiguous memory buffers as GC heap pages ([072855a](https://github.com/mruby/mruby/commit/072855a))
+- Chunk-based pool for symbol string allocation ([e05bd8f](https://github.com/mruby/mruby/commit/e05bd8f))
+- Reduce `IV_INITIAL_SIZE` from 4 to 2 ([6bd1f51](https://github.com/mruby/mruby/commit/6bd1f51))
+- Lossless float encoding using rotation in word boxing ([b6148c8](https://github.com/mruby/mruby/commit/b6148c8))
+- Lossless rotation encoding for 32-bit float32 word boxing ([14a5cfb](https://github.com/mruby/mruby/commit/14a5cfb))
+- Consolidated irep allocation for .mrb loading ([74fb045](https://github.com/mruby/mruby/commit/74fb045))
+- Object shapes (hidden classes) for `MRB_TT_OBJECT` IV storage, sharing key layouts across objects with the same instance variable assignment order ([8d10056](https://github.com/mruby/mruby/commit/8d10056))
+
+# Build & Configuration
+
+- **_NOTE_**: `MRB_WORDBOX_NO_FLOAT_TRUNCATE` renamed to `MRB_WORDBOX_NO_INLINE_FLOAT` (old name still works) ([59e1fe2](https://github.com/mruby/mruby/commit/59e1fe2))
+- **_NOTE_**: `MRB_INT64` on 32-bit now requires `MRB_NO_BOXING` (other boxing modes cannot guarantee alignment for heap-allocated 64-bit integers) ([eaaa66b](https://github.com/mruby/mruby/commit/eaaa66b))
+- Amalgamation support via `rake amalgam` task ([d995ca2](https://github.com/mruby/mruby/commit/d995ca2))
+- New Platform: Cosmopolitan Libc ([#6681](https://github.com/mruby/mruby/pull/6681))
+- Emscripten: use native WASM exception handling ([ca364e3](https://github.com/mruby/mruby/commit/ca364e3))
+- HAL (Hardware Abstraction Layer) for platform abstraction in mruby-io, mruby-socket, mruby-dir, mruby-task ([74ca22f](https://github.com/mruby/mruby/commit/74ca22f))
+- `MRUBY_MIRB_READLINE` environment variable to control readline library selection ([0aafb83](https://github.com/mruby/mruby/commit/0aafb83))
+- Inter-gem headers separated from external API headers ([#6671](https://github.com/mruby/mruby/pull/6671))
+
+# Changes in mrbgems
+
+## New Gems
+
+- **mruby-task**: Cooperative multitasking with preemptive scheduling ([ae0d7a0](https://github.com/mruby/mruby/commit/ae0d7a0))
+- **mruby-benchmark**: Benchmarking gem ([2f40f3d](https://github.com/mruby/mruby/commit/2f40f3d))
+- **mruby-strftime**: Time#strftime implementation ([b31e22f](https://github.com/mruby/mruby/commit/b31e22f))
+
+## mruby-bin-mirb Improvements
+
+- Custom multi-line editor replacing readline ([527018c](https://github.com/mruby/mruby/commit/527018c))
+- Syntax highlighting for keywords, strings, result values, hash key symbols ([624272b](https://github.com/mruby/mruby/commit/624272b), [1713d4a](https://github.com/mruby/mruby/commit/1713d4a))
+- Automatic light/dark theme detection via OSC 11 ([db4c8d9](https://github.com/mruby/mruby/commit/db4c8d9))
+- Tab completion support ([2f15282](https://github.com/mruby/mruby/commit/2f15282))
+- Colored output for prompts and errors ([b36e0b4](https://github.com/mruby/mruby/commit/b36e0b4))
+- Auto-indentation and auto-dedent ([d52f318](https://github.com/mruby/mruby/commit/d52f318), [e901b6d](https://github.com/mruby/mruby/commit/e901b6d))
+- Command history with Up/Down navigation ([5f85c1b](https://github.com/mruby/mruby/commit/5f85c1b))
+- Line numbers in multi-line prompts ([5a3f0e2](https://github.com/mruby/mruby/commit/5a3f0e2))
+- UTF-8 multibyte character support ([4a97da3](https://github.com/mruby/mruby/commit/4a97da3))
+
+## mruby-bigint Improvements
+
+- Toom-3 multiplication for large numbers ([99620804](https://github.com/mruby/mruby/commit/99620804))
+- Karatsuba multiplication for medium-sized numbers ([85e81072](https://github.com/mruby/mruby/commit/85e81072))
+- Balance multiplication for asymmetric operands ([0220ec2b](https://github.com/mruby/mruby/commit/0220ec2b))
+- Divide-and-conquer optimization for `to_s` ([990ff90f](https://github.com/mruby/mruby/commit/990ff90f))
+- Consolidated mpn layer for low-level limb operations ([9ef3362f](https://github.com/mruby/mruby/commit/9ef3362f))
+- Always use 32-bit limbs by default ([c747c77f](https://github.com/mruby/mruby/commit/c747c77f))
+
+## Other Gem Changes
+
+- **_NOTE_**: `Hash#deconstruct_keys` removed for CRuby compatibility ([34b9412](https://github.com/mruby/mruby/commit/34b9412))
+- **mruby-array-ext**: Add `Array#find` and `Array#rfind` methods
+- **mruby-io**: Add `IO#putc` and `Kernel#putc` ([baff6e6](https://github.com/mruby/mruby/commit/baff6e6))
+- **mruby-random**: Replace xoshiro with PCG for better memory efficiency ([f1bab01](https://github.com/mruby/mruby/commit/f1bab01))
+- **mruby-compiler**: Variable-sized AST nodes for reduced memory usage
+- **mruby-compiler**: `no_return_value` context flag for script optimization ([613b03a](https://github.com/mruby/mruby/commit/613b03a))
+- `initialize_copy` and `respond_to_missing?` defined as private ([#6708](https://github.com/mruby/mruby/pull/6708))
+- Struct keyword argument initialization ([#6574](https://github.com/mruby/mruby/pull/6574))
+
+# Compiler Improvements
+
+- Variable-sized AST nodes for reduced memory consumption ([821b989](https://github.com/mruby/mruby/commit/821b989))
+- Pattern matching bytecode optimizations ([21d4135](https://github.com/mruby/mruby/commit/21d4135))
+- Optimized masgn to generate literals directly into target registers ([fb5d966](https://github.com/mruby/mruby/commit/fb5d966))
+- Optimized splat of literal arrays in args/literals ([1cb8d73](https://github.com/mruby/mruby/commit/1cb8d73))
+- Early termination after too many parse errors ([510ebd7](https://github.com/mruby/mruby/commit/510ebd7))
+
+# VM Optimizations
+
+New super-instructions that fuse common opcode sequences to reduce bytecode size and improve performance:
+
+- `OP_SEND0`/`OP_SSEND0`: Zero-argument method call, avoiding argument count setup ([9123ef4](https://github.com/mruby/mruby/commit/9123ef4))
+- `OP_TDEF`/`OP_SDEF`: Fused method definition combining TCLASS/SCLASS+METHOD+DEF into single instruction, saving 4 bytes per method ([8d4f47e](https://github.com/mruby/mruby/commit/8d4f47e))
+- `OP_GETIDX0`: Fast path for `array[0]` and `Array#first` access ([680f7ec](https://github.com/mruby/mruby/commit/680f7ec))
+- `OP_ADDILV`/`OP_SUBILV`: Local variable increment/decrement fusion for `i += n` patterns ([43f64b9](https://github.com/mruby/mruby/commit/43f64b9))
+- `OP_RETSELF`: Single-byte instruction for `return self` pattern ([a71db8c](https://github.com/mruby/mruby/commit/a71db8c))
+- `OP_RETNIL`: Single-byte instruction for `return nil` pattern ([64e30bf](https://github.com/mruby/mruby/commit/64e30bf))
+- `OP_RETTRUE`/`OP_RETFALSE`: Single-byte instructions for `return true`/`return false` patterns ([0b15727](https://github.com/mruby/mruby/commit/0b15727))
+- `OP_MATCHERR`: Pattern matching error with conditional execution ([944168a](https://github.com/mruby/mruby/commit/944168a))
+- `OP_BLKCALL`: Direct block call for `yield`, bypassing method dispatch (13-17% faster) ([3aa2872](https://github.com/mruby/mruby/commit/3aa2872))
+
+Other optimizations:
+
+- 1.5x stack growth instead of linear growth for reduced reallocations ([f7988c93](https://github.com/mruby/mruby/commit/f7988c93))
+- Skip keyword argument hash duplication ([5970e350](https://github.com/mruby/mruby/commit/5970e350))
+
+# Fixed GitHub Issues
+
+- [#5531](https://github.com/mruby/mruby/issues/5531) Hash recursion detection
+- [#6506](https://github.com/mruby/mruby/issues/6506) Constant lookup in singleton class
+- [#6507](https://github.com/mruby/mruby/issues/6507) tally multi-values
+- [#6508](https://github.com/mruby/mruby/issues/6508) Enumerable#sum index
+- [#6509](https://github.com/mruby/mruby/issues/6509) scope_new nregs initialization
+- [#6515](https://github.com/mruby/mruby/issues/6515) y.tab.c in repository
+- [#6516](https://github.com/mruby/mruby/issues/6516) Private backquote
+- [#6554](https://github.com/mruby/mruby/issues/6554) Socket private #initialize
+- [#6570](https://github.com/mruby/mruby/issues/6570) instance_eval crash
+- [#6613](https://github.com/mruby/mruby/issues/6613) const_added hook during bootstrapping
+- [#6635](https://github.com/mruby/mruby/issues/6635), [#6636](https://github.com/mruby/mruby/issues/6636) Colon3 constant lookup
+- [#6637](https://github.com/mruby/mruby/issues/6637) arm64 mingw64 builtin setjmp/longjmp
+- [#6642](https://github.com/mruby/mruby/issues/6642) Task segfault when sleep called from C
+- [#6645](https://github.com/mruby/mruby/issues/6645) Set memory leak from double initialization
+- [#6646](https://github.com/mruby/mruby/issues/6646) IO#gets negative length
+- [#6647](https://github.com/mruby/mruby/issues/6647) IO#ungetc buffer overflow
+- [#6648](https://github.com/mruby/mruby/issues/6648) sprintf buffer overread
+- [#6649](https://github.com/mruby/mruby/issues/6649) Array#sort! use-after-realloc
+- [#6650](https://github.com/mruby/mruby/issues/6650) Array#fill validation
+- [#6652](https://github.com/mruby/mruby/issues/6652) Array comparison use-after-realloc
+- [#6657](https://github.com/mruby/mruby/issues/6657) Exception handling for ||= on class variables
+- [#6659](https://github.com/mruby/mruby/issues/6659) Super with keyword arguments
+- [#6660](https://github.com/mruby/mruby/issues/6660) Regression on struct/array/hash == override with super
+- [#6662](https://github.com/mruby/mruby/issues/6662) Array set operations use-after-free
+- [#6664](https://github.com/mruby/mruby/issues/6664) Set#flatten memory leak
+- [#6666](https://github.com/mruby/mruby/issues/6666) Regexp literal with encoding
+- [#6668](https://github.com/mruby/mruby/issues/6668) Method#== for aliased methods and comparison bug
+- [#6671](https://github.com/mruby/mruby/issues/6671) Separate inter-gem headers from external API headers
+- [#6674](https://github.com/mruby/mruby/issues/6674) Document pattern matching limitations
+- [#6675](https://github.com/mruby/mruby/issues/6675) Allow Hash#[] to be aliased again
+- [#6687](https://github.com/mruby/mruby/issues/6687) Expand MRB_SYM/MRB_GVSYM support for symbols with special characters
+- [#6698](https://github.com/mruby/mruby/issues/6698) Bigint tests fail on architectures other than x86_64 and i386
+- [#6701](https://github.com/mruby/mruby/issues/6701) Heap-use-after-free in mrb_vm_exec involving mruby-rational / mruby-bigint
+- [#6702](https://github.com/mruby/mruby/issues/6702) mruby-bigint doesn't compile in C++ project
+- [#6704](https://github.com/mruby/mruby/issues/6704) Heap-buffer-overflow in mrb_vm_exec via malformed source code
+- [#6705](https://github.com/mruby/mruby/issues/6705) Can't get outer class of an object in C
+- [#6713](https://github.com/mruby/mruby/issues/6713) mruby-polarssl not work
+- [#6720](https://github.com/mruby/mruby/issues/6720) Random float range: different behavior from CRuby
+
+# Merged Pull Requests
+
+- [#6418](https://github.com/mruby/mruby/pull/6418) Add `ls-lint` with GitHub Actions
+- [#6492](https://github.com/mruby/mruby/pull/6492) fix a typo, update specs
+- [#6493](https://github.com/mruby/mruby/pull/6493) Fix TYPO in memory.md
+- [#6495](https://github.com/mruby/mruby/pull/6495) Remove `MRB_ENDIAN_LOHI()` that is no longer in use
+- [#6497](https://github.com/mruby/mruby/pull/6497) gha: update `build.yml` try `windows-2025` image
+- [#6498](https://github.com/mruby/mruby/pull/6498) Clean up and standardize the pre-commit config
+- [#6501](https://github.com/mruby/mruby/pull/6501) Update pre-commit Node.js version to `v22.14.0 LTS`
+- [#6502](https://github.com/mruby/mruby/pull/6502) pre-commit: update prettier to the latest version
+- [#6503](https://github.com/mruby/mruby/pull/6503) misc: fix typos
+- [#6505](https://github.com/mruby/mruby/pull/6505) mrbgems: fix spelling
+- [#6510](https://github.com/mruby/mruby/pull/6510) Fixed class method visibility via `module_function`
+- [#6511](https://github.com/mruby/mruby/pull/6511) Exclude the external project "lrama" from pre-commit
+- [#6513](https://github.com/mruby/mruby/pull/6513) mruby 3.4.0 released
+- [#6517](https://github.com/mruby/mruby/pull/6517) core/codegen.c: remove unneeded duplicate semicolon
+- [#6518](https://github.com/mruby/mruby/pull/6518) Change mrbc_args.flags bit width from 2 to 3
+- [#6519](https://github.com/mruby/mruby/pull/6519) Add `tools/lrama` to `.prettierignore`
+- [#6520](https://github.com/mruby/mruby/pull/6520) pre-commit: autoupdate and update node LTS version
+- [#6521](https://github.com/mruby/mruby/pull/6521) Add codespell config file `.codespellrc`
+- [#6522](https://github.com/mruby/mruby/pull/6522) gha: label more files
+- [#6523](https://github.com/mruby/mruby/pull/6523) add `rand(Range)` and unify implementations of `Random#rand` and `Kernel#rand`
+- [#6524](https://github.com/mruby/mruby/pull/6524) Fix Kernel#p when no argument
+- [#6525](https://github.com/mruby/mruby/pull/6525) Skip adding empty input to mirb history
+- [#6526](https://github.com/mruby/mruby/pull/6526) Add build config for Luckfox Pico embedded SBC
+- [#6528](https://github.com/mruby/mruby/pull/6528) misc: fix spelling
+- [#6530](https://github.com/mruby/mruby/pull/6530) Revert "class.c (find_visibility_scope): when callinfo returns, \*ep == NULL; #6512"
+- [#6531](https://github.com/mruby/mruby/pull/6531) Improve method table performance by rehashing at 75% load factor
+- [#6532](https://github.com/mruby/mruby/pull/6532) Reverted method table optimizations to prioritize memory savings
+- [#6533](https://github.com/mruby/mruby/pull/6533) Fix calling `extended` callback
+- [#6534](https://github.com/mruby/mruby/pull/6534) Add descriptive comment to mrb_read_float function
+- [#6535](https://github.com/mruby/mruby/pull/6535) Added descriptive comments for functions/macros in src/mempool.c
+- [#6536](https://github.com/mruby/mruby/pull/6536) Add descriptive comments to public functions in src/debug.c
+- [#6537](https://github.com/mruby/mruby/pull/6537) Updated comments in `cdump.c` to remove the `@brief` tag
+- [#6539](https://github.com/mruby/mruby/pull/6539) Add descriptive comments for functions in src/load.c
+- [#6540](https://github.com/mruby/mruby/pull/6540) Add descriptive comments to MRB_API functions in object.c
+- [#6541](https://github.com/mruby/mruby/pull/6541) Add descriptive comments for MRB_API functions in src/array.c
+- [#6542](https://github.com/mruby/mruby/pull/6542) Add descriptive comments to MRB_API functions in src/symbol.c
+- [#6543](https://github.com/mruby/mruby/pull/6543) Add descriptive comments to several functions in src/dump.c
+- [#6544](https://github.com/mruby/mruby/pull/6544) Fix build strings that must be mutable
+- [#6545](https://github.com/mruby/mruby/pull/6545) Add descriptive comments for MRB_API functions in src/class.c
+- [#6548](https://github.com/mruby/mruby/pull/6548) Add descriptive comments to MRB_API functions in src/etc.c
+- [#6549](https://github.com/mruby/mruby/pull/6549) Add descriptive comments to kernel functions
+- [#6550](https://github.com/mruby/mruby/pull/6550) Add descriptive comments for MRB_API functions in src/proc.c
+- [#6551](https://github.com/mruby/mruby/pull/6551) Add descriptive comments for MRB_API functions in src/state.c
+- [#6552](https://github.com/mruby/mruby/pull/6552) Fix: Correct placement of comments in src/variable.c
+- [#6553](https://github.com/mruby/mruby/pull/6553) Add descriptive comments for MRB_API functions in src/vm.c
+- [#6555](https://github.com/mruby/mruby/pull/6555) `mrb_mt_foreach()` needs to update the pointer at each loop
+- [#6556](https://github.com/mruby/mruby/pull/6556) `iv_foreach()` needs to update the pointer at each loop
+- [#6560](https://github.com/mruby/mruby/pull/6560) Refactor: Improve Set GC marking and freeing
+- [#6561](https://github.com/mruby/mruby/pull/6561) pre-commit updates and fix prettier entrypoint
+- [#6562](https://github.com/mruby/mruby/pull/6562) misc: fix spelling word case
+- [#6563](https://github.com/mruby/mruby/pull/6563) pre-commit add rubocop with one rule spaces for indentation
+- [#6564](https://github.com/mruby/mruby/pull/6564) Remove jumanjihouse pre-commit hooks no longer maintained
+- [#6565](https://github.com/mruby/mruby/pull/6565) Rubocop: fix target Ruby version; add two more cops; fix lint error
+- [#6566](https://github.com/mruby/mruby/pull/6566) Removed unreferenced variables in `CrossBuild#run_bintest`
+- [#6567](https://github.com/mruby/mruby/pull/6567) Avoid array object creation in `cmd_bin` method in bintest
+- [#6568](https://github.com/mruby/mruby/pull/6568) mruby-bin-debugger depends on mruby-bin-mrbc in bintest
+- [#6569](https://github.com/mruby/mruby/pull/6569) sed s/Mruby/MRuby/g
+- [#6571](https://github.com/mruby/mruby/pull/6571) Update limitations.md to add behavior on small hash
+- [#6572](https://github.com/mruby/mruby/pull/6572) Add Claude Code GitHub Workflow
+- [#6573](https://github.com/mruby/mruby/pull/6573) pre-commit fixes and updates
+- [#6574](https://github.com/mruby/mruby/pull/6574) Support initializing structs via keyword arguments
+- [#6575](https://github.com/mruby/mruby/pull/6575) Fix typo in file time methods
+- [#6581](https://github.com/mruby/mruby/pull/6581) Merge `mrb_obj_iv_inspect()` into `mrb_obj_inspect()`
+- [#6582](https://github.com/mruby/mruby/pull/6582) Stricter type tag in `mrb_obj_alloc()`
+- [#6583](https://github.com/mruby/mruby/pull/6583) Add fallback to local build_config.rb before using default configuration
+- [#6585](https://github.com/mruby/mruby/pull/6585) Fix typo in mruby3.2 docs
+- [#6586](https://github.com/mruby/mruby/pull/6586) Makefile: refactor add docs and add command line `help` target
+- [#6587](https://github.com/mruby/mruby/pull/6587) Add Set#hash tests
+- [#6588](https://github.com/mruby/mruby/pull/6588) Add CodeQL Analysis for GitHub Actions
+- [#6589](https://github.com/mruby/mruby/pull/6589) Add pre-commit hook `check-zip-file-is-not-committed`
+- [#6591](https://github.com/mruby/mruby/pull/6591) mruby-eval fix license link in README
+- [#6593](https://github.com/mruby/mruby/pull/6593) README: Add Contributors Avatars, Star History, Table of Contents
+- [#6599](https://github.com/mruby/mruby/pull/6599) pre-commit: run `markdown-link-check`, `oxipng`, `prettier` manually
+- [#6600](https://github.com/mruby/mruby/pull/6600) `dreamcast_shelf build config`: update to use KallistiOS wrappers
+- [#6601](https://github.com/mruby/mruby/pull/6601) fix: skip local build_config.rb when working in MRUBY_ROOT
+- [#6602](https://github.com/mruby/mruby/pull/6602) Improved iseq annotations for `new` and `!=`
+- [#6604](https://github.com/mruby/mruby/pull/6604) pre-commit config updates
+- [#6607](https://github.com/mruby/mruby/pull/6607) fix bigint on raspberry pi
+- [#6610](https://github.com/mruby/mruby/pull/6610) Extract golden ratio prime into constant
+- [#6614](https://github.com/mruby/mruby/pull/6614) Fix uninitialized variable in io_gets causing segmentation fault
+- [#6617](https://github.com/mruby/mruby/pull/6617) Fix various minor problems and speed up build
+- [#6618](https://github.com/mruby/mruby/pull/6618) Stop generating unnecessary C++ files in mruby-bin-mruby
+- [#6621](https://github.com/mruby/mruby/pull/6621) Set up all GEMS before mruby core tasks definition
+- [#6624](https://github.com/mruby/mruby/pull/6624) Fixed wrong `MRuby::Build.current` at the top level of `mrbgem.rake`
+- [#6628](https://github.com/mruby/mruby/pull/6628) Revert `File.absolute_path` logic
+- [#6629](https://github.com/mruby/mruby/pull/6629) pre-commit update
+- [#6631](https://github.com/mruby/mruby/pull/6631) Revert "Rakefile: make the whole thing parallel unless SERIAL=1"
+- [#6633](https://github.com/mruby/mruby/pull/6633) Fix a heap-buffer-overflow in str strip! methods
+- [#6643](https://github.com/mruby/mruby/pull/6643) Fix crash caused by an incorrect node type check in `codegen_masgn`
+- [#6651](https://github.com/mruby/mruby/pull/6651) Address stack-use-after-return in the mruby bigint implementation
+- [#6653](https://github.com/mruby/mruby/pull/6653) Improve HAL-related components for MinGW
+- [#6655](https://github.com/mruby/mruby/pull/6655) Preventing Memory Leaks in `Array#__combination_init`
+- [#6656](https://github.com/mruby/mruby/pull/6656) Fix integer overflow in allocation size calculation
+- [#6663](https://github.com/mruby/mruby/pull/6663) Added the `kh_is_end()` macro function
+- [#6665](https://github.com/mruby/mruby/pull/6665) Fixed use-after-free with `Set#join`
+- [#6670](https://github.com/mruby/mruby/pull/6670) Arranging VM dispatch macros
+- [#6673](https://github.com/mruby/mruby/pull/6673) Adjust broken license links; clean up Markdown
+- [#6677](https://github.com/mruby/mruby/pull/6677) gha: run pre-commit with `--color=always`
+- [#6678](https://github.com/mruby/mruby/pull/6678) Put ls-lint and pre-commit in separate workflow files
+- [#6679](https://github.com/mruby/mruby/pull/6679) pre-commit autoupdate; update node and prettier
+- [#6681](https://github.com/mruby/mruby/pull/6681) Add Cosmopolitan Libc build configuration
+- [#6689](https://github.com/mruby/mruby/pull/6689) docs: fix pre-commit manual hooks; fix link
+- [#6694](https://github.com/mruby/mruby/pull/6694) Fix mirb build under Cosmopolitan
+- [#6695](https://github.com/mruby/mruby/pull/6695) Dependabot: add a cooldown period for new releases
+- [#6696](https://github.com/mruby/mruby/pull/6696) Fix parse error with required kwargs and omitted parens
+- [#6699](https://github.com/mruby/mruby/pull/6699) Fix mruby-task for PicoRuby Integration
+- [#6700](https://github.com/mruby/mruby/pull/6700) Fix float/double pack/unpack on s390x
+- [#6706](https://github.com/mruby/mruby/pull/6706) Refactor task class to use symbol IDs
+- [#6708](https://github.com/mruby/mruby/pull/6708) `initialize_copy` and `respond_to_missing?` defined as private
+- [#6709](https://github.com/mruby/mruby/pull/6709) Add the `MRB_ENSURE()` macro
+- [#6711](https://github.com/mruby/mruby/pull/6711) Fix out of bounds read and write in IO.select
+- [#6714](https://github.com/mruby/mruby/pull/6714) Fix OP_DEBUG operand type and add NULL check for debug_op_hook
+- [#6716](https://github.com/mruby/mruby/pull/6716) Fixes identity for proc object
+- [#6717](https://github.com/mruby/mruby/pull/6717) Fix mruby-task: wrapping by critical section and setting initial task receiver
+- [#6718](https://github.com/mruby/mruby/pull/6718) Add installation instructions for conda and Homebrew
+
+# Security Fixes
+
+- Buffer overflow in bigint uadd ([3f2611e](https://github.com/mruby/mruby/commit/3f2611e))
+- Stack buffer overflow in Montgomery reduction ([edce0a3](https://github.com/mruby/mruby/commit/edce0a3))
+- Buffer overflow in pack_uu encoding ([2993302](https://github.com/mruby/mruby/commit/2993302))
+- Buffer overflow in IO#ungetc ([01ab2ff](https://github.com/mruby/mruby/commit/01ab2ff))
+- Heap-buffer-overflow in pattern alternation codegen ([eea9e30](https://github.com/mruby/mruby/commit/eea9e30))
+- Out of bounds read and write in IO.select ([44831711](https://github.com/mruby/mruby/commit/44831711))
+- Off-by-one in bounds check for symbol names and pool strings in load.c ([b3b8c01](https://github.com/mruby/mruby/commit/b3b8c01))
+- Use-after-free in Set operations ([a6b55e7](https://github.com/mruby/mruby/commit/a6b55e7))
+- Use-after-free in Array set operations ([729b84c](https://github.com/mruby/mruby/commit/729b84c))
+- Use-after-free in Set#join ([0e653eb](https://github.com/mruby/mruby/commit/0e653eb))
+- Use-after-realloc in Array#sort! ([eb39897](https://github.com/mruby/mruby/commit/eb39897))
+- Heap-use-after-free in insertion_sort ([099d2c47](https://github.com/mruby/mruby/commit/099d2c47))
+- Integer overflow in str_check_length ([6afff1c3](https://github.com/mruby/mruby/commit/6afff1c3))
+- Integer overflow in Integer#lcm ([070bef24](https://github.com/mruby/mruby/commit/070bef24))
+- Multiple memory leak fixes in bigint, Set, Array, and Task gems

README.md

@@ -1,38 +1,70 @@
-[![Build Status][build-status-img]][travis-ci]
+<div align="center">
+  <p>
+    <a href="https://mruby.org/">
+      <img src="https://avatars.githubusercontent.com/u/1796512?s=200&v=4"
+        alt="The mruby programming language" title="mruby">
+    </a>
+  </p>
+  <h1>mruby</h1>
+  <a href="https://github.com/marketplace/actions/super-linter">
+    <img src="https://github.com/mruby/mruby/actions/workflows/super-linter.yml/badge.svg"
+      alt="GitHub Super-Linter">
+  </a>
+</div>
+
+### Table of contents
+
+- [What is mruby](#what-is-mruby)
+- [How to get mruby](#how-to-get-mruby)
+- [mruby homepage](#mruby-homepage)
+- [Mailing list](#mailing-list)
+- [How to compile, test, and install (mruby and gems)](#how-to-compile-test-and-install-mruby-and-gems)
+- [Amalgamation (single-file build)](#amalgamation-single-file-build)
+- [Building documentation](#building-documentation)
+- [How to customize mruby (mrbgems)](#how-to-customize-mruby-mrbgems)
+- [Index of Document](#index-of-document)
+- [License](#license)
+- [Note for License](#note-for-license)
+- [How to Contribute](#how-to-contribute)
+- [Star History](#star-history)
+- [Contributors](#contributors)
 
 ## What is mruby
 
 mruby is the lightweight implementation of the Ruby language complying to (part
-of) the [ISO standard][ISO-standard]. Its syntax is Ruby 2.x compatible.
+of) the [ISO standard][ISO-standard] with more recent features provided by Ruby 4.x.
+Also, its syntax is Ruby 4.x compatible.
 
-mruby can be linked and embedded within your application.  We provide the
-interpreter program "mruby" and the interactive mruby shell "mirb" as examples.
-You can also compile Ruby programs into compiled byte code using the mruby
-compiler "mrbc".  All those tools reside in the "bin" directory.  "mrbc" is
-also able to generate compiled byte code in a C source file, see the "mrbtest"
-program under the "test" directory for an example.
+You can link and embed mruby within your application. The "mruby" interpreter
+program and the interactive "mirb" shell are provided as examples. You can also
+compile Ruby programs into compiled byte code using the "mrbc" compiler. All
+these tools are located in the "bin" directory. "mrbc" can also generate
+compiled byte code in a C source file. See the "mrbtest" program under the
+"test" directory for an example.
 
 This achievement was sponsored by the Regional Innovation Creation R&D Programs
 of the Ministry of Economy, Trade and Industry of Japan.
 
 ## How to get mruby
 
-The releace candidate version 3.0.0 of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/archive/3.0.0-rc.zip](https://github.com/mruby/mruby/archive/3.0.0-rc.zip)
+To get mruby, you can download the stable version 4.0.0 from the official mruby
+GitHub repository or clone the trunk of the mruby source tree with the "git
+clone" command. You can also install and compile mruby using [ruby-install](https://github.com/postmodern/ruby-install), [ruby-build](https://github.com/rbenv/ruby-build), [rvm](https://github.com/rvm/rvm), [conda](https://anaconda.org/channels/conda-forge/packages/mruby/overview) or [Homebrew](https://formulae.brew.sh/formula/mruby).
 
-The stable version 2.1.2 of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/archive/2.1.2.zip](https://github.com/mruby/mruby/archive/2.1.2.zip)
+The release candidate version 4.0.0 of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/archive/4.0.0-rc3.zip](https://github.com/mruby/mruby/archive/4.0.0-rc3.zip)
 
 The latest development version of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/zipball/master](https://github.com/mruby/mruby/zipball/master)
 
 The trunk of the mruby source tree can be checked out with the
 following command:
 
-    $ git clone https://github.com/mruby/mruby.git
+```console
+$ git clone https://github.com/mruby/mruby.git
+```
 
-You can also install and compile mruby using [ruby-install](https://github.com/postmodern/ruby-install), [ruby-build](https://github.com/rbenv/ruby-build) or [rvm](https://github.com/rvm/rvm).
+## mruby homepage
 
-## mruby home-page
-
-The URL of the mruby home-page is: https://mruby.org.
+The URL of the mruby homepage is: <https://mruby.org>.
 
 ## Mailing list
 
@@ -40,31 +72,85 @@ We don't have a mailing list, but you can use [GitHub issues](https://github.com
 
 ## How to compile, test, and install (mruby and gems)
 
-See the [compile.md](https://github.com/mruby/mruby/blob/master/doc/guides/compile.md) file.
+For the simplest case, type
+
+```console
+rake all test
+```
+
+See the [compile.md](doc/guides/compile.md) file for the detail.
+
+## Amalgamation (single-file build)
+
+mruby supports amalgamation, which combines all source files into a single
+`mruby.c` and `mruby.h` for easy embedding (similar to SQLite).
+
+```console
+rake amalgam
+```
+
+Output files are generated in `build/host/amalgam/`. To use:
+
+```console
+gcc -I./build/host/amalgam your_app.c ./build/host/amalgam/mruby.c -o your_app -lm
+```
 
 ## Building documentation
 
-There are two sets of documentation in mruby: the mruby API (generated by yard) and C API (Doxygen)
+There are two sets of documentation in mruby: the mruby API (generated by YARD) and C API (Doxygen and Graphviz)
 
 To build both of them, simply go
 
-    rake doc
+```console
+rake doc
+```
 
 You can also view them in your browser
 
-    rake view_api
-    rake view_capi
+```console
+rake view_api
+rake view_capi
+```
 
 ## How to customize mruby (mrbgems)
 
-mruby contains a package manager called *mrbgems*. To create extensions
-in C and/or Ruby you should create a *GEM*. For a documentation of how to
-use mrbgems consult the file [mrbgems.md](https://github.com/mruby/mruby/blob/master/doc/guides/mrbgems.md).
-For example code of how to use mrbgems look into the folder *examples/mrbgems/*.
+mruby contains a package manager called "mrbgems" that you can use to create
+extensions in C and/or Ruby. For a guide on how to use mrbgems, consult the
+[mrbgems.md](doc/guides/mrbgems.md) file, and for example code, refer to the
+[examples/mrbgems/](examples/mrbgems) folder.
+
+## Index of Document
+
+<!--
+    This section is generated by `rake doc:update-index`.
+    All manual changes will get lost.
+-->
+
+<!-- BEGIN OF MRUBY DOCUMENT INDEX -->
+
+- [About the Limitations of mruby](doc/limitations.md)
+- [About Amalgamation (Single-File Build)](doc/guides/amalgamation.md)
+- [C API Reference](doc/guides/capi.md)
+- [About the Compile](doc/guides/compile.md)
+- [About the Debugger with the `mrdb` Command](doc/guides/debugger.md)
+- [About GC Arena](doc/guides/gc-arena-howto.md)
+- [Getting Started with mruby](doc/guides/getting-started.md)
+- [About the mruby directory structure](doc/guides/hier.md)
+- [About Linking with `libmruby`](doc/guides/link.md)
+- [About Memory Allocator Customization and Heap Regions](doc/guides/memory.md)
+- [About Build-time Configurations](doc/guides/mrbconf.md)
+- [About the Build-time Library Manager](doc/guides/mrbgems.md)
+- [ROM Method Tables for Memory-Efficient Method Registration](doc/guides/rom-method-table.md)
+- [About the Symbols](doc/guides/symbol.md)
+- [Internal Implementation / About mruby Architecture](doc/internal/architecture.md)
+- [Internal Implementation / About Value Boxing](doc/internal/boxing.md)
+- [Internal Implementation / About mruby Virtual Machine Instructions](doc/internal/opcode.md)
+
+<!-- END OF MRUBY DOCUMENT INDEX -->
 
 ## License
 
-mruby is released under the [MIT License](https://github.com/mruby/mruby/blob/master/LICENSE).
+mruby is released under the [MIT License](LICENSE).
 
 ## Note for License
 
@@ -72,26 +158,29 @@ mruby has chosen a MIT License due to its permissive license allowing
 developers to target various environments such as embedded systems.
 However, the license requires the display of the copyright notice and license
 information in manuals for instance. Doing so for big projects can be
-complicated or troublesome.  This is why mruby has decided to display "mruby
+complicated or troublesome. This is why mruby has decided to display "mruby
 developers" as the copyright name to make it simple conventionally.
 In the future, mruby might ask you to distribute your new code
 (that you will commit,) under the MIT License as a member of
 "mruby developers" but contributors will keep their copyright.
 (We did not intend for contributors to transfer or waive their copyrights,
-Actual copyright holder name (contributors) will be listed in the AUTHORS
+actual copyright holder name (contributors) will be listed in the [AUTHORS](AUTHORS)
 file.)
 
 Please ask us if you want to distribute your code under another license.
 
 ## How to Contribute
 
-See the [contribution guidelines][contribution-guidelines], and then send a pull
-request to <https://github.com/mruby/mruby>.  We consider you have granted
-non-exclusive right to your contributed code under MIT license.  If you want to
-be named as one of mruby developers, please include an update to the AUTHORS
-file in your pull request.
+To contribute to mruby, please refer to the [contribution guidelines][contribution-guidelines] and send a pull request to the [mruby GitHub repository](https://github.com/mruby/mruby).
+By contributing, you grant non-exclusive rights to your code under the MIT License.
 
-[ISO-standard]: https://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=59579
-[build-status-img]: https://travis-ci.org/mruby/mruby.svg?branch=master
-[contribution-guidelines]: https://github.com/mruby/mruby/blob/master/CONTRIBUTING.md
-[travis-ci]: https://travis-ci.org/mruby/mruby
+## Star History
+
+[![mruby Star History](https://api.star-history.com/svg?repos=mruby/mruby&type=Date)](https://www.star-history.com/#mruby/mruby&Date)
+
+## Contributors
+
+[![mruby Contributors](https://contrib.rocks/image?repo=mruby/mruby&anon=1&max=500)](https://github.com/mruby/mruby/graphs/contributors)
+
+[ISO-standard]: https://www.iso.org/standard/59579.html
+[contribution-guidelines]: CONTRIBUTING.md

Rakefile

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # Build description.
 # basic build file for mruby
 MRUBY_ROOT = File.dirname(File.expand_path(__FILE__))
@@ -17,6 +16,11 @@ require "mruby/build"
 MRUBY_CONFIG = MRuby::Build.mruby_config_path
 load MRUBY_CONFIG
 
+# set up all gems
+MRuby.each_target do
+  gems.setup(self) if enable_gems?
+end
+
 # load basic rules
 MRuby.each_target do |build|
   build.define_rules
@@ -31,8 +35,9 @@ load "#{MRUBY_ROOT}/tasks/bin.rake"
 load "#{MRUBY_ROOT}/tasks/presym.rake"
 load "#{MRUBY_ROOT}/tasks/test.rake"
 load "#{MRUBY_ROOT}/tasks/benchmark.rake"
-load "#{MRUBY_ROOT}/tasks/gitlab.rake"
 load "#{MRUBY_ROOT}/tasks/doc.rake"
+load "#{MRUBY_ROOT}/tasks/install.rake"
+load "#{MRUBY_ROOT}/tasks/amalgam.rake"
 
 ##############################
 # generic build targets, rules
@@ -58,7 +63,7 @@ task :clean do
     rm_rf build.build_dir
     rm_f build.products
   end
-  puts "Cleaned up target build folder"
+  puts "Cleaned up target build directory"
 end
 
 desc "clean everything!"
@@ -66,5 +71,32 @@ task :deep_clean => %w[clean doc:clean] do
   MRuby.each_target do |build|
     rm_rf build.gem_clone_dir
   end
-  puts "Cleaned up mrbgems build folder"
+  rm_rf "#{MRUBY_ROOT}/bin"
+  rm_rf "#{MRUBY_ROOT}/build"
+  puts "Cleaned up mrbgems build directory"
+end
+
+desc "run all pre-commit hooks against all files"
+task :check do
+  sh "prek run --all-files"
+end
+
+desc "install the pre-commit hooks"
+task :checkinstall do
+  sh "prek install"
+end
+
+desc "check the pre-commit hooks for updates"
+task :checkupdate do
+  sh "prek autoupdate"
+end
+
+desc "run all pre-commit hooks against all files with docker-compose"
+task :composecheck do
+  sh "docker-compose -p mruby run test prek run --all-files"
+end
+
+desc "build and run all mruby tests with docker-compose"
+task :composetest do
+  sh "docker-compose -p mruby run test"
 end

SECURITY.md

@@ -0,0 +1,54 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+To report a security vulnerability, please email the mruby team at <matz@ruby.or.jp>. We appreciate your efforts to disclose your findings responsibly.
+
+## Scope
+
+mruby is an embeddable Ruby implementation. Its security model is designed for integration into a host application, which is responsible for sandboxing and resource management. This policy defines what we consider a security vulnerability within the mruby interpreter itself.
+
+### High Priority Security Vulnerabilities
+
+We consider the following issues to be **high priority security vulnerabilities**:
+
+- **Remote Code Execution (RCE)**: The ability to execute arbitrary machine code or shell commands from within a Ruby script, beyond the intended execution scope of the script itself.
+
+### Lower Priority: Crashes (Preferably Report as Bugs)
+
+We **accept but deprioritize** the following issues. We recommend reporting them as **bug reports** on our issue tracker rather than security reports:
+
+- **VM Crash on Valid Ruby Code**: Segmentation faults, assertion failures, or other interpreter crashes triggered by syntactically and semantically valid Ruby scripts.
+  - _Recommendation_: Please report these as bugs on our issue tracker.
+  - _Rationale_: While we will fix these issues, they typically only result in denial of service (DoS), not arbitrary code execution. They are lower priority than RCE vulnerabilities.
+  - _Note_: This does not include standard Ruby exceptions like `TypeError` or `ZeroDivisionError`, which are expected behavior.
+  - _Example_: A segmentation fault when running `[1, 2, 3].map { |x| x * 2 }` is best reported as a bug.
+
+### Out of Scope: Not Considered Security Vulnerabilities
+
+We do **not** consider the following issues to be security vulnerabilities:
+
+- **Resource Exhaustion**: Infinite loops, excessive memory allocation, or high CPU usage originating from a Ruby script.
+  - _Rationale_: The host application is responsible for implementing resource limits, sandboxing, and execution timeouts. mruby provides the execution engine; the host provides the constraints.
+  - _Example_: `loop {}` or `"a" * (2**30)` are not vulnerabilities, even if they lead to memory or CPU exhaustion.
+
+- **Crashes from Malformed Bytecode**: Crashes resulting from loading or executing corrupted or intentionally malformed `.mrb` files.
+  - _Rationale_: mruby's bytecode format is not a security boundary. Applications should only execute bytecode from trusted sources.
+  - _Example_: A crash discovered by fuzzing `.mrb` files is not considered a vulnerability.
+
+- **Crashes from C API Misuse**: Crashes caused by incorrect usage of mruby's C API from the embedding application.
+  - _Rationale_: The C API is a trusted interface for developers. The caller is responsible for adhering to the API contract (e.g., not passing `NULL` pointers, managing object lifetimes correctly).
+  - _Example_: Calling `mrb_funcall()` with an invalid `mrb_state*` pointer is not a vulnerability.
+
+- **Theoretical Undefined Behavior (UB)**: Issues reported by tools like ASAN, UBSan, or Valgrind that do not lead to a demonstrable crash or exploitable behavior in practice.
+  - _Rationale_: While we strive for clean, well-defined code, our focus is on practical security impact. We prioritize fixing UB that is exploitable over issues that are purely theoretical.
+  - _Example_: An integer overflow in an intermediate calculation that gets handled correctly before affecting program output or control flow.
+
+- **Warnings on Large Memory Allocations**: Tooling warnings related to large memory allocations that do not result in a crash.
+  - _Rationale_: mruby is designed to handle `malloc(3)` returning `NULL` on large allocation requests. This is considered graceful error handling, not a vulnerability.
+
+### Summary
+
+- **High Priority Security Reports**: Remote code execution vulnerabilities.
+- **Accepted (but preferably as bug reports)**: VM crashes from valid Ruby code.
+- **Not Accepted as Security Issues**: Resource exhaustion, malformed bytecode, C API misuse, theoretical undefined behavior, or allocation warnings.

TODO.md

@@ -1,17 +1,17 @@
-Thing to Do in the future
-===
+# Things to Do in the future
 
-# After mruby 3.0
+# After mruby 3.4
 
-* replace `fp_fmt.c` by `float_format` (https://github.com/dhylands/format-float.git)
-* multi-precision integer
-* WORD_BOXING: Pack some floats in `mrb_value`
-* NAN_BOXING: Allow `MRB_INT64` along with NaN boxing
-* keyword arguments a la Ruby3.0 (using `OP_SENDVK`)
-* parser and code generator independent from `mrb_state` (mmruby?)
+- parser and code generator independent from `mrb_state` (picoruby?)
+- iv/hash entry cache
+- method inline caching improvements (cache method lookup results)
+- more peephole optimization (if possible)
+- built-in profiler (method call tracing, stack profiling, detailed memory analysis)
+- improved REPL (mirb) features (syntax highlighting)
+- configurable memory pools (per-object-type, memory-constrained devices)
+- suspend/resume VM state (serialize/deserialize for power cycling)
+- CMake build support (better IDE integration, standard C tooling)
 
-# Things to do (Things that are not done yet)
+# Things to do (Things we need to consider)
 
-* `begin ... end while cond` to behave as CRuby
-* special variables ($1,$2..)
-* super in aliased methods
+- special variables ($1,$2..)

appveyor.yml

@@ -4,42 +4,44 @@ shallow_clone: true
 
 environment:
   matrix:
-    - job_name: Visual Studio 2019 64bit
+    - job_name: Visual Studio 2022 64-bit
+      visualcpp: C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat
+      appveyor_build_worker_image: Visual Studio 2022
+
+    - job_name: Visual Studio 2019 64-bit
       visualcpp: C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars64.bat
       appveyor_build_worker_image: Visual Studio 2019
 
-    - job_name: Visual Studio 2019 32bit
+    - job_name: Visual Studio 2019 32-bit
       visualcpp: C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars32.bat
       appveyor_build_worker_image: Visual Studio 2019
 
-    - job_name: Visual Studio 2017 64bit
+    - job_name: Visual Studio 2017 64-bit
       visualcpp: C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat
       appveyor_build_worker_image: Visual Studio 2017
 
-    - job_name: Visual Studio 2017 32bit
+    - job_name: Visual Studio 2017 32-bit
       visualcpp: C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars32.bat
       appveyor_build_worker_image: Visual Studio 2017
 
-    - job_name: Visual Studio 2015 64bit
+    - job_name: Visual Studio 2015 64-bit
       visualcpp: C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat
       appveyor_build_worker_image: Visual Studio 2015
       machine: x86_amd64
 
-    - job_name: Visual Studio 2015 32bit
+    - job_name: Visual Studio 2015 32-bit
       visualcpp: C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat
       appveyor_build_worker_image: Visual Studio 2015
       machine: x86
 
 init:
   - call "%visualcpp%" %machine%
-  # For using Rubyins4aller's Ruby 2.6 64bit
+  # For using RubyInstaller's Ruby 2.6 64-bit
   # 2.6 is the highest supported Ruby version across all historical
   # Visual Studio AppVeyor images. Ruby 2.7 is only on the 2019 image.
   - set PATH=C:\Ruby26-x64\bin;%PATH%
   - ruby --version
 
-
 build_script:
   - set MRUBY_CONFIG=ci/msvc
-  - rake -m test:build
-  - rake test:run
+  - rake -m test:run:serial

benchmark/bm_ao_render.rb

@@ -1,29 +1,29 @@
 # AO render benchmark
-# Original program (C) Syoyo Fujita in Javascript (and other languages)
+# Original program (C) Syoyo Fujita in JavaScript (and other languages)
 #      https://code.google.com/p/aobench/
 # Ruby(yarv2llvm) version by Hideki Miura
 # mruby version by Hideki Miura
 #
 
-IMAGE_WIDTH = 64
-IMAGE_HEIGHT = 64
+IMAGE_WIDTH = Integer(ARGV[0] || 64)
+IMAGE_HEIGHT = IMAGE_WIDTH
 NSUBSAMPLES = 2
 NAO_SAMPLES = 8
 
 module Rand
   # Use xorshift
-  @@x = 123456789
-  @@y = 362436069
-  @@z = 521288629
-  @@w = 88675123
+  @x = 123456789
+  @y = 362436069
+  @z = 521288629
+  @w = 88675123
   BNUM = 1 << 29
   BNUMF = BNUM.to_f
   def self.rand
-    x = @@x
+    x = @x
     t = x ^ ((x & 0xfffff) << 11)
-    w = @@w
-    @@x, @@y, @@z = @@y, @@z, w
-    w = @@w = (w ^ (w >> 19) ^ (t ^ (t >> 8)))
+    w = @w
+    @x, @y, @z = @y, @z, w
+    w = @w = (w ^ (w >> 19) ^ (t ^ (t >> 8)))
     (w % BNUM) / BNUMF
   end
 end
@@ -179,7 +179,7 @@ def clamp(f)
   i.to_i
 end
 
-def otherBasis(basis, n)
+def orthoBasis(basis, n)
   basis[2] = Vec.new(n.x, n.y, n.z)
   basis[1] = Vec.new(0.0, 0.0, 0.0)
 
@@ -211,7 +211,7 @@ class Scene
 
   def ambient_occlusion(isect)
     basis = Array.new(3)
-    otherBasis(basis, isect.n)
+    orthoBasis(basis, isect.n)
 
     ntheta    = NAO_SAMPLES
     nphi      = NAO_SAMPLES
@@ -243,8 +243,6 @@ class Scene
         @plane.intersect(ray, occisect)
         if occisect.hit
           occlusion = occlusion + 1.0
-        else
-          0.0
         end
       end
     end
@@ -254,8 +252,8 @@ class Scene
   end
 
   def render(w, h, nsubsamples)
-    cnt = 0
     nsf = nsubsamples.to_f
+    nsfs = nsf * nsf
     h.times do |y|
       w.times do |x|
         rad = Vec.new(0.0, 0.0, 0.0)
@@ -263,7 +261,6 @@ class Scene
         # Subsampling
         nsubsamples.times do |v|
           nsubsamples.times do |u|
-            cnt = cnt + 1
             wf = w.to_f
             hf = h.to_f
             xf = x.to_f
@@ -288,15 +285,13 @@ class Scene
               rad.x = rad.x + col.x
               rad.y = rad.y + col.y
               rad.z = rad.z + col.z
-            else
-              0.0
             end
           end
         end
 
-        r = rad.x / (nsf * nsf)
-        g = rad.y / (nsf * nsf)
-        b = rad.z / (nsf * nsf)
+        r = rad.x / nsfs
+        g = rad.y / nsfs
+        b = rad.z / nsfs
         printf("%c", clamp(r))
         printf("%c", clamp(g))
         printf("%c", clamp(b))

benchmark/bm_fib.rb

@@ -1,4 +1,3 @@
-
 def fib n
   return n if n < 2
   fib(n-2) + fib(n-1)

benchmark/bm_mandel_term.rb

@@ -0,0 +1,34 @@
+def mandelbrot(c_r, c_i)
+  limit=95
+  iterations=0
+  cr = (c_r * 100).to_i
+  ci = (c_i * 100).to_i
+  zr = zi = 0
+  # Avoid sqrt by squaring the threshold: sqrt(x) < 1000 => x < 1000000
+  while iterations<limit
+    zr2 = zr*zr
+    zi2 = zi*zi
+    break if zr2+zi2 >= 1000000
+    zr, zi = (zr2-zi2)/100+cr, (zr*zi*2)/100+ci
+    iterations+=1
+  end
+  return iterations
+end
+
+def mandel_calc(min_r, min_i, max_r, max_i, res)
+  cur_i = min_i
+  while cur_i > max_i
+    putc "|"
+    cur_r = min_r
+    while cur_r < max_r
+      ch = 127 - mandelbrot(cur_r, cur_i)
+      putc ch  # Use putc with integer - no string allocation!
+      cur_r += res
+    end
+    putc "|"
+    putc "\n"
+    cur_i -= res
+  end
+end
+
+mandel_calc(-2, 1, 1, -1, 0.04)

benchmark/bm_so_lists.rb

@@ -1,9 +1,11 @@
-#from http://www.bagley.org/~doug/shootout/bench/lists/lists.ruby
+# from http://www.bagley.org/~doug/shootout/bench/lists/lists.ruby
+# which is lost long time ago. The past content can be retrieved from
+# https://web.archive.org/web/20040805115204/http://www.bagley.org/~doug/shootout/bench/lists/lists.ruby
 
 NUM = 300
 SIZE = 10000
 
-def test_lists()
+def test_lists
   # create a list of integers (Li1) from 1 to SIZE
   li1 = (1..SIZE).to_a
   # copy the list to li2 (not by individual items)

benchmark/bm_so_mandelbrot.rb

@@ -0,0 +1,65 @@
+#  The Computer Language Benchmarks Game
+#  http://shootout.alioth.debian.org/
+#
+#  contributed by Karl von Laudermann
+#  modified by Jeremy Echols
+#  optimized: while loops instead of for..in to avoid closure overhead
+
+size = 600 # ARGV[0].to_i
+
+puts "P4\n#{size} #{size}"
+
+# Cache constants in local variables to avoid repeated constant lookup
+iter = 49
+limit_squared = 4.0
+
+byte_acc = 0
+bit_num = 0
+
+count_size = size - 1
+
+# Use while loops instead of for..in to avoid closure/upvalue overhead
+y = 0
+while y <= count_size
+  x = 0
+  while x <= count_size
+    zr = 0.0
+    zi = 0.0
+    cr = (2.0*x/size)-1.5
+    ci = (2.0*y/size)-1.0
+    escape = false
+
+    # Use while instead of for..in to avoid closure overhead
+    i = 0
+    while i <= iter
+      tr = zr*zr - zi*zi + cr
+      ti = 2*zr*zi + ci
+      zr = tr
+      zi = ti
+
+      if (zr*zr+zi*zi) > limit_squared
+        escape = true
+        break
+      end
+      i += 1
+    end
+
+    byte_acc = (byte_acc << 1) | (escape ? 0b0 : 0b1)
+    bit_num += 1
+
+    # Code is very similar for these cases, but using separate blocks
+    # ensures we skip the shifting when it's unnecessary, which is most cases.
+    if (bit_num == 8)
+      print byte_acc.chr
+      byte_acc = 0
+      bit_num = 0
+    elsif (x == count_size)
+      byte_acc <<= (8 - bit_num)
+      print byte_acc.chr
+      byte_acc = 0
+      bit_num = 0
+    end
+    x += 1
+  end
+  y += 1
+end

benchmark/build_config_cc.rb

@@ -1,13 +0,0 @@
-MRuby::Build.new do |conf|
-  toolchain :gcc
-end
-
-MRuby::Build.new('gcc') do |conf|
-  toolchain :gcc
-  conf.gembox 'default'
-end
-
-MRuby::Build.new('clang') do |conf|
-  toolchain :clang
-  conf.gembox 'default'
-end

benchmark/vm_dispatch_bench.c

@@ -0,0 +1,197 @@
+/*
+ * VM Dispatch Micro-benchmark
+ *
+ * This benchmark measures the raw dispatch overhead of the mruby VM
+ * by executing minimal bytecode sequences.
+ *
+ * Compile:
+ *   cc -O2 -I include -I build/host/include \
+ *      benchmark/vm_dispatch_bench.c \
+ *      build/host/lib/libmruby.a -lm -o vm_dispatch_bench
+ *
+ * Run:
+ *   ./vm_dispatch_bench
+ */
+
+#include <mruby.h>
+#include <mruby/compile.h>
+#include <mruby/string.h>
+#include <mruby/proc.h>
+#include <stdio.h>
+#include <time.h>
+
+#define ITERATIONS 10
+
+static double
+get_time_ms(void)
+{
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+  return ts.tv_sec * 1000.0 + ts.tv_nsec / 1000000.0;
+}
+
+static void
+run_benchmark(mrb_state *mrb, const char *name, const char *code, int iterations)
+{
+  double times[ITERATIONS];
+  double total = 0.0;
+  double min_time = 1e9;
+  double max_time = 0.0;
+
+  /* Compile once */
+  mrbc_context *cxt = mrbc_context_new(mrb);
+  struct mrb_parser_state *p = mrb_parse_string(mrb, code, cxt);
+  if (!p || p->nerr > 0) {
+    fprintf(stderr, "Failed to parse: %s\n", name);
+    if (p) mrb_parser_free(p);
+    mrbc_context_free(mrb, cxt);
+    return;
+  }
+  struct RProc *proc = mrb_generate_code(mrb, p);
+  mrb_parser_free(p);
+  mrbc_context_free(mrb, cxt);
+
+  if (!proc) {
+    fprintf(stderr, "Failed to compile: %s\n", name);
+    return;
+  }
+
+  /* Warm up */
+  for (int i = 0; i < 3; i++) {
+    mrb_top_run(mrb, proc, mrb_top_self(mrb), 0);
+    mrb->exc = NULL;
+  }
+
+  /* Measure */
+  for (int i = 0; i < iterations; i++) {
+    mrb_gc_arena_save(mrb);
+    mrb_full_gc(mrb);
+
+    double t0 = get_time_ms();
+    mrb_top_run(mrb, proc, mrb_top_self(mrb), 0);
+    double t1 = get_time_ms();
+
+    times[i] = t1 - t0;
+    total += times[i];
+    if (times[i] < min_time) min_time = times[i];
+    if (times[i] > max_time) max_time = times[i];
+
+    mrb->exc = NULL;
+    mrb_gc_arena_restore(mrb, 0);
+  }
+
+  double avg = total / iterations;
+  printf("%-30s avg: %8.2f ms  min: %8.2f ms  max: %8.2f ms\n",
+         name, avg, min_time, max_time);
+}
+
+int
+main(int argc, char **argv)
+{
+  mrb_state *mrb = mrb_open();
+  if (!mrb) {
+    fprintf(stderr, "Failed to create mrb_state\n");
+    return 1;
+  }
+
+  printf("========================================\n");
+  printf("mruby VM Dispatch Micro-benchmarks\n");
+  printf("========================================\n\n");
+
+  /* 1. Pure dispatch overhead */
+  printf("--- Dispatch Overhead ---\n");
+
+  run_benchmark(mrb, "empty_loop_1M",
+    "i = 0; while i < 1000000; i += 1; end", ITERATIONS);
+
+  run_benchmark(mrb, "empty_loop_10M",
+    "i = 0; while i < 10000000; i += 1; end", ITERATIONS);
+
+  /* 2. Arithmetic operations */
+  printf("\n--- Arithmetic ---\n");
+
+  run_benchmark(mrb, "int_add_1M",
+    "x = 0; i = 0; while i < 1000000; x = x + 1; i += 1; end", ITERATIONS);
+
+  run_benchmark(mrb, "int_mul_1M",
+    "x = 1; i = 0; while i < 1000000; x = x * 1; i += 1; end", ITERATIONS);
+
+  run_benchmark(mrb, "float_add_1M",
+    "x = 0.0; i = 0; while i < 1000000; x = x + 1.0; i += 1; end", ITERATIONS);
+
+  /* 3. Method calls */
+  printf("\n--- Method Calls ---\n");
+
+  run_benchmark(mrb, "empty_method_100K",
+    "class X; def m; end; end; "
+    "o = X.new; i = 0; while i < 100000; o.m; i += 1; end", ITERATIONS);
+
+  run_benchmark(mrb, "method_1arg_100K",
+    "class Y; def m(a); a; end; end; "
+    "o = Y.new; i = 0; while i < 100000; o.m(1); i += 1; end", ITERATIONS);
+
+  run_benchmark(mrb, "method_2arg_100K",
+    "class Z; def m(a,b); a+b; end; end; "
+    "o = Z.new; i = 0; while i < 100000; o.m(1,2); i += 1; end", ITERATIONS);
+
+  /* 4. Array access */
+  printf("\n--- Array/Hash ---\n");
+
+  run_benchmark(mrb, "array_read_1M",
+    "a = [0,1,2,3,4,5,6,7,8,9]; "
+    "i = 0; s = 0; while i < 1000000; s += a[i % 10]; i += 1; end", ITERATIONS);
+
+  run_benchmark(mrb, "array_write_1M",
+    "a = [0,0,0,0,0,0,0,0,0,0]; "
+    "i = 0; while i < 1000000; a[i % 10] = i; i += 1; end", ITERATIONS);
+
+  run_benchmark(mrb, "hash_read_100K",
+    "h = {0=>0,1=>1,2=>2,3=>3,4=>4,5=>5,6=>6,7=>7,8=>8,9=>9}; "
+    "i = 0; s = 0; while i < 100000; s += h[i % 10]; i += 1; end", ITERATIONS);
+
+  /* 5. Comparison and branching */
+  printf("\n--- Comparison/Branch ---\n");
+
+  run_benchmark(mrb, "lt_compare_1M",
+    "i = 0; c = 0; while i < 1000000; c += 1 if i < 500000; i += 1; end", ITERATIONS);
+
+  run_benchmark(mrb, "eq_compare_1M",
+    "i = 0; c = 0; while i < 1000000; c += 1 if i == 500000; i += 1; end", ITERATIONS);
+
+  /* 6. Block calls */
+  printf("\n--- Blocks ---\n");
+
+  run_benchmark(mrb, "times_100K",
+    "s = 0; 100000.times { |i| s += i }", ITERATIONS);
+
+  run_benchmark(mrb, "each_100K",
+    "a = (0...1000).to_a; s = 0; 100.times { a.each { |x| s += x } }", ITERATIONS);
+
+  /* 7. Recursion */
+  printf("\n--- Recursion ---\n");
+
+  run_benchmark(mrb, "fib_25",
+    "def fib(n); n < 2 ? n : fib(n-1) + fib(n-2); end; fib(25)", ITERATIONS);
+
+  run_benchmark(mrb, "fib_30",
+    "def fib(n); n < 2 ? n : fib(n-1) + fib(n-2); end; fib(30)", ITERATIONS);
+
+  /* 8. Local variable access */
+  printf("\n--- Local Variables ---\n");
+
+  run_benchmark(mrb, "few_vars_1M",
+    "i = 0; a = 0; b = 0; "
+    "while i < 1000000; a += 1; b += 1; i += 1; end", ITERATIONS);
+
+  run_benchmark(mrb, "many_vars_1M",
+    "i = 0; a = 0; b = 0; c = 0; d = 0; e = 0; f = 0; g = 0; h = 0; "
+    "while i < 1000000; a += 1; b += 1; c += 1; d += 1; e += 1; "
+    "f += 1; g += 1; h += 1; i += 1; end", ITERATIONS);
+
+  printf("\n========================================\n");
+  printf("Benchmark complete\n");
+  printf("========================================\n");
+
+  mrb_close(mrb);
+  return 0;
+}

benchmark/vm_optimization_bench.rb

@@ -0,0 +1,513 @@
+# VM Optimization Benchmarks for mruby
+# Usage: ./bin/mruby benchmark/vm_optimization_bench.rb
+#
+# Each benchmark is designed to isolate specific VM behaviors:
+# - Dispatch overhead
+# - Arithmetic operations
+# - Method calls
+# - Array/Hash access
+# - Loop performance
+
+# Benchmark infrastructure
+def measure(name, iterations = 1)
+  # Warm up
+  3.times { yield }
+
+  # Force GC before measurement
+  GC.start
+
+  t0 = Time.now
+  iterations.times { yield }
+  elapsed = Time.now - t0
+
+  puts "#{name}: #{elapsed * 1000 / iterations} ms"
+  elapsed
+end
+
+N = 1_000_000
+M = 100_000
+
+puts "=" * 60
+puts "mruby VM Optimization Benchmarks"
+puts "=" * 60
+puts
+
+#=============================================================================
+# 1. DISPATCH OVERHEAD BENCHMARKS
+# Target: Tail-call threading, computed goto efficiency
+#=============================================================================
+puts "--- Dispatch Overhead ---"
+
+# 1a. Empty loop (pure dispatch cost)
+measure("empty_loop", 10) do
+  i = 0
+  while i < N
+    i += 1
+  end
+end
+
+# 1b. NOP-heavy (many instructions, minimal work)
+measure("nop_sequence", 10) do
+  i = 0
+  while i < M
+    a = 1; b = 2; c = 3; d = 4; e = 5
+    a = 1; b = 2; c = 3; d = 4; e = 5
+    a = 1; b = 2; c = 3; d = 4; e = 5
+    a = 1; b = 2; c = 3; d = 4; e = 5
+    i += 1
+  end
+end
+
+#=============================================================================
+# 2. ARITHMETIC BENCHMARKS
+# Target: Type specialization, register variables, ADDI fusion
+#=============================================================================
+puts
+puts "--- Arithmetic Operations ---"
+
+# 2a. Integer addition (tests OP_ADD fast path)
+measure("int_add", 10) do
+  x = 0
+  i = 0
+  while i < N
+    x = x + 1
+    i += 1
+  end
+  x
+end
+
+# 2b. Integer increment (tests potential OP_INCI fusion)
+measure("int_increment", 10) do
+  x = 0
+  i = 0
+  while i < N
+    x += 1
+    i += 1
+  end
+  x
+end
+
+# 2c. Mixed arithmetic (tests type checking overhead)
+measure("mixed_arith", 10) do
+  x = 0
+  y = 1.5
+  i = 0
+  while i < M
+    x = x + 1
+    y = y + 0.5
+    i += 1
+  end
+  x
+end
+
+# 2d. Comparison in loop (tests OP_LT + JMPNOT fusion potential)
+measure("comparison_loop", 10) do
+  x = 0
+  while x < N
+    x += 1
+  end
+  x
+end
+
+# 2e. Multiple comparisons (branch prediction)
+measure("multi_compare", 10) do
+  i = 0
+  count = 0
+  while i < M
+    count += 1 if i > 100
+    count += 1 if i < 50000
+    count += 1 if i == 25000
+    i += 1
+  end
+  count
+end
+
+#=============================================================================
+# 3. METHOD CALL BENCHMARKS
+# Target: Inline caching, method dispatch optimization
+#=============================================================================
+puts
+puts "--- Method Calls ---"
+
+class BenchClass
+  def empty_method
+  end
+
+  def simple_add(a, b)
+    a + b
+  end
+
+  def self.class_method
+  end
+end
+
+$obj = BenchClass.new
+
+# 3a. Empty method call (pure dispatch overhead)
+measure("empty_method_call", 10) do
+  obj = $obj
+  i = 0
+  while i < M
+    obj.empty_method
+    i += 1
+  end
+end
+
+# 3b. Method with arguments
+measure("method_with_args", 10) do
+  obj = $obj
+  i = 0
+  while i < M
+    obj.simple_add(1, 2)
+    i += 1
+  end
+end
+
+# 3c. Self method call (tests OP_SENDSELF potential)
+class SelfCallBench
+  def run
+    i = 0
+    while i < M
+      helper
+      i += 1
+    end
+  end
+
+  def helper
+  end
+end
+
+measure("self_method_call", 10) do
+  SelfCallBench.new.run
+end
+
+# 3d. Polymorphic call site (tests inline cache invalidation)
+class Duck1
+  def quack; 1; end
+end
+class Duck2
+  def quack; 2; end
+end
+
+$duck1 = Duck1.new
+$duck2 = Duck2.new
+
+measure("polymorphic_call", 10) do
+  d1, d2 = $duck1, $duck2
+  i = 0
+  sum = 0
+  while i < M
+    sum += d1.quack
+    sum += d2.quack
+    i += 1
+  end
+  sum
+end
+
+#=============================================================================
+# 4. ARRAY/HASH BENCHMARKS
+# Target: GETIDX/SETIDX fast path, bounds checking
+#=============================================================================
+puts
+puts "--- Array/Hash Access ---"
+
+$ary = Array.new(1000) { |i| i }
+$hash = {}
+1000.times { |i| $hash[i] = i }
+
+# 4a. Array read (sequential)
+measure("array_read_seq", 10) do
+  ary = $ary
+  i = 0
+  sum = 0
+  while i < M
+    sum += ary[i % 1000]
+    i += 1
+  end
+  sum
+end
+
+# 4b. Array read (constant index - tests constant propagation)
+measure("array_read_const", 10) do
+  ary = $ary
+  i = 0
+  sum = 0
+  while i < M
+    sum += ary[500]
+    i += 1
+  end
+  sum
+end
+
+# 4c. Array write
+measure("array_write", 10) do
+  ary = Array.new(1000, 0)
+  i = 0
+  while i < M
+    ary[i % 1000] = i
+    i += 1
+  end
+end
+
+# 4d. Hash read
+measure("hash_read", 10) do
+  h = $hash
+  i = 0
+  sum = 0
+  while i < M
+    sum += h[i % 1000]
+    i += 1
+  end
+  sum
+end
+
+#=============================================================================
+# 5. LOOP PATTERN BENCHMARKS
+# Target: Loop optimization, branch prediction
+#=============================================================================
+puts
+puts "--- Loop Patterns ---"
+
+# 5a. Simple while loop
+measure("while_loop", 10) do
+  i = 0
+  while i < N
+    i += 1
+  end
+end
+
+# 5b. times iterator (block overhead)
+measure("times_iterator", 10) do
+  sum = 0
+  M.times do |i|
+    sum += i
+  end
+  sum
+end
+
+# 5c. each iterator on array
+$small_ary = (0...1000).to_a
+measure("each_iterator", 10) do
+  ary = $small_ary
+  total = 0
+  1000.times do
+    ary.each { |x| total += x }
+  end
+  total
+end
+
+# 5d. Nested loops
+measure("nested_loop", 10) do
+  sum = 0
+  i = 0
+  while i < 1000
+    j = 0
+    while j < 1000
+      sum += 1
+      j += 1
+    end
+    i += 1
+  end
+  sum
+end
+
+#=============================================================================
+# 6. CONSTANT LOADING BENCHMARKS
+# Target: Constant pre-computation, pool access
+#=============================================================================
+puts
+puts "--- Constant Loading ---"
+
+# 6a. Integer literals (tests LOADI optimization)
+measure("int_literals", 10) do
+  i = 0
+  sum = 0
+  while i < M
+    sum += 1
+    sum += 2
+    sum += 3
+    sum += 42
+    sum += 100
+    i += 1
+  end
+  sum
+end
+
+# 6b. Large integer literals (tests LOADL from pool)
+measure("large_int_literals", 10) do
+  i = 0
+  sum = 0
+  while i < M
+    sum += 1000000
+    sum += 2000000
+    sum += 3000000
+    i += 1
+  end
+  sum
+end
+
+# 6c. Float literals
+measure("float_literals", 10) do
+  i = 0
+  sum = 0.0
+  while i < M
+    sum += 1.5
+    sum += 2.5
+    sum += 3.5
+    i += 1
+  end
+  sum
+end
+
+# 6d. String literals (allocation vs interning)
+measure("string_literals", 5) do
+  i = 0
+  while i < 100000
+    s = "hello"
+    s = "world"
+    s = "test"
+    i += 1
+  end
+end
+
+#=============================================================================
+# 7. BRANCH PREDICTION BENCHMARKS
+# Target: mrb_likely/mrb_unlikely effectiveness
+#=============================================================================
+puts
+puts "--- Branch Prediction ---"
+
+# 7a. Predictable branch (always true)
+measure("predictable_true", 10) do
+  i = 0
+  count = 0
+  while i < N
+    count += 1 if true
+    i += 1
+  end
+  count
+end
+
+# 7b. Predictable branch (always false)
+measure("predictable_false", 10) do
+  i = 0
+  count = 0
+  while i < N
+    count += 1 if false
+    i += 1
+  end
+  count
+end
+
+# 7c. Unpredictable branch (50/50)
+measure("unpredictable_50", 10) do
+  i = 0
+  count = 0
+  while i < M
+    count += 1 if i & 1 == 0
+    i += 1
+  end
+  count
+end
+
+# 7d. Rare branch (error path simulation)
+measure("rare_branch", 10) do
+  i = 0
+  count = 0
+  while i < N
+    count += 1 if i == -1  # Never true
+    i += 1
+  end
+  count
+end
+
+#=============================================================================
+# 8. REGISTER PRESSURE BENCHMARKS
+# Target: Register variable optimization
+#=============================================================================
+puts
+puts "--- Register Pressure ---"
+
+# 8a. Few local variables (should fit in registers)
+measure("few_locals", 10) do
+  i = 0
+  a = 0
+  while i < N
+    a += 1
+    i += 1
+  end
+  a
+end
+
+# 8b. Many local variables (register spilling)
+measure("many_locals", 10) do
+  i = 0
+  a = 0; b = 0; c = 0; d = 0; e = 0
+  f = 0; g = 0; h = 0; j = 0; k = 0
+  l = 0; m = 0; n = 0; o = 0; p = 0
+  while i < M
+    a += 1; b += 1; c += 1; d += 1; e += 1
+    f += 1; g += 1; h += 1; j += 1; k += 1
+    l += 1; m += 1; n += 1; o += 1; p += 1
+    i += 1
+  end
+  a + b + c + d + e + f + g + h + j + k + l + m + n + o + p
+end
+
+#=============================================================================
+# 9. COMPOSITE BENCHMARKS (Real-world-ish)
+#=============================================================================
+puts
+puts "--- Composite Benchmarks ---"
+
+# 9a. Fibonacci (recursion + arithmetic)
+def fib(n)
+  return n if n < 2
+  fib(n - 1) + fib(n - 2)
+end
+
+measure("fibonacci_30", 3) do
+  fib(30)
+end
+
+# 9b. Tak function (heavy recursion)
+def tak(x, y, z)
+  if y < x
+    tak(tak(x - 1, y, z), tak(y - 1, z, x), tak(z - 1, x, y))
+  else
+    z
+  end
+end
+
+measure("tak_18_12_6", 3) do
+  tak(18, 12, 6)
+end
+
+# 9c. Array manipulation
+measure("array_manipulation", 5) do
+  ary = []
+  10000.times { |i| ary << i }
+  ary.map! { |x| x * 2 }
+  ary.select { |x| x % 3 == 0 }.size
+end
+
+# 9d. String operations
+measure("string_ops", 5) do
+  s = ""
+  10000.times { |i| s = s + i.to_s }
+  s.size
+end
+
+# 9e. Hash operations
+measure("hash_ops", 5) do
+  h = {}
+  50000.times { |i| h[i.to_s] = i }
+  sum = 0
+  h.each { |k, v| sum += v }
+  sum
+end
+
+puts
+puts "=" * 60
+puts "Benchmark complete"
+puts "=" * 60

build_config/ArduinoDue.rb

@@ -11,7 +11,7 @@ MRuby::CrossBuild.new("ArduinoDue") do |conf|
   # ARDUINO_PATH = '/Applications/Arduino.app/Contents/Java'
   # GNU Linux
   ARDUINO_PATH = '/opt/arduino'
-   # Arduino IDE <= 1.5.6
+  # Arduino IDE <= 1.5.6
   BIN_PATH = "#{ARDUINO_PATH}/hardware/tools/g++_arm_none_eabi/bin"
   # Arduino IDE >= 1.5.7
   # BIN_PATH = "#{ARDUINO_PATH}/hardware/tools/gcc-arm-none-eabi-4.8.3-2014q1/bin"
@@ -30,9 +30,9 @@ MRuby::CrossBuild.new("ArduinoDue") do |conf|
 
     #configuration for low memory environment
     cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
-    cc.defines << %w(KHASH_DEFAULT_SIZE=8)
+    cc.defines << %w(KHASH_INITIAL_SIZE=8)
     cc.defines << %w(MRB_GC_STRESS)
-    #cc.defines << %w(MRB_NO_STDIO) #if you dont need stdio.
+    #cc.defines << %w(MRB_NO_STDIO) #if you don't need stdio.
     #cc.defines << %w(POOL_PAGE_SIZE=1000) #effective only for use with mruby-eval
   end
 
@@ -60,7 +60,6 @@ MRuby::CrossBuild.new("ArduinoDue") do |conf|
   conf.disable_cxx_exception
 
   #gems from core
-  conf.gem :core => "mruby-print"
   conf.gem :core => "mruby-math"
   conf.gem :core => "mruby-enum-ext"
 

build_config/IntelEdison.rb

@@ -21,7 +21,7 @@ MRuby::CrossBuild.new('core2-32-poky-linux') do |conf|
   #
   POKY_EDISON_PATH = '/opt/poky-edison/1.7.2'
 
-  POKY_EDISON_SYSROOT =  "#{POKY_EDISON_PATH}/sysroots/core2-32-poky-linux"
+  POKY_EDISON_SYSROOT  = "#{POKY_EDISON_PATH}/sysroots/core2-32-poky-linux"
   POKY_EDISON_X86_PATH = "#{POKY_EDISON_PATH}/sysroots/i386-pokysdk-darwin"
   POKY_EDISON_BIN_PATH = "#{POKY_EDISON_X86_PATH}/usr/bin/i586-poky-linux"
 

build_config/IntelGalileo.rb

@@ -12,7 +12,7 @@ MRuby::CrossBuild.new("Galileo") do |conf|
   #ARDUINO_GALILEO_PATH = '/opt/arduino'
 
   GALILEO_BIN_PATH = "#{GALILEO_ARDUINO_PATH}/hardware/tools/x86/i386-pokysdk-darwin/usr/bin/i586-poky-linux-uclibc"
-  GALILEO_SYSROOT =  "#{GALILEO_ARDUINO_PATH}/hardware/tools/x86/i586-poky-linux-uclibc"
+  GALILEO_SYSROOT  = "#{GALILEO_ARDUINO_PATH}/hardware/tools/x86/i586-poky-linux-uclibc"
   GALILEO_X86_PATH = "#{GALILEO_ARDUINO_PATH}/hardware/arduino/x86"
 
 
@@ -56,7 +56,6 @@ MRuby::CrossBuild.new("Galileo") do |conf|
 
   #official mrbgems
   conf.gem :core => "mruby-sprintf"
-  conf.gem :core => "mruby-print"
   conf.gem :core => "mruby-math"
   conf.gem :core => "mruby-time"
   conf.gem :core => "mruby-struct"
@@ -74,7 +73,7 @@ MRuby::CrossBuild.new("Galileo") do |conf|
   conf.gem :core => "mruby-fiber"
   conf.gem :core => "mruby-toplevel-ext"
 
-  #lightweigh regular expression
+  #lightweight regular expression
   conf.gem :github => "masamitsu-murase/mruby-hs-regexp", :branch => "master"
 
   #Arduino API

build_config/RX630.rb

@@ -16,9 +16,9 @@ MRuby::CrossBuild.new("RX630") do |conf|
     #configuration for low memory environment
     cc.defines << %w(MRB_USE_FLOAT32)
     cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
-    cc.defines << %w(KHASH_DEFAULT_SIZE=8)
+    cc.defines << %w(KHASH_INITIAL_SIZE=8)
     cc.defines << %w(MRB_GC_STRESS)
-    cc.defines << %w(MRB_NO_STDIO) #if you dont need stdio.
+    cc.defines << %w(MRB_NO_STDIO) #if you don't need stdio.
     #cc.defines << %w(POOL_PAGE_SIZE=1000) #effective only for use with mruby-eval
   end
 
@@ -50,7 +50,6 @@ MRuby::CrossBuild.new("RX630") do |conf|
 
   #gems from core
   conf.gem :core => "mruby-sprintf"
-  conf.gem :core => "mruby-print"
   conf.gem :core => "mruby-math"
   conf.gem :core => "mruby-enum-ext"
   conf.gem :core => "mruby-numeric-ext"

build_config/android_arm64_v8a.rb

@@ -2,8 +2,8 @@
 MRuby::CrossBuild.new('android-arm64-v8a') do |conf|
   params = {
     :arch => 'arm64-v8a',
-    :platform => 'android-24',
-    :toolchain => :clang,
+    :sdk_version => 33,
+    :toolchain => :clang
   }
   toolchain :android, params
 

build_config/android_armeabi.rb

@@ -1,11 +0,0 @@
-# Requires Android NDK r13 or later.
-MRuby::CrossBuild.new('android-armeabi') do |conf|
-  params = {
-    :arch => 'armeabi',
-    :platform => 'android-24',
-    :toolchain => :clang,
-  }
-  toolchain :android, params
-
-  conf.gembox 'default'
-end

build_config/android_armeabi_v7a_neon_hard.rb

@@ -4,8 +4,8 @@ MRuby::CrossBuild.new('android-armeabi-v7a-neon-hard') do |conf|
     :arch => 'armeabi-v7a',
     :mfpu => 'neon',
     :mfloat_abi => 'hard',
-    :platform => 'android-24',
-    :toolchain => :clang,
+    :sdk_version => 33,
+    :toolchain => :clang
   }
   toolchain :android, params
 

build_config/boxing.rb

@@ -3,11 +3,9 @@ bits = [64, 32]
 ints = [64, 32]
 
 boxings.product(bits, ints) do |boxing, bit, int|
-  next if boxing == "nan" && int == 64
-
   MRuby::Build.new("boxing-#{boxing}-m#{bit}-i#{int}") do |conf|
     conf.toolchain :gcc
-    conf.gembox 'default'
+    conf.gembox 'full-core'
     conf.compilers.each do |c|
       c.defines << "MRB_#{boxing.upcase}_BOXING"
       c.defines << "MRB_INT#{int}"

build_config/chipKITMax32.rb

@@ -27,9 +27,9 @@ MRuby::CrossBuild.new("chipKITMax32") do |conf|
 
     #configuration for low memory environment
     cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
-    cc.defines << %w(KHASH_DEFAULT_SIZE=8)
+    cc.defines << %w(KHASH_INITIAL_SIZE=8)
     cc.defines << %w(MRB_GC_STRESS)
-    #cc.defines << %w(MRB_NO_STDIO) #if you dont need stdio.
+    #cc.defines << %w(MRB_NO_STDIO) #if you don't need stdio.
     #cc.defines << %w(POOL_PAGE_SIZE=1000) #effective only for use with mruby-eval
   end
 
@@ -56,7 +56,6 @@ MRuby::CrossBuild.new("chipKITMax32") do |conf|
   conf.disable_cxx_exception
 
   #gems from core
-  conf.gem :core => "mruby-print"
   conf.gem :core => "mruby-math"
   conf.gem :core => "mruby-enum-ext"
 

build_config/ci/gcc-clang.rb

@@ -28,7 +28,7 @@ MRuby::Build.new('cxx_abi') do |conf|
   conf.toolchain
 
   conf.gembox 'full-core'
-  conf.cc.flags += %w(-fpermissive)
+  conf.cc.flags += %w(-fpermissive -std=gnu++03)
   conf.compilers.each do |c|
     c.defines += %w(MRB_GC_FIXED_ARENA)
   end

build_config/clang-asan.rb

@@ -1,7 +1,7 @@
 MRuby::Build.new do |conf|
   conf.toolchain :clang
   # include the GEM box
-  conf.gembox 'default'
+  conf.gembox 'full-core'
 
   # Turn on `enable_debug` for better debugging
   conf.enable_sanitizer "address,undefined"

build_config/cosmopolitan.rb

@@ -0,0 +1,86 @@
+# Cosmopolitan Libc build configuration for mruby
+# https://github.com/jart/cosmopolitan
+#
+# Produces Actually Portable Executables (APE) - single binaries that run on:
+#   - Linux (x86_64, ARM64)
+#   - macOS (x86_64, ARM64)
+#   - Windows (x86_64)
+#   - FreeBSD (x86_64)
+#   - OpenBSD (x86_64)
+#   - NetBSD (x86_64)
+#
+# Requirements:
+#   Download cosmocc toolchain from https://cosmo.zip/pub/cosmocc/
+#
+# Usage:
+#   COSMO_ROOT=/path/to/cosmocc rake MRUBY_CONFIG=cosmopolitan
+#
+# The resulting binaries in bin/ will have .com extension and run on all
+# supported platforms without recompilation.
+
+COSMO_ROOT = ENV['COSMO_ROOT']
+
+unless COSMO_ROOT && File.directory?(COSMO_ROOT)
+  msg = <<~MSG
+    Cosmopolitan toolchain not found.
+
+    Please set COSMO_ROOT environment variable to the cosmocc directory:
+
+      mkdir -p ~/cosmo && cd ~/cosmo
+      wget https://cosmo.zip/pub/cosmocc/cosmocc.zip
+      unzip cosmocc.zip
+      export COSMO_ROOT=~/cosmo
+
+    Then run:
+      COSMO_ROOT=~/cosmo rake MRUBY_CONFIG=cosmopolitan
+  MSG
+  raise msg
+end
+
+MRuby::Build.new do |conf|
+  # C compiler
+  conf.cc do |cc|
+    cc.command = "#{COSMO_ROOT}/bin/cosmocc"
+    cc.flags = %w[-Os -fno-omit-frame-pointer]
+  end
+
+  # C++ compiler
+  conf.cxx do |cxx|
+    cxx.command = "#{COSMO_ROOT}/bin/cosmoc++"
+    cxx.flags = conf.cc.flags.dup
+  end
+
+  # Linker
+  conf.linker do |linker|
+    linker.command = "#{COSMO_ROOT}/bin/cosmocc"
+    linker.flags = %w[-static]
+  end
+
+  # Archiver
+  conf.archiver do |archiver|
+    archiver.command = "#{COSMO_ROOT}/bin/cosmoar"
+  end
+
+  # APE binaries use .com extension
+  conf.exts.executable = '.com'
+
+  # Cosmopolitan provides POSIX compatibility, explicitly select POSIX HALs
+  conf.gem core: 'hal-posix-io'
+  conf.gem core: 'hal-posix-socket'
+  conf.gem core: 'hal-posix-dir'
+
+  # Standard library
+  conf.gembox 'stdlib'
+  conf.gembox 'stdlib-ext'
+  conf.gembox 'stdlib-io'  # Includes mruby-io, mruby-socket, mruby-dir
+  conf.gembox 'math'
+  conf.gembox 'metaprog'
+
+  # Binary tools
+  # Note: mruby-bin-config is a shell script and incompatible with .com extension
+  conf.gem core: 'mruby-bin-mrbc'
+  conf.gem core: 'mruby-bin-mruby'
+  conf.gem core: 'mruby-bin-strip'
+  conf.gem core: 'mruby-bin-mirb'
+  conf.gem core: 'mruby-bin-debugger'
+end

build_config/cross-mingw-winetest.rb

@@ -0,0 +1,90 @@
+# Cross-compile using MinGW and test using Wine.
+#
+# Steps:
+#
+#   1. Install MinGW; 64-bit target seems to work best.
+#
+#   2. Install Wine.
+#
+#   3. Run command:
+#
+#           wine cmd /c echo "Hello world"'
+#
+#      This will confirm that Wine works and will trigger standard
+#      Wine setup, which is slow.
+#
+#   4. Confirm that drive 'z:' is mapped to your root filesystem.
+#      (This is supposed to be a default but it helps to
+#      double-check.) To confirm, run:
+#
+#           wine cmd /c dir 'z:\\'
+#
+#      This should give you a DOS-style equivalent of 'ls /'. If not,
+#      you'll need to fix that with winecfg or by adding a symlink to
+#      '~/.wine/dosdevices'.
+#
+#   5. You will likely need to tweak the settings below to work with
+#      your configuration unless it is exactly like one of the platforms
+#      I've tested on (Ubuntu 20.04 or macOS using brew.)
+#
+#   6. Run the build command:
+#
+#           MRUBY_CONFIG=build_config/cross-mingw-winetest.rb rake test
+#
+#      If all goes well, you should now have Windows executables and a
+#      set of passing tests.
+#
+#
+#  Caveats:
+#
+#    1. This works by using a helper script that rewrites test output
+#       to make it look *nix-like and then handing it back to the test
+#       cases. Some of the existing tests were (slightly) modified to
+#       make this easier but only for the 'full-core' gembox. Other
+#       gems' bintests may or may not work with the helper script and
+#       may or may not be fixable by extending the script.
+#
+#   2.  MinGW and Wine are both complex and not very consistent so you
+#       will likely need to do some fiddling to get things to work.
+#
+#   3.  This script assumes you are running it on a *nix-style OS.
+#
+#   4.  I recommend building 64-bit targets only. Building a 32-bit
+#       Windows binary with i686-w64-mingw32 seems to work (at least,
+#       it did for me) but the resulting executable failed a number of
+#       unit tests due to small errors in some floating-point
+#       operations. It's unclear if this indicates more serious problems.
+#
+
+
+MRuby::CrossBuild.new("cross-mingw-winetest") do |conf|
+  conf.toolchain :gcc
+
+  conf.host_target = "x86_64-w64-mingw32"
+
+  # Ubuntu 20
+  conf.cc.command = "#{conf.host_target}-gcc-posix"
+
+  # macOS+Wine from brew
+  #conf.cc.command = "#{conf.host_target}-gcc"
+
+  conf.linker.command = conf.cc.command
+  conf.archiver.command = "#{conf.host_target}-gcc-ar"
+  conf.exts.executable = ".exe"
+
+  # By default, we compile as static as possible to remove runtime
+  # MinGW dependencies; they are probably fixable but it gets
+  # complicated.
+  conf.cc.flags = ['-static']
+  conf.linker.flags += ['-static']
+
+  conf.test_runner do |t|
+    thisdir = File.absolute_path( File.dirname(__FILE__) )
+    t.command = File.join(thisdir, * %w{ helpers wine_runner.rb})
+  end
+
+  conf.gembox "full-core"
+
+  conf.enable_bintest
+  conf.enable_test
+end

build_config/cross-mingw.rb

@@ -0,0 +1,14 @@
+#
+# Ubuntu 20.04 requires at least `gcc-mingw-w64-x86-64` package as a
+# cross compiler.
+#
+
+MRuby::CrossBuild.new("cross-mingw") do |conf|
+  conf.toolchain :gcc
+  conf.host_target = "x86_64-w64-mingw32"  # required for `for_windows?` used by `mruby-socket` gem
+  conf.cc.command = "#{conf.host_target}-gcc-posix"
+  conf.linker.command = conf.cc.command
+  conf.archiver.command = "#{conf.host_target}-gcc-ar"
+  conf.exts.executable = ".exe"
+  conf.gembox "default"
+end

build_config/default.rb

@@ -42,7 +42,7 @@ MRuby::Build.new do |conf|
   #   linker.library_paths = []
   #   linker.option_library = '-l%s'
   #   linker.option_library_path = '-L%s'
-  #   linker.link_options = "%{flags} -o "%{outfile}" %{objs} %{libs}"
+  #   linker.link_options = %Q[%{flags} -o "%{outfile}" %{objs} %{libs}]
   # end
 
   # Archiver settings
@@ -60,7 +60,7 @@ MRuby::Build.new do |conf|
   # gperf settings
   # conf.gperf do |gperf|
   #   gperf.command = 'gperf'
-  #   gperf.compile_options = %q[-L ANSI-C -C -p -j1 -i 1 -g -o -t -N mrb_reserved_word -k"1,3,$" "%{infile}" > "%{outfile}"]
+  #   gperf.compile_options = %q[-L ANSI-C -C -j1 -i 1 -o -t -N mrb_reserved_word -k"1,3,$" "%{infile}" > "%{outfile}"]
   # end
 
   # file extensions
@@ -73,6 +73,9 @@ MRuby::Build.new do |conf|
   # file separator
   # conf.file_separator = '/'
 
+  # change library directory name from the default "lib" if necessary
+  # conf.libdir_name = 'lib64'
+
   # Turn on `enable_debug` for better debugging
   # conf.enable_debug
   conf.enable_bintest

build_config/dreamcast_shelf.rb

@@ -1,94 +1,81 @@
 # Cross Compiling configuration for the Sega Dreamcast
-# This configuration requires KallistiOS (KOS)
-# https://dreamcast.wiki
+# https://dreamcast.wiki/Using_Ruby_for_Sega_Dreamcast_development
 #
-# Tested on GNU/Linux, MinGW-w64/MSYS2, Cygwin, macOS and MinGW/MSYS (see below)
+# Requires KallistiOS (KOS)
+# http://gamedev.allusion.net/softprj/kos/
+#
+# This configuration has been improved to be used as KallistiOS Port (kos-ports)
+# Updated: 2025-07-31
+#
+# Tested on GNU/Linux, macOS and Windows (MinGW-w64/MSYS2, Cygwin, DreamSDK)
+# DreamSDK is based on both MinGW/MSYS and MinGW-w64/MSYS2: https://dreamsdk.org/
+#
+# Install mruby for Sega Dreamcast using the "mruby" kos-port.
+# See: https://github.com/kallistios/kallistios
+#
+# If you want to see examples, check the /examples/dreamcast/mruby directory
+# in the KallistiOS repository.
 #
 MRuby::CrossBuild.new("dreamcast") do |conf|
   toolchain :gcc
 
-  # Support for DreamSDK (based on MinGW/MSYS)
-  # To compile mruby with DreamSDK, RubyInstaller for Windows should be installed
-  DREAMSDK_HOME = ENV["DREAMSDK_HOME"]
-  MSYS_ROOT = !(DREAMSDK_HOME.nil? || DREAMSDK_HOME.empty?) ? "#{DREAMSDK_HOME}/msys/1.0" : ""
+  # Getting critical environment variables
+  KOS_BASE = ENV["KOS_BASE"]
+  KOS_CC_BASE = ENV["KOS_CC_BASE"]
 
-  # Setting paths
-  DREAMCAST_PATH = "#{MSYS_ROOT}/opt/toolchains/dc"
-  KOS_PATH = "#{DREAMCAST_PATH}/kos"
-  BIN_PATH = "#{DREAMCAST_PATH}/sh-elf/bin"
+  # Check environment variables
+  if KOS_BASE.to_s.empty?
+    raise "Error: KallistiOS is required; KOS_BASE need to be declared; Stop."
+  end
+
+  # Root directory for KallistiOS wrappers
+  # This will handle specific DreamSDK wrappers if needed
+  KOS_WRAPPERS_BASE = if ENV["ENVIRONMENT_NAME"] == "DreamSDK" && ENV["RAKE_AVAILABLE"] == "0"
+                      "#{KOS_CC_BASE}/bin"
+                    else
+                      "#{KOS_BASE}/utils/build_wrappers"
+                    end
 
   # C compiler
-  # Flags were extracted from KallistiOS environment files
   conf.cc do |cc|
-    cc.command = "#{BIN_PATH}/sh-elf-gcc"	
-    cc.include_paths << ["#{KOS_PATH}/include", "#{KOS_PATH}/kernel/arch/dreamcast/include", "#{KOS_PATH}/addons/include", "#{KOS_PATH}/../kos-ports/include"]
-    cc.flags << ["-O2", "-fomit-frame-pointer", "-ml", "-m4-single-only", "-ffunction-sections", "-fdata-sections", "-Wall", "-g", "-fno-builtin", "-ml", "-m4-single-only", "-Wl,-Ttext=0x8c010000", "-Wl,--gc-sections", "-T#{KOS_PATH}/utils/ldscripts/shlelf.xc", "-nodefaultlibs"]
-    cc.compile_options = %Q[%{flags} -o "%{outfile}" -c "%{infile}"]
-    cc.defines << %w(_arch_dreamcast)
-    cc.defines << %w(_arch_sub_pristine)
+    cc.command = "#{KOS_WRAPPERS_BASE}/kos-cc"
   end
 
   # C++ compiler
   conf.cxx do |cxx|
-    cxx.command = conf.cc.command.dup
-    cxx.include_paths = conf.cc.include_paths.dup
-    cxx.flags = conf.cc.flags.dup
-    cxx.flags << %w(-fno-rtti -fno-exceptions)
-    cxx.defines = conf.cc.defines.dup
-    cxx.compile_options = conf.cc.compile_options.dup
+    cxx.command = "#{KOS_WRAPPERS_BASE}/kos-c++"
   end
 
   # Linker
-  # There is an issue when making the mruby library with KallistiOS:
-  # 'newlib_kill.o' and 'newlib_getpid.o' aren't found so they are explicitly
-  # specified here at least for now.
   conf.linker do |linker|
-    linker.command="#{BIN_PATH}/sh-elf-gcc"
-    linker.flags << ["#{MSYS_ROOT}/opt/toolchains/dc/kos/kernel/build/newlib_kill.o", "#{MSYS_ROOT}/opt/toolchains/dc/kos/kernel/build/newlib_getpid.o", "-Wl,--start-group -lkallisti -lc -lgcc -Wl,--end-group"]
-    linker.library_paths << ["#{KOS_PATH}/lib/dreamcast", "#{KOS_PATH}/addons/lib/dreamcast", "#{KOS_PATH}/../kos-ports/lib"]
+    linker.command = "#{KOS_WRAPPERS_BASE}/kos-ld"
   end
 
   # Archiver
   conf.archiver do |archiver|
-    archiver.command = "#{BIN_PATH}/sh-elf-ar"
-    archiver.archive_options = 'rcs "%{outfile}" %{objs}'
+    archiver.command = "#{KOS_WRAPPERS_BASE}/kos-ar"
   end
 
-  # No executables
+  # No executables needed for KallistiOS
   conf.bins = []
 
-  # Do not build executable test
+  # Do not build test binaries
   conf.build_mrbtest_lib_only
 
-  # Disable C++ exception
-  conf.disable_cxx_exception
+  # Gemboxes
+  conf.gembox "default-no-stdio"
+  conf.gembox "stdlib-ext"
+  conf.gembox "metaprog"
 
-  # Gems from core
-  # removing mruby-io
-  conf.gem :core => "mruby-metaprog"
-  conf.gem :core => "mruby-pack"
-  conf.gem :core => "mruby-sprintf"
-  conf.gem :core => "mruby-print"
-  conf.gem :core => "mruby-math"
-  conf.gem :core => "mruby-time"
-  conf.gem :core => "mruby-struct"
-  conf.gem :core => "mruby-compar-ext"
-  conf.gem :core => "mruby-enum-ext"
-  conf.gem :core => "mruby-string-ext"
-  conf.gem :core => "mruby-numeric-ext"
-  conf.gem :core => "mruby-array-ext"
-  conf.gem :core => "mruby-hash-ext"
-  conf.gem :core => "mruby-range-ext"
-  conf.gem :core => "mruby-proc-ext"
-  conf.gem :core => "mruby-symbol-ext"
-  conf.gem :core => "mruby-random"
-  conf.gem :core => "mruby-object-ext"
-  conf.gem :core => "mruby-objectspace"
-  conf.gem :core => "mruby-fiber"
-  conf.gem :core => "mruby-enumerator"
-  conf.gem :core => "mruby-enum-lazy"
-  conf.gem :core => "mruby-toplevel-ext"
-  conf.gem :core => "mruby-kernel-ext"
-  conf.gem :core => "mruby-class-ext"
-  conf.gem :core => "mruby-compiler"
+  # Additional Gems
+  # Currently unsupported on KallistiOS: "mruby-io", "mruby-dir", "mruby-socket"
+  conf.gem :core => "mruby-binding"
+  conf.gem :core => "mruby-catch"
+  conf.gem :core => "mruby-enum-chain"
+  conf.gem :core => "mruby-errno"
+  conf.gem :core => "mruby-error"
+  conf.gem :core => "mruby-exit"
+  conf.gem :core => "mruby-os-memsize"
+  conf.gem :core => "mruby-proc-binding"
+  conf.gem :core => "mruby-sleep"
 end

build_config/emscripten-cxx.rb

@@ -0,0 +1,12 @@
+# Make sure to add these compile options:
+#   build/emscripten-cxx/host-bin/mruby-config --cxxflags
+#
+# Make sure to add these link options:
+#   build/emscripten-cxx/host-bin/mruby-config --ldflags --libs
+MRuby::CrossBuild.new('emscripten-cxx') do |conf|
+  conf.toolchain :emscripten
+
+  conf.gembox 'default'
+
+  conf.enable_cxx_abi
+end

build_config/emscripten.rb

@@ -0,0 +1,10 @@
+# Make sure to add these compile options:
+#   build/emscripten/host-bin/mruby-config --cflags
+#
+# Make sure to add these link options:
+#   build/emscripten/host-bin/mruby-config --ldflags --libs
+MRuby::CrossBuild.new('emscripten') do |conf|
+  conf.toolchain :emscripten
+
+  conf.gembox 'default'
+end

build_config/gameboyadvance.rb

@@ -47,7 +47,6 @@ MRuby::CrossBuild.new("gameboyadvance") do |conf|
   conf.gem core: "mruby-metaprog"
   conf.gem core: "mruby-pack"
   conf.gem core: "mruby-sprintf"
-  conf.gem core: "mruby-print"
   conf.gem core: "mruby-math"
   conf.gem core: "mruby-time"
   conf.gem core: "mruby-struct"

build_config/helpers/wine_runner.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+# Wrapper for running tests for cross-compiled Windows builds in Wine.
+
+require 'open3'
+
+DOSROOT = 'z:'
+
+# Rewrite test output to replace DOS-isms with Unix-isms.
+def clean(output, stderr = false)
+  ends_with_newline = !!(output =~ /\n$/)
+  executable = ARGV[0].gsub(/\.exe\z/i, '')
+
+  # Fix line-ends
+  output = output.gsub(/\r\n/, "\n")
+
+  # Strip out Wine messages
+
+
+  results = output.split(/\n/).map do |line|
+    # Fix file paths
+    if line =~ /#{DOSROOT}\\/i
+      line.gsub!(/#{DOSROOT}([^:]*)/i) { |path|
+        path.gsub!(/^#{DOSROOT}/i, '')
+        path.gsub!(%r{\\}, '/')
+        path
+      }
+    end
+
+    # strip '.exe' off the end of the executable's name if needed
+    line.gsub!(/(#{Regexp.escape executable})\.exe/i, '\1')
+
+    line
+  end
+
+  result_text = results.join("\n")
+  result_text += "\n" if ends_with_newline
+  result_text
+end
+
+
+def main
+  if ARGV.empty? || ARGV[0] =~ /^- (-?) (\?|help|h) $/x
+    puts "#{$0} <command-line>"
+    exit 0
+  end
+
+  # For simplicity, just read all of stdin into memory and pass that
+  # as an argument when invoking wine. (Skipped if STDIN was not
+  # redirected.)
+  if !STDIN.tty?
+    input = STDIN.read
+  else
+    input = ""
+  end
+
+  # Disable all Wine messages so they don't interfere with the output
+  ENV['WINEDEBUG'] = 'err-all,warn-all,fixme-all,trace-all'
+
+  # Run the program in wine and capture the output
+  output, errormsg, status = Open3.capture3('wine', *ARGV, :stdin_data => input)
+
+  # Clean and print the results.
+  STDOUT.write clean(output)
+  STDERR.write clean(errormsg)
+
+  exit(status.exitstatus)
+end
+
+
+main()

build_config/host-f32.rb

@@ -0,0 +1,14 @@
+MRuby::Build.new do |conf|
+  # load specific toolchain settings
+  toolchain :gcc
+
+  # include the GEM box
+  conf.gembox 'full-core'
+
+  conf.cc.defines << 'MRB_USE_FLOAT32'
+
+  # Turn on `enable_debug` for better debugging
+  conf.enable_debug
+  conf.enable_test
+  conf.enable_bintest
+end

build_config/host-gprof.rb

@@ -3,7 +3,7 @@ MRuby::Build.new do |conf|
   toolchain :gcc
 
   # include the GEM box
-  conf.gembox 'default'
+  conf.gembox 'full-core'
 
   conf.cc.flags << '-pg'
   conf.linker.flags << '-pg'

build_config/host-m32-f32.rb

@@ -0,0 +1,16 @@
+MRuby::Build.new do |conf|
+  # load specific toolchain settings
+  toolchain :gcc
+
+  # include the GEM box
+  conf.gembox 'full-core'
+
+  conf.cc.flags << '-m32'
+  conf.cc.defines << 'MRB_USE_FLOAT32'
+  conf.linker.flags << '-m32'
+
+  # Turn on `enable_debug` for better debugging
+  conf.enable_debug
+  conf.enable_test
+  conf.enable_bintest
+end

build_config/host-m32.rb

@@ -3,7 +3,7 @@ MRuby::Build.new do |conf|
   toolchain :gcc
 
   # include the GEM box
-  conf.gembox 'default'
+  conf.gembox 'full-core'
 
   conf.cc.flags << '-m32'
   conf.linker.flags << '-m32'

build_config/host-nofloat.rb

@@ -0,0 +1,22 @@
+MRuby::Build.new do |conf|
+  # load specific toolchain settings
+  toolchain :gcc
+
+  # include the GEM box
+  conf.gembox "stdlib"
+  conf.gembox "stdlib-ext"
+  conf.gembox "stdlib-io"
+  conf.gembox "metaprog"
+
+  conf.gem :core => 'mruby-bin-mruby'
+  conf.gem :core => 'mruby-bin-mirb'
+
+  # Add configuration
+  conf.compilers.each do |c|
+    c.defines << "MRB_NO_FLOAT"
+  end
+
+  conf.enable_debug
+  conf.enable_test
+  conf.enable_bintest
+end

build_config/host-shared.rb

@@ -1,34 +1,34 @@
+# NOTE: Currently, this configuration file does not support VisualC++!
+#       Your help is needed!
+
 MRuby::Build.new do |conf|
   # load specific toolchain settings
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
+  conf.toolchain
 
   # include the GEM box
   conf.gembox 'default'
 
   # C compiler settings
-  conf.cc do |cc|
-    cc.flags = '-fPIC'
+  conf.compilers.each do |cc|
+    cc.flags << '-fPIC'
   end
 
   conf.archiver do |archiver|
-    archiver.command = 'gcc'
+    archiver.command = cc.command
     archiver.archive_options = '-shared -o %{outfile} %{objs}'
   end
 
   # file extensions
   conf.exts do |exts|
-     exts.library = '.so'
+    exts.library = '.so'
   end
 
   # file separator
   # conf.file_separator = '/'
 
+  # enable this if better compatibility with C++ is desired
+  #conf.enable_cxx_exception
+
   # Turn on `enable_debug` for better debugging
   conf.enable_debug
   conf.enable_bintest

build_config/i586-pc-msdosdjgpp.rb

@@ -0,0 +1,76 @@
+# Cross Compiling configuration for MS-DOS
+#
+# Requires DJGPP cross-compiler, see
+# https://github.com/andrewwutw/build-djgpp/releases
+
+MRuby::CrossBuild.new("i586-pc-msdosdjgpp") do |conf|
+  toolchain :gcc
+
+  # If DJGPP is not in the PATH, set this to the bin directory
+  DJGPP_PATH = nil
+
+  GCC = 'i586-pc-msdosdjgpp-gcc'
+  GXX = 'i586-pc-msdosdjgpp-g++'
+  AR  = 'i586-pc-msdosdjgpp-ar'
+
+  conf.cc do |cc|
+    cc.command = DJGPP_PATH ? File.join(DJGPP_PATH, GCC) : GCC
+    cc.defines << 'MRB_NO_IO_PREAD_PWRITE'
+    cc.defines << 'MRB_UTF8_STRING'
+  end
+
+  conf.cxx do |cxx|
+    cxx.command = DJGPP_PATH ? File.join(DJGPP_PATH, GXX) : GXX
+    cxx.defines << 'MRB_NO_IO_PREAD_PWRITE'
+    cxx.defines << 'MRB_UTF8_STRING'
+  end
+
+  conf.linker do |linker|
+    linker.command = DJGPP_PATH ? File.join(DJGPP_PATH, GXX) : GXX
+    linker.libraries = %w(m)
+  end
+
+  conf.archiver do |archiver|
+    archiver.command = DJGPP_PATH ? File.join(DJGPP_PATH, AR) : AR
+  end
+
+  # All provided gems that can be reasonably made to compile:
+  # default.gembox, minus mruby-socket and replacing mruby-cmath with mruby-cmath-alt
+  conf.gembox "stdlib"
+  conf.gembox "stdlib-ext"
+
+  conf.gem :core => 'mruby-io'              # stdlib-io.gembox <- default.gembox
+# No socket support in DJGPP
+# conf.gem :core => 'mruby-socket'          # stdlib-io.gembox <- default.gembox
+  conf.gem :core => 'mruby-errno'           # stdlib-io.gembox <- default.gembox
+  conf.gem :core => 'mruby-dir'             # stdlib-io.gembox <- default.gembox
+
+  conf.gem :core => 'mruby-bigint'          # math.gembox <- default.gembox
+  conf.gem :core => 'mruby-complex'         # math.gembox <- default.gembox
+  conf.gem :core => 'mruby-math'            # math.gembox <- default.gembox
+  conf.gem :core => 'mruby-rational'        # math.gembox <- default.gembox
+  # Alternative implementation of cmath, not requiring <complex.h>
+# conf.gem :github => 'chasonr/mruby-cmath-alt' # math.gembox <- default.gembox
+
+  conf.gembox "metaprog"
+
+  conf.gem :core => 'mruby-bin-mrbc'        # default.gembox
+  conf.gem :core => 'mruby-bin-debugger'    # default.gembox
+  conf.gem :core => 'mruby-bin-mirb'        # default.gembox
+  conf.gem :core => 'mruby-bin-mruby'       # default.gembox
+  conf.gem :core => 'mruby-bin-strip'       # default.gembox
+  conf.gem :core => 'mruby-bin-config'      # default.gembox
+
+  # Other compilable gems
+  conf.gem :core => 'mruby-binding'
+  conf.gem :core => 'mruby-catch'
+  conf.gem :core => 'mruby-enum-chain'
+  conf.gem :core => 'mruby-error'
+  conf.gem :core => 'mruby-exit'
+  conf.gem :core => 'mruby-os-memsize'
+  conf.gem :core => 'mruby-proc-binding'
+  conf.gem :core => 'mruby-sleep'
+
+  # For Onigmo regular expression support
+  conf.gem :github => 'mattn/mruby-onig-regexp'
+end

build_config/luckfox_pico.rb

@@ -0,0 +1,106 @@
+# Cross Compiling configuration for Luckfox Pico embedded SBC.
+#
+# To build on Ubuntu x86_64: rake MRUBY_CONFIG=build_config/luckfox_pico.rb
+# Uses Buildroot SDK for this board. Binaries run on the corresponding Linux image.
+# Requires: https://github.com/LuckfoxTECH/luckfox-pico
+#
+# NOTE: default config includes all standard mrbgems, EXCEPT: mruby-cmath
+#
+MRuby::CrossBuild.new("luckfox_pico") do |conf|
+  # Clone the luckfox-pico repo above next to (same directory level) as mruby.
+  SDK_BASE = File.realpath(File.expand_path("../../../", File.expand_path(__FILE__)) + "/luckfox-pico")
+  TOOLCHAIN_BASE = "#{SDK_BASE}/tools/linux/toolchain/arm-rockchip830-linux-uclibcgnueabihf"
+  SYSROOT = "#{TOOLCHAIN_BASE}/arm-rockchip830-linux-uclibcgnueabihf/sysroot"
+
+  toolchain :gcc
+
+  # C compiler settings
+  conf.cc do |cc|
+    cc.command = "#{TOOLCHAIN_BASE}/bin/arm-rockchip830-linux-uclibcgnueabihf-gcc"
+
+    cc.include_paths << "#{TOOLCHAIN_BASE}/lib/gcc/arm-rockchip830-linux-uclibcgnueabihf/8.3.0/include"
+    cc.include_paths << "#{TOOLCHAIN_BASE}/lib/gcc/arm-rockchip830-linux-uclibcgnueabihf/8.3.0/include-fixed"
+    cc.include_paths << "#{TOOLCHAIN_BASE}/arm-rockchip830-linux-uclibcgnueabihf/include/c++/8.3.0/arm-rockchip830-linux-uclibcgnueabihf"
+    cc.include_paths << "#{SYSROOT}/usr/include"
+
+    # Flags taken from the SDK's Makefile
+    cc.flags << ["-march=armv7-a", "-mfpu=neon", "-mfloat-abi=hard"]
+    cc.flags << ["-D_LARGEFILE_SOURCE", "-D_LARGEFILE64_SOURCE", "-D_FILE_OFFSET_BITS=64", "-ffunction-sections", "-fdata-sections"]
+    cc.flags << ["-O2", "-fPIC"]
+    cc.flags << ["-Wl,--copy-dt-needed-entries", "-Wl,-lc,-lgcc_s"]
+  end
+
+  # Linker settings
+  conf.linker do |linker|
+    linker.command = cc.command
+    linker.library_paths << "#{TOOLCHAIN_BASE}/arm-rockchip830-linux-uclibcgnueabihf/lib"
+    linker.flags = cc.flags
+  end
+
+  # Archiver settings
+  conf.archiver do |archiver|
+    archiver.command = "#{TOOLCHAIN_BASE}/bin/arm-rockchip830-linux-uclibcgnueabihf-ar"
+  end
+
+  # Do not build executable test
+  conf.build_mrbtest_lib_only
+
+  # Disable C++ exception
+  conf.disable_cxx_exception
+
+  # All standard gems.
+  conf.gem 'mrbgems/mruby-array-ext/'
+  conf.gem 'mrbgems/mruby-bigint/'
+  conf.gem 'mrbgems/mruby-bin-config/'
+  conf.gem 'mrbgems/mruby-bin-debugger/'
+  conf.gem 'mrbgems/mruby-bin-mirb/'
+  conf.gem 'mrbgems/mruby-bin-mrbc/'
+  conf.gem 'mrbgems/mruby-bin-mruby/'
+  conf.gem 'mrbgems/mruby-bin-strip/'
+  conf.gem 'mrbgems/mruby-binding/'
+  conf.gem 'mrbgems/mruby-catch/'
+  conf.gem 'mrbgems/mruby-class-ext/'
+  # SDK doesn't include complex math for uClibc
+  # conf.gem 'mrbgems/mruby-cmath/'
+  conf.gem 'mrbgems/mruby-compar-ext/'
+  conf.gem 'mrbgems/mruby-compiler/'
+  conf.gem 'mrbgems/mruby-complex/'
+  conf.gem 'mrbgems/mruby-data/'
+  conf.gem 'mrbgems/mruby-dir/'
+  conf.gem 'mrbgems/mruby-enum-chain/'
+  conf.gem 'mrbgems/mruby-enum-ext/'
+  conf.gem 'mrbgems/mruby-enum-lazy/'
+  conf.gem 'mrbgems/mruby-enumerator/'
+  conf.gem 'mrbgems/mruby-errno/'
+  conf.gem 'mrbgems/mruby-error/'
+  conf.gem 'mrbgems/mruby-eval/'
+  conf.gem 'mrbgems/mruby-exit/'
+  conf.gem 'mrbgems/mruby-fiber/'
+  conf.gem 'mrbgems/mruby-hash-ext/'
+  conf.gem 'mrbgems/mruby-io/'
+  conf.gem 'mrbgems/mruby-kernel-ext/'
+  conf.gem 'mrbgems/mruby-math/'
+  conf.gem 'mrbgems/mruby-metaprog/'
+  conf.gem 'mrbgems/mruby-method/'
+  conf.gem 'mrbgems/mruby-numeric-ext/'
+  conf.gem 'mrbgems/mruby-object-ext/'
+  conf.gem 'mrbgems/mruby-objectspace/'
+  conf.gem 'mrbgems/mruby-os-memsize/'
+  conf.gem 'mrbgems/mruby-pack/'
+  conf.gem 'mrbgems/mruby-proc-binding/'
+  conf.gem 'mrbgems/mruby-proc-ext/'
+  conf.gem 'mrbgems/mruby-random/'
+  conf.gem 'mrbgems/mruby-range-ext/'
+  conf.gem 'mrbgems/mruby-rational/'
+  conf.gem 'mrbgems/mruby-set/'
+  conf.gem 'mrbgems/mruby-sleep/'
+  conf.gem 'mrbgems/mruby-socket/'
+  conf.gem 'mrbgems/mruby-sprintf/'
+  conf.gem 'mrbgems/mruby-string-ext/'
+  conf.gem 'mrbgems/mruby-struct/'
+  conf.gem 'mrbgems/mruby-symbol-ext/'
+  # conf.gem 'mrbgems/mruby-test-inline-struct/'
+  # conf.gem 'mrbgems/mruby-test/'
+  conf.gem 'mrbgems/mruby-time/'
+  conf.gem 'mrbgems/mruby-toplevel-ext/'
+end

build_config/milkv_duo.rb

@@ -0,0 +1,106 @@
+# Cross Compiling configuration for Milk-V Duo.
+# To build (on Ubuntu 24.04): rake MRUBY_CONFIG=build_config/milkv_duo.rb
+#
+# Requires: https://github.com/milkv-duo/duo-sdk
+#
+MRuby::CrossBuild.new("milkv_duo") do |conf|
+  # Set this string to match your board: milkv_duo, milkv_duo256m, milkv_duos
+  MILKV_DUO_VARIANT = "milkv_duo256m"
+
+  # Expect duo-sdk directory is same level as (next to) mruby top-level directory.
+  SDK_BASE = File.expand_path("../../../", File.expand_path(__FILE__)) + "/duo-sdk"
+  TOOLCHAIN_BASE = "#{SDK_BASE}/riscv64-linux-musl-x86_64"
+  SYSROOT = "#{SDK_BASE}/rootfs"
+
+  toolchain :gcc
+
+  # C compiler settings
+  conf.cc do |cc|
+    cc.command = "#{TOOLCHAIN_BASE}/bin/riscv64-unknown-linux-musl-gcc"
+    cc.include_paths << "#{TOOLCHAIN_BASE}/lib/gcc/riscv64-unknown-linux/musl/10.2.0/include-fixed"
+    cc.include_paths << "#{TOOLCHAIN_BASE}/lib/gcc/riscv64-unknown-linux/musl/10.2.0/include"
+    cc.include_paths << "#{TOOLCHAIN_BASE}/riscv64-unknown-linux/include"
+    cc.include_paths << "#{TOOLCHAIN_BASE}/include"
+    cc.include_paths << "#{SYSROOT}/usr/include"
+    cc.flags << ["-mcpu=c906fdv", "-march=rv64imafdcv0p7xthead", "-mcmodel=medany", "-mabi=lp64d"]
+    cc.flags << ["-D_LARGEFILE_SOURCE", "-D_LARGEFILE64_SOURCE", "-D_FILE_OFFSET_BITS=64"]
+    cc.flags << ["-Wl,--copy-dt-needed-entries", "-Wl,-lc,-lgcc_s,-lwiringx"]
+    cc.defines << "MILKV_DUO_VARIANT=_#{MILKV_DUO_VARIANT}"
+  end
+
+  # Linker settings
+  conf.linker do |linker|
+    linker.command = cc.command
+    linker.library_paths << ["#{SYSROOT}/lib", "#{SYSROOT}/usr/lib"]
+    linker.flags = cc.flags
+  end
+
+  # Archiver settings
+  conf.archiver do |archiver|
+    archiver.command = "#{TOOLCHAIN_BASE}/bin/riscv64-unknown-linux-musl-gcc-ar"
+  end
+
+  # Do not build executable test
+  conf.build_mrbtest_lib_only
+
+  # Disable C++ exception
+  conf.disable_cxx_exception
+
+  # All standard gems.
+  conf.gem 'mrbgems/mruby-array-ext/'
+  conf.gem 'mrbgems/mruby-bigint/'
+  conf.gem 'mrbgems/mruby-bin-config/'
+  conf.gem 'mrbgems/mruby-bin-debugger/'
+  conf.gem 'mrbgems/mruby-bin-mirb/'
+  conf.gem 'mrbgems/mruby-bin-mrbc/'
+  conf.gem 'mrbgems/mruby-bin-mruby/'
+  conf.gem 'mrbgems/mruby-bin-strip/'
+  conf.gem 'mrbgems/mruby-binding/'
+  conf.gem 'mrbgems/mruby-catch/'
+  conf.gem 'mrbgems/mruby-class-ext/'
+  conf.gem 'mrbgems/mruby-cmath/'
+  conf.gem 'mrbgems/mruby-compar-ext/'
+  conf.gem 'mrbgems/mruby-compiler/'
+  conf.gem 'mrbgems/mruby-complex/'
+  conf.gem 'mrbgems/mruby-data/'
+  conf.gem 'mrbgems/mruby-dir/'
+  conf.gem 'mrbgems/mruby-enum-chain/'
+  conf.gem 'mrbgems/mruby-enum-ext/'
+  conf.gem 'mrbgems/mruby-enum-lazy/'
+  conf.gem 'mrbgems/mruby-enumerator/'
+  conf.gem 'mrbgems/mruby-errno/'
+  conf.gem 'mrbgems/mruby-error/'
+  conf.gem 'mrbgems/mruby-eval/'
+  conf.gem 'mrbgems/mruby-exit/'
+  conf.gem 'mrbgems/mruby-fiber/'
+  conf.gem 'mrbgems/mruby-hash-ext/'
+  conf.gem 'mrbgems/mruby-io/'
+  conf.gem 'mrbgems/mruby-kernel-ext/'
+  conf.gem 'mrbgems/mruby-math/'
+  conf.gem 'mrbgems/mruby-metaprog/'
+  conf.gem 'mrbgems/mruby-method/'
+  conf.gem 'mrbgems/mruby-numeric-ext/'
+  conf.gem 'mrbgems/mruby-object-ext/'
+  conf.gem 'mrbgems/mruby-objectspace/'
+  conf.gem 'mrbgems/mruby-os-memsize/'
+  conf.gem 'mrbgems/mruby-pack/'
+  conf.gem 'mrbgems/mruby-proc-binding/'
+  conf.gem 'mrbgems/mruby-proc-ext/'
+  conf.gem 'mrbgems/mruby-random/'
+  conf.gem 'mrbgems/mruby-range-ext/'
+  conf.gem 'mrbgems/mruby-rational/'
+  conf.gem 'mrbgems/mruby-set/'
+  conf.gem 'mrbgems/mruby-sleep/'
+  conf.gem 'mrbgems/mruby-socket/'
+  conf.gem 'mrbgems/mruby-sprintf/'
+  conf.gem 'mrbgems/mruby-string-ext/'
+  conf.gem 'mrbgems/mruby-struct/'
+  conf.gem 'mrbgems/mruby-symbol-ext/'
+  # conf.gem 'mrbgems/mruby-test-inline-struct/'
+  # conf.gem 'mrbgems/mruby-test/'
+  conf.gem 'mrbgems/mruby-time/'
+  conf.gem 'mrbgems/mruby-toplevel-ext/'
+
+  # GPIO, ADC, PWM, I2C and SPI support for Milk-V Duo
+  # conf.gem :github => 'denko-rb/mruby-milkv-duo'
+end

build_config/minimal.rb

@@ -0,0 +1,4 @@
+MRuby::CrossBuild.new('minimal') do |conf|
+  conf.toolchain :gcc
+  conf.cc.defines << 'MRB_NO_STDIO'
+end

build_config/mrbc.rb

@@ -7,5 +7,4 @@ MRuby::Build.new do |conf|
 
   conf.build_mrbc_exec
   conf.disable_libmruby
-  conf.disable_presym
 end

build_config/nintendo_switch.rb

@@ -0,0 +1,73 @@
+# Cross Compiling configuration for the Nintendo Switch, it requires Nintendo SDK
+# Tested on windows
+MRuby::CrossBuild.new('nintendo_switch_32bit') do |conf|
+  conf.toolchain :clang
+  NINTENDO_SDK_PATH = ENV['NINTENDO_SDK_ROOT']
+
+  include_paths = [
+    "#{NINTENDO_SDK_PATH}/Include",
+    "#{NINTENDO_SDK_PATH}/Common/Configs/Targets/NX-NXFP2-a32/Include"
+  ]
+
+  conf.cc do |cc|
+    cc.command = "#{NINTENDO_SDK_PATH}/Compilers/NX/bin/nx-clang++"
+    cc.include_paths += include_paths
+    cc.flags += ['-fpic -fno-short-enums -ffunction-sections -fdata-sections -fno-common -fno-strict-aliasing -fomit-frame-pointer -fno-vectorize -funsigned-char -O2 -g -mno-implicit-float']
+    cc.defines += 'NN_SDK_BUILD_RELEASE'
+  end
+
+  conf.cxx do |cxx|
+    cxx.command = "#{NINTENDO_SDK_PATH}/Compilers/NX/bin/nx-clang++"
+    cxx.include_paths += include_paths
+    cxx.flags += ['-fpic -fno-short-enums -ffunction-sections -fdata-sections -fno-common -fno-strict-aliasing -fomit-frame-pointer -fno-vectorize -funsigned-char -O2 -g -mno-implicit-float']
+    cxx.defines += 'NN_SDK_BUILD_RELEASE'
+  end
+
+  conf.archiver do |archiver|
+    archiver.command = "#{NINTENDO_SDK_PATH}/Compilers/NX/nx/armv7l/bin/llvm-ar"
+  end
+
+  conf.linker do |linker|
+    linker.command = "#{NINTENDO_SDK_PATH}/Compilers/NX/nx/armv7l/bin/clang++"
+    linker.libraries = []
+  end
+
+  # Add your mrbgems
+end
+
+MRuby::CrossBuild.new('nintendo_switch_64bit') do |conf|
+  conf.toolchain :clang
+  NINTENDO_SDK_PATH = ENV['NINTENDO_SDK_ROOT']
+
+  include_paths = [
+    "#{NINTENDO_SDK_PATH}/Include",
+    "#{NINTENDO_SDK_PATH}/Common/Configs/Targets/NX-NXFP2-a64/Include"
+  ]
+
+  conf.cc do |cc|
+    cc.command = "#{NINTENDO_SDK_PATH}/Compilers/NX/bin/nx-clang++"
+    cc.include_paths += include_paths
+    cc.flags += ['-fpic -fno-short-enums -ffunction-sections -fdata-sections -fno-common -fno-strict-aliasing -fomit-frame-pointer -fno-vectorize -funsigned-char -O2 -g -mno-implicit-float']
+    cc.flags << '--target=aarch64-nintendo-nx-elf'
+    cc.defines += 'NN_SDK_BUILD_RELEASE'
+  end
+
+  conf.cxx do |cxx|
+    cxx.command = "#{NINTENDO_SDK_PATH}/Compilers/NX/bin/nx-clang++"
+    cxx.include_paths += include_paths
+    cxx.flags += ['-fpic -fno-short-enums -ffunction-sections -fdata-sections -fno-common -fno-strict-aliasing -fomit-frame-pointer -fno-vectorize -funsigned-char -O2 -g -mno-implicit-float']
+    cxx.flags << '--target=aarch64-nintendo-nx-elf'
+    cxx.defines += 'NN_SDK_BUILD_RELEASE'
+  end
+
+  conf.archiver do |archiver|
+    archiver.command = "#{NINTENDO_SDK_PATH}/Compilers/NX/nx/aarch64/bin/llvm-ar"
+  end
+
+  conf.linker do |linker|
+    linker.command = "#{NINTENDO_SDK_PATH}/Compilers/NX/nx/aarch64/bin/clang++"
+    linker.libraries = []
+  end
+
+  # Add your mrbgems
+end

build_config/nintendo_wii.rb

@@ -0,0 +1,95 @@
+# Cross Compiling configuration for the Nintendo Wii
+# This configuration requires devkitPPC
+# https://devkitpro.org/wiki/Getting_Started
+#
+#
+MRuby::CrossBuild.new("wii") do |conf|
+  toolchain :gcc
+
+  DEVKITPRO_PATH = "/opt/devkitpro"
+  BIN_PATH = "#{DEVKITPRO_PATH}/devkitPPC/bin"
+
+  # C compiler
+  conf.cc do |cc|
+    cc.command = "#{BIN_PATH}/powerpc-eabi-gcc"
+    cc.compile_options = %(%{flags} -o "%{outfile}" -c "%{infile}")
+  end
+
+  # C++ compiler
+  conf.cxx do |cxx|
+    cxx.command = "#{BIN_PATH}/powerpc-eabi-g++"
+    cxx.include_paths = conf.cc.include_paths.dup
+    cxx.flags = conf.cc.flags.dup
+    cxx.defines = conf.cc.defines.dup
+    cxx.compile_options = conf.cc.compile_options.dup
+  end
+
+  # Linker
+  conf.linker do |linker|
+    linker.command = "#{BIN_PATH}/powerpc-eabi-gcc"
+  end
+
+  # No executables
+  conf.bins = []
+
+  # Do not build executable test
+  conf.build_mrbtest_lib_only
+
+  # Disable C++ exception
+  conf.disable_cxx_exception
+
+  # All current core gems with ones with build issues commented out
+  conf.gem 'mrbgems/mruby-array-ext/'
+  conf.gem 'mrbgems/mruby-bigint/'
+  conf.gem 'mrbgems/mruby-bin-config/'
+  conf.gem 'mrbgems/mruby-bin-debugger/'
+  conf.gem 'mrbgems/mruby-bin-mirb/'
+  conf.gem 'mrbgems/mruby-bin-mrbc/'
+  conf.gem 'mrbgems/mruby-bin-mruby/'
+  conf.gem 'mrbgems/mruby-bin-strip/'
+  conf.gem 'mrbgems/mruby-binding/'
+  conf.gem 'mrbgems/mruby-catch/'
+  conf.gem 'mrbgems/mruby-class-ext/'
+  conf.gem 'mrbgems/mruby-cmath/'
+  conf.gem 'mrbgems/mruby-compar-ext/'
+  conf.gem 'mrbgems/mruby-compiler/'
+  conf.gem 'mrbgems/mruby-complex/'
+  conf.gem 'mrbgems/mruby-data/'
+  #conf.gem 'mrbgems/mruby-dir/'
+  conf.gem 'mrbgems/mruby-enum-chain/'
+  conf.gem 'mrbgems/mruby-enum-ext/'
+  conf.gem 'mrbgems/mruby-enum-lazy/'
+  conf.gem 'mrbgems/mruby-enumerator/'
+  conf.gem 'mrbgems/mruby-errno/'
+  conf.gem 'mrbgems/mruby-error/'
+  conf.gem 'mrbgems/mruby-eval/'
+  conf.gem 'mrbgems/mruby-exit/'
+  conf.gem 'mrbgems/mruby-fiber/'
+  conf.gem 'mrbgems/mruby-hash-ext/'
+  #conf.gem 'mrbgems/mruby-io/'
+  conf.gem 'mrbgems/mruby-kernel-ext/'
+  conf.gem 'mrbgems/mruby-math/'
+  conf.gem 'mrbgems/mruby-metaprog/'
+  conf.gem 'mrbgems/mruby-method/'
+  conf.gem 'mrbgems/mruby-numeric-ext/'
+  conf.gem 'mrbgems/mruby-object-ext/'
+  conf.gem 'mrbgems/mruby-objectspace/'
+  conf.gem 'mrbgems/mruby-os-memsize/'
+  conf.gem 'mrbgems/mruby-pack/'
+  conf.gem 'mrbgems/mruby-proc-binding/'
+  conf.gem 'mrbgems/mruby-proc-ext/'
+  conf.gem 'mrbgems/mruby-random/'
+  conf.gem 'mrbgems/mruby-range-ext/'
+  conf.gem 'mrbgems/mruby-rational/'
+  conf.gem 'mrbgems/mruby-set/'
+  conf.gem 'mrbgems/mruby-sleep/'
+  #conf.gem 'mrbgems/mruby-socket/'
+  conf.gem 'mrbgems/mruby-sprintf/'
+  conf.gem 'mrbgems/mruby-string-ext/'
+  conf.gem 'mrbgems/mruby-struct/'
+  conf.gem 'mrbgems/mruby-symbol-ext/'
+  conf.gem 'mrbgems/mruby-test-inline-struct/'
+  #conf.gem 'mrbgems/mruby-test/'
+  conf.gem 'mrbgems/mruby-time/'
+  conf.gem 'mrbgems/mruby-toplevel-ext/'
+end

build_config/playstationportable.rb

@@ -0,0 +1,78 @@
+# Cross Compiling configuration for the Sony PlayStation Portable.
+# This configuration requires toolchain from https://github.com/pspdev
+
+MRuby::CrossBuild.new("playstationportable") do |conf|
+  toolchain :gcc
+
+  PSPDEV_PATH = "#{ENV['PSPDEV']}"
+  BIN_PATH = "#{PSPDEV_PATH}/bin"
+
+  # C compiler
+  conf.cc do |cc|
+    cc.command = "#{BIN_PATH}/psp-gcc"
+    cc.flags << ["-O2", "-D_PSP_FW_VERSION=600"]
+    cc.include_paths << ["#{PSPDEV_PATH}/psp/include", "#{PSPDEV_PATH}/psp/sdk/include"]
+    cc.compile_options = %(%{flags} -o "%{outfile}" -c "%{infile}")
+  end
+
+  # C++ compiler
+  conf.cxx do |cxx|
+    cxx.command = "#{BIN_PATH}/psp-g++"
+    cxx.include_paths = conf.cc.include_paths.dup
+    cxx.flags = conf.cc.flags.dup
+    cxx.flags << %w[-fno-rtti -fno-exceptions]
+    cxx.defines = conf.cc.defines.dup
+    cxx.compile_options = conf.cc.compile_options.dup
+  end
+
+  # Linker
+  conf.linker do |linker|
+    linker.command = "#{BIN_PATH}/psp-gcc"
+    linker.flags << ["-Wl,-zmax-page-size=128"]
+  end
+
+  # No executables
+  conf.bins = []
+
+  # Do not build executable test
+  conf.build_mrbtest_lib_only
+
+  # Gems from core
+  conf.gem :core => "mruby-metaprog"
+  conf.gem :core => "mruby-pack"
+  conf.gem :core => "mruby-sprintf"
+  conf.gem :core => "mruby-math"
+  conf.gem :core => "mruby-time"
+  conf.gem :core => "mruby-struct"
+  conf.gem :core => "mruby-compar-ext"
+  conf.gem :core => "mruby-enum-ext"
+  conf.gem :core => "mruby-string-ext"
+  conf.gem :core => "mruby-numeric-ext"
+  conf.gem :core => "mruby-array-ext"
+  conf.gem :core => "mruby-hash-ext"
+  conf.gem :core => "mruby-range-ext"
+  conf.gem :core => "mruby-proc-ext"
+  conf.gem :core => "mruby-symbol-ext"
+  conf.gem :core => "mruby-random"
+  conf.gem :core => "mruby-object-ext"
+  conf.gem :core => "mruby-objectspace"
+  conf.gem :core => "mruby-fiber"
+  conf.gem :core => "mruby-enumerator"
+  conf.gem :core => "mruby-enum-lazy"
+  conf.gem :core => "mruby-toplevel-ext"
+  conf.gem :core => "mruby-kernel-ext"
+  conf.gem :core => "mruby-class-ext"
+  conf.gem :core => "mruby-compiler"
+  conf.gem :core => "mruby-binding"
+  conf.gem :core => "mruby-catch"
+  conf.gem :core => "mruby-enum-chain"
+  conf.gem :core => "mruby-errno"
+  conf.gem :core => "mruby-error"
+  conf.gem :core => "mruby-exit"
+  conf.gem :core => "mruby-os-memsize"
+  conf.gem :core => "mruby-proc-binding"
+  conf.gem :core => "mruby-sleep"
+  conf.gem :core => "mruby-io"
+  conf.gem :core => "mruby-dir"
+  #conf.gem :core => "mruby-socket" unsupported
+end

build_config/serenity.rb

@@ -0,0 +1,26 @@
+# Cross compiling configuration for SerenityOS
+# Graphical Unix-like operating system for x86 computers.
+# https://github.com/SerenityOS/serenity
+#
+# Should be built using the SerenityOS Ports system
+# https://github.com/SerenityOS/serenity/tree/master/Ports
+#
+# As of 2021/08/20, SERENITY_ARCH is defined in the SerenityOS Ports
+# build script to always be either "i686" or "x86_64"
+
+MRuby::CrossBuild.new('serenity') do |conf|
+  conf.toolchain :gcc
+
+  conf.archiver.command = "#{ENV['SERENITY_ARCH']}-pc-serenity-ar"
+  conf.linker.command = "#{ENV['SERENITY_ARCH']}-pc-serenity-g++"
+
+  conf.cxx.command = "#{ENV['SERENITY_ARCH']}-pc-serenity-g++"
+  conf.cxx.defines << (ENV['SERENITY_ARCH'].include?('64') ? 'MRB_64BIT' : 'MRB_32BIT')
+
+  conf.cc.command = "#{ENV['SERENITY_ARCH']}-pc-serenity-gcc"
+  conf.cc.defines << (ENV['SERENITY_ARCH'].include?('64') ? 'MRB_64BIT' : 'MRB_32BIT')
+
+  conf.gembox 'full-core'
+
+  conf.test_runner.command = 'env'
+end

doc/README.md

@@ -0,0 +1,67 @@
+# mruby Documentation
+
+## Getting Started
+
+New to mruby? Start here:
+
+| Document                                     | Description                            |
+| -------------------------------------------- | -------------------------------------- |
+| [Getting Started](guides/getting-started.md) | Build mruby and run your first program |
+| [Language Features](guides/language.md)      | Ruby subset supported by mruby         |
+| [Limitations](limitations.md)                | Behavioral differences from CRuby      |
+
+## Guides (for embedders and gem authors)
+
+### Embedding mruby in C
+
+| Document                                | Description                                      |
+| --------------------------------------- | ------------------------------------------------ |
+| [C API Reference](guides/capi.md)       | Values, classes, methods, error handling, fibers |
+| [GC Arena](guides/gc-arena-howto.md)    | Managing temporary objects in C extensions       |
+| [Linking](guides/link.md)               | Linking with `libmruby`                          |
+| [Amalgamation](guides/amalgamation.md)  | Single-file build for easy integration           |
+| [Precompiled Symbols](guides/symbol.md) | Compile-time symbol allocation                   |
+
+### Building and Configuring
+
+| Document                                 | Description                                 |
+| ---------------------------------------- | ------------------------------------------- |
+| [Compilation](guides/compile.md)         | Build system, cross-compilation, toolchains |
+| [Build Configuration](guides/mrbconf.md) | Compile-time macros (`MRB_*` flags)         |
+| [mrbgems](guides/mrbgems.md)             | Creating and managing gems                  |
+| [Memory](guides/memory.md)               | Allocator customization and heap regions    |
+
+### Tools
+
+| Document                                        | Description                                     |
+| ----------------------------------------------- | ----------------------------------------------- |
+| [Debugger](guides/debugger.md)                  | Using `mrdb` for debugging                      |
+| [ROM Method Tables](guides/rom-method-table.md) | Read-only method tables for constrained devices |
+
+### Reference
+
+| Document                              | Description        |
+| ------------------------------------- | ------------------ |
+| [Directory Structure](guides/hier.md) | Source tree layout |
+
+## Internals (for mruby contributors)
+
+Start with [Architecture](internal/architecture.md) for an overview,
+then dive into the subsystem you need:
+
+| Document                                  | Description                                        |
+| ----------------------------------------- | -------------------------------------------------- |
+| [Architecture](internal/architecture.md)  | Overview of object model, VM, GC, compiler         |
+| [Virtual Machine](internal/vm.md)         | Dispatch loop, call frames, method lookup, fibers  |
+| [Garbage Collector](internal/gc.md)       | Tri-color marking, write barriers, generational GC |
+| [Compiler Pipeline](internal/compiler.md) | Parser, code generator, IRep, binary format        |
+| [Opcodes](internal/opcode.md)             | VM instruction set reference                       |
+| [Value Boxing](internal/boxing.md)        | How `mrb_value` encodes types                      |
+
+## Release Notes
+
+- [mruby 3.4](mruby3.4.md)
+- [mruby 3.3](mruby3.3.md)
+- [mruby 3.2](mruby3.2.md)
+- [mruby 3.1](mruby3.1.md)
+- [mruby 3.0](mruby3.0.md)

doc/guides/amalgamation.md

@@ -0,0 +1,153 @@
+<!-- summary: About Amalgamation (Single-File Build) -->
+
+# Amalgamation
+
+Amalgamation combines all mruby source files into a single `mruby.c` and
+`mruby.h` for easy embedding, similar to SQLite's distribution model.
+
+## Benefits
+
+- **Simple integration**: Just two files to add to your project
+- **Single compilation unit**: Enables better compiler optimization
+- **No build system required**: Compile directly with any C compiler
+- **Portable**: No external dependencies beyond standard C library
+  (but see [Platform-Dependent Gems](#platform-dependent-gems) below)
+
+## Generating Amalgamation
+
+```console
+rake amalgam
+```
+
+Output files are generated in `build/<target>/amalgam/`:
+
+- `mruby.h` - All headers concatenated in dependency order
+- `mruby.c` - All sources concatenated (core + gems + mrblib)
+
+### With Custom Configuration
+
+The amalgamation includes gems specified in your build configuration:
+
+```console
+MRUBY_CONFIG=build_config/minimal.rb rake amalgam
+```
+
+## Using the Amalgamation
+
+### Basic Usage
+
+```c
+#include "mruby.h"
+
+int main(void) {
+  mrb_state *mrb = mrb_open();
+  mrb_load_string(mrb, "puts 'Hello from mruby!'");
+  mrb_close(mrb);
+  return 0;
+}
+```
+
+### Compiling
+
+```console
+gcc -I./build/host/amalgam your_app.c ./build/host/amalgam/mruby.c -o your_app -lm
+```
+
+For optimized builds:
+
+```console
+gcc -O2 -DNDEBUG -I./build/host/amalgam your_app.c ./build/host/amalgam/mruby.c -o your_app -lm
+```
+
+## Gem Compatibility
+
+### Known Working Gems
+
+The following gems work with amalgamation:
+
+- `mruby-compiler` - Required for `mrb_load_string`
+- `mruby-eval` - `eval`, `Binding`
+- `mruby-array-ext`, `mruby-string-ext`, `mruby-hash-ext`
+- `mruby-numeric-ext`, `mruby-range-ext`, `mruby-symbol-ext`
+- `mruby-proc-ext`, `mruby-kernel-ext`, `mruby-object-ext`, `mruby-class-ext`
+- `mruby-enum-ext`, `mruby-compar-ext`
+- `mruby-error`, `mruby-math`, `mruby-struct`
+- `mruby-bigint`, `mruby-rational`, `mruby-complex`
+- `mruby-io` (with `hal-posix-io`)
+- `mruby-task` (with `hal-posix-task`)
+
+### Platform-Dependent Gems
+
+Gems that use a HAL (Hardware Abstraction Layer) include
+platform-specific code in the amalgamation. For example, if
+`mruby-io` selects `hal-posix-io` on Linux, the generated `mruby.c`
+contains POSIX-specific code and cannot be compiled on Windows.
+
+If you need amalgamated files for multiple platforms, generate them
+separately for each target platform (or cross-build configuration).
+
+### Excluded Gems
+
+Binary gems (`mruby-bin-*`) are automatically excluded as they contain
+their own `main()` function. The amalgamation produces a library, not
+an executable.
+
+## Example Configuration
+
+A minimal configuration for amalgamation:
+
+```ruby
+# build_config/amalgam.rb
+MRuby::Build.new do |conf|
+  conf.toolchain :gcc
+
+  conf.gem core: 'mruby-compiler'
+  conf.gem core: 'mruby-error'
+  conf.gem core: 'mruby-eval'
+  conf.gem core: 'mruby-array-ext'
+  conf.gem core: 'mruby-string-ext'
+  conf.gem core: 'mruby-hash-ext'
+  conf.gem core: 'mruby-io'
+end
+```
+
+Generate with:
+
+```console
+MRUBY_CONFIG=build_config/amalgam.rb rake amalgam
+```
+
+## Output Sizes
+
+Typical sizes depend on included gems:
+
+- `mruby.h`: 200-500 KB
+- `mruby.c`: 2-4 MB
+
+## Technical Details
+
+### Header Processing
+
+- Include guards are stripped to allow concatenation
+- Headers are ordered by dependency (foundation types first)
+- Internal includes are commented out (already in `mruby.h`)
+
+### Source Processing
+
+- Sources are concatenated in proper initialization order
+- X-macro headers (like `mruby/ops.h`) are inlined at each use
+- Local includes (`.cstub` files) are automatically inlined
+- Generated files (`mrblib.c`, `gem_init.c`) are included
+
+### Gem Defines
+
+Gems that add preprocessor defines affecting core structures are
+automatically detected and included at the top of `mruby.h`.
+Supported patterns: `MRB_USE_*`, `MRB_UTF8_*`, `HAVE_MRUBY_*`.
+
+### Build Order
+
+1. Core sources (`src/*.c`)
+2. Gem sources (`mrbgems/*/src/*.c` or `core/*.c`)
+3. Generated mrblib (`build/*/mrblib/mrblib.c`)
+4. Gem initialization (`build/*/mrbgems/gem_init.c`)

doc/guides/capi.md

@@ -0,0 +1,856 @@
+<!-- summary: C API Reference -->
+
+# C API Reference
+
+This document covers the mruby C API for embedding and extending mruby.
+
+**Contents:**
+[Headers](#headers) |
+[State Management](#state-management) |
+[Values](#values) |
+[Defining Classes and Modules](#defining-classes-and-modules) |
+[Defining Methods](#defining-methods) |
+[Parsing Arguments](#parsing-arguments) |
+[Calling Ruby Methods from C](#calling-ruby-methods-from-c) |
+[String Operations](#string-operations) |
+[Array Operations](#array-operations) |
+[Hash Operations](#hash-operations) |
+[Wrapping C Structures](#wrapping-c-structures) |
+[Exception Handling](#exception-handling) |
+[Method Visibility](#method-visibility) |
+[Proc and Block Handling](#proc-and-block-handling) |
+[Fiber API](#fiber-api) |
+[Compilation Contexts](#compilation-contexts) |
+[Precompiled Bytecode](#precompiled-bytecode) |
+[GC Arena](#gc-arena) |
+[Memory Allocation](#memory-allocation)
+
+## Headers
+
+```c
+#include <mruby.h>            /* core types, state, class/method definition */
+#include <mruby/compile.h>    /* mrb_load_string, mrb_load_file */
+#include <mruby/string.h>     /* string operations */
+#include <mruby/array.h>      /* array operations */
+#include <mruby/hash.h>       /* hash operations */
+#include <mruby/data.h>       /* wrapping C structs */
+#include <mruby/class.h>      /* class inspection */
+#include <mruby/value.h>      /* value type macros */
+#include <mruby/irep.h>       /* loading precompiled bytecode */
+#include <mruby/error.h>      /* error handling (mrb_protect etc.) */
+#include <mruby/variable.h>   /* instance/class/global variables */
+```
+
+## State Management
+
+```c
+mrb_state *mrb = mrb_open();       /* create state with all gems */
+mrb_state *mrb = mrb_open_core();  /* create state without gems */
+mrb_close(mrb);                    /* close and free state */
+```
+
+`mrb_open()` returns `NULL` on allocation failure. Always check the
+return value.
+
+## Values
+
+All Ruby values are represented as `mrb_value` in C.
+
+### Creating Values
+
+```c
+mrb_nil_value()                          /* nil */
+mrb_true_value()                         /* true */
+mrb_false_value()                        /* false */
+mrb_bool_value(mrb_bool b)              /* true or false */
+mrb_fixnum_value(mrb_int i)             /* Integer */
+mrb_float_value(mrb_state *mrb, mrb_float f)  /* Float */
+mrb_symbol_value(mrb_sym sym)           /* Symbol */
+mrb_obj_value(void *p)                  /* object pointer to value */
+mrb_cptr_value(mrb_state *mrb, void *p) /* C pointer */
+```
+
+### Type Checking
+
+```c
+mrb_type(v)          /* returns enum mrb_vtype */
+mrb_nil_p(v)         /* true if nil */
+mrb_integer_p(v)     /* true if Integer */
+mrb_float_p(v)       /* true if Float */
+mrb_symbol_p(v)      /* true if Symbol */
+mrb_string_p(v)      /* true if String */
+mrb_array_p(v)       /* true if Array */
+mrb_hash_p(v)        /* true if Hash */
+mrb_true_p(v)        /* true if true */
+mrb_false_p(v)       /* true if false */
+mrb_undef_p(v)       /* true if undefined */
+mrb_immediate_p(v)   /* true if not a heap object */
+```
+
+### Extracting C Values
+
+```c
+mrb_integer(v)               /* mrb_int from Integer value */
+mrb_float(v)                 /* mrb_float from Float value */
+mrb_symbol(v)                /* mrb_sym from Symbol value */
+mrb_ptr(v)                   /* void* from object value */
+mrb_str_to_cstr(mrb, v)     /* const char* from String value */
+```
+
+### Value Types
+
+| `mrb_vtype`        | Ruby Class          | Notes                    |
+| ------------------ | ------------------- | ------------------------ |
+| `MRB_TT_FALSE`     | FalseClass/NilClass | `nil` has `MRB_TT_FALSE` |
+| `MRB_TT_TRUE`      | TrueClass           |                          |
+| `MRB_TT_INTEGER`   | Integer             | Immediate value          |
+| `MRB_TT_FLOAT`     | Float               | May be immediate         |
+| `MRB_TT_SYMBOL`    | Symbol              | Immediate value          |
+| `MRB_TT_STRING`    | String              | Heap object              |
+| `MRB_TT_ARRAY`     | Array               | Heap object              |
+| `MRB_TT_HASH`      | Hash                | Heap object              |
+| `MRB_TT_OBJECT`    | Object              | User-defined classes     |
+| `MRB_TT_CLASS`     | Class               |                          |
+| `MRB_TT_MODULE`    | Module              |                          |
+| `MRB_TT_PROC`      | Proc                |                          |
+| `MRB_TT_CDATA`     | (C data)            | Wrapped C structs        |
+| `MRB_TT_EXCEPTION` | Exception           |                          |
+| `MRB_TT_FIBER`     | Fiber               |                          |
+
+## Defining Classes and Modules
+
+```c
+/* Define a class under Object */
+struct RClass *my_class = mrb_define_class(mrb, "MyClass", mrb->object_class);
+
+/* Define a class under another class/module */
+struct RClass *inner = mrb_define_class_under(mrb, outer, "Inner", mrb->object_class);
+
+/* Define a module */
+struct RClass *my_mod = mrb_define_module(mrb, "MyModule");
+struct RClass *inner_mod = mrb_define_module_under(mrb, outer, "InnerMod");
+
+/* Include/prepend a module */
+mrb_include_module(mrb, my_class, my_mod);
+mrb_prepend_module(mrb, my_class, my_mod);
+
+/* Look up existing class/module */
+struct RClass *c = mrb_class_get(mrb, "String");
+struct RClass *m = mrb_module_get(mrb, "Kernel");
+
+/* Define a constant */
+mrb_define_const(mrb, my_class, "VERSION", mrb_str_new_lit(mrb, "1.0"));
+```
+
+## Defining Methods
+
+All C methods have the same signature:
+
+```c
+static mrb_value
+my_method(mrb_state *mrb, mrb_value self)
+{
+  /* self is the receiver */
+  return mrb_nil_value();
+}
+```
+
+Register with:
+
+```c
+mrb_define_method(mrb, klass, "name", my_method, MRB_ARGS_NONE());
+mrb_define_class_method(mrb, klass, "name", my_method, MRB_ARGS_REQ(1));
+mrb_define_module_function(mrb, mod, "name", my_method, MRB_ARGS_ANY());
+```
+
+### Argument Specifiers
+
+| Macro                  | Meaning                               |
+| ---------------------- | ------------------------------------- |
+| `MRB_ARGS_NONE()`      | No arguments                          |
+| `MRB_ARGS_REQ(n)`      | `n` required arguments                |
+| `MRB_ARGS_OPT(n)`      | `n` optional arguments                |
+| `MRB_ARGS_ARG(r,o)`    | `r` required + `o` optional           |
+| `MRB_ARGS_REST()`      | Splat (`*args`)                       |
+| `MRB_ARGS_BLOCK()`     | Block (`&block`)                      |
+| `MRB_ARGS_ANY()`       | Any number (same as REST)             |
+| `MRB_ARGS_KEY(n,rest)` | `n` keyword args, `rest`=1 for `**kw` |
+
+These can be combined with `|`:
+
+```c
+MRB_ARGS_REQ(1) | MRB_ARGS_OPT(2) | MRB_ARGS_BLOCK()
+```
+
+## Parsing Arguments
+
+`mrb_get_args()` extracts arguments from the Ruby call stack:
+
+```c
+mrb_int mrb_get_args(mrb_state *mrb, const char *format, ...);
+```
+
+### Format Specifiers
+
+| Spec | Ruby Type     | C Type(s)                   | Notes                            |
+| ---- | ------------- | --------------------------- | -------------------------------- |
+| `o`  | any           | `mrb_value`                 | No type check                    |
+| `i`  | Numeric       | `mrb_int`                   | Coerces to integer               |
+| `f`  | Numeric       | `mrb_float`                 | Coerces to float                 |
+| `b`  | any           | `mrb_bool`                  | Truthiness                       |
+| `n`  | String/Symbol | `mrb_sym`                   | Converts to symbol               |
+| `s`  | String        | `const char*, mrb_int`      | Pointer + length                 |
+| `z`  | String        | `const char*`               | Null-terminated                  |
+| `S`  | String        | `mrb_value`                 | String value                     |
+| `A`  | Array         | `mrb_value`                 | Array value                      |
+| `H`  | Hash          | `mrb_value`                 | Hash value                       |
+| `C`  | Class         | `mrb_value`                 | Class/Module value               |
+| `c`  | Class         | `struct RClass*`            | Class pointer                    |
+| `a`  | Array         | `const mrb_value*, mrb_int` | Array pointer + length           |
+| `d`  | C Data        | `void*`                     | Requires `mrb_data_type*`        |
+| `&`  | Block         | `mrb_value`                 | Block argument                   |
+| `*`  | rest          | `const mrb_value*, mrb_int` | Rest arguments                   |
+| `\|` | —             | —                           | Following args are optional      |
+| `?`  | —             | `mrb_bool`                  | Was previous optional arg given? |
+| `:`  | keywords      | `mrb_kwargs`                | Keyword arguments                |
+
+Adding `!` to `S`, `A`, `H`, `C`, `c`, `s`, `z`, `a`, `d` allows `nil`
+(returns NULL/zero for nil).
+
+### Examples
+
+```c
+/* def method(name, count) */
+const char *name; mrb_int len, count;
+mrb_get_args(mrb, "si", &name, &len, &count);
+
+/* def method(required, optional=nil) */
+mrb_value req, opt = mrb_nil_value();
+mrb_get_args(mrb, "o|o", &req, &opt);
+
+/* def method(*args) */
+const mrb_value *args; mrb_int argc;
+mrb_get_args(mrb, "*", &args, &argc);
+
+/* def method(&block) */
+mrb_value block;
+mrb_get_args(mrb, "&", &block);
+
+/* def method(name:, age: 0) */
+mrb_sym kw_names[] = { mrb_intern_lit(mrb, "name"), mrb_intern_lit(mrb, "age") };
+mrb_value kw_values[2];
+mrb_kwargs kw = { 2, 1, kw_names, kw_values, NULL };
+mrb_get_args(mrb, ":", &kw);
+/* kw_values[0] = name (required), kw_values[1] = age (optional, undef if not given) */
+```
+
+## Calling Ruby Methods from C
+
+```c
+/* Call obj.method(arg1, arg2) */
+mrb_funcall(mrb, obj, "method", 2, arg1, arg2);
+
+/* Call with symbol (faster, no string lookup) */
+mrb_funcall_id(mrb, obj, mrb_intern_lit(mrb, "method"), 2, arg1, arg2);
+
+/* Call with argv array */
+mrb_value argv[] = { arg1, arg2 };
+mrb_funcall_argv(mrb, obj, mrb_intern_lit(mrb, "method"), 2, argv);
+
+/* Call with block */
+mrb_funcall_with_block(mrb, obj, mid, argc, argv, block);
+
+/* Yield to block */
+mrb_yield(mrb, block, arg);
+mrb_yield_argv(mrb, block, argc, argv);
+```
+
+## String Operations
+
+```c
+/* Creation */
+mrb_str_new_lit(mrb, "hello")              /* from string literal */
+mrb_str_new(mrb, ptr, len)                 /* from pointer + length */
+mrb_str_new_cstr(mrb, cstr)               /* from null-terminated C string */
+mrb_str_new_static(mrb, ptr, len)          /* from static data (no copy) */
+
+/* Access */
+RSTRING_PTR(str)                           /* char* pointer */
+RSTRING_LEN(str)                           /* length */
+mrb_str_to_cstr(mrb, str)                 /* null-terminated (may copy) */
+
+/* Modification */
+mrb_str_cat(mrb, str, ptr, len)            /* append bytes */
+mrb_str_cat_cstr(mrb, str, cstr)           /* append C string */
+mrb_str_cat_str(mrb, str, str2)            /* append String */
+
+/* Comparison */
+mrb_str_equal(mrb, str1, str2)             /* equality */
+mrb_str_cmp(mrb, str1, str2)              /* comparison (-1, 0, 1) */
+```
+
+## Array Operations
+
+```c
+/* Creation */
+mrb_ary_new(mrb)                           /* empty array */
+mrb_ary_new_capa(mrb, capa)               /* preallocated */
+mrb_ary_new_from_values(mrb, n, vals)     /* from C array */
+
+/* Access */
+RARRAY_PTR(ary)                            /* mrb_value* pointer */
+RARRAY_LEN(ary)                            /* length */
+mrb_ary_entry(ary, idx)                    /* get element (no mrb needed) */
+
+/* Modification */
+mrb_ary_push(mrb, ary, val)               /* append */
+mrb_ary_pop(mrb, ary)                     /* remove last */
+mrb_ary_shift(mrb, ary)                   /* remove first */
+mrb_ary_unshift(mrb, ary, val)            /* prepend */
+mrb_ary_set(mrb, ary, idx, val)           /* set element */
+mrb_ary_splice(mrb, ary, pos, len, rpl)   /* splice */
+mrb_ary_concat(mrb, ary, other)           /* extend */
+```
+
+## Hash Operations
+
+```c
+/* Creation */
+mrb_hash_new(mrb)                          /* empty hash */
+
+/* Access */
+mrb_hash_get(mrb, hash, key)              /* get value */
+mrb_hash_fetch(mrb, hash, key, def)       /* get with default */
+mrb_hash_key_p(mrb, hash, key)            /* key exists? */
+mrb_hash_empty_p(mrb, hash)               /* empty? */
+mrb_hash_size(mrb, hash)                  /* number of entries */
+
+/* Modification */
+mrb_hash_set(mrb, hash, key, val)         /* set key-value */
+mrb_hash_delete_key(mrb, hash, key)       /* delete key */
+mrb_hash_merge(mrb, hash1, hash2)         /* merge hash2 into hash1 */
+
+/* Iteration */
+mrb_hash_keys(mrb, hash)                  /* Array of keys */
+mrb_hash_values(mrb, hash)                /* Array of values */
+```
+
+## Wrapping C Structures
+
+To expose a C struct to Ruby, use `mrb_data_type` and `Data_Wrap_Struct`:
+
+```c
+/* 1. Define the data type with a name and destructor */
+static void point_free(mrb_state *mrb, void *p) {
+  mrb_free(mrb, p);
+}
+
+static const mrb_data_type point_type = {
+  "Point", point_free
+};
+
+/* 2. Allocate and initialize */
+static mrb_value
+point_init(mrb_state *mrb, mrb_value self)
+{
+  mrb_float x, y;
+  mrb_get_args(mrb, "ff", &x, &y);
+
+  double *data = (double*)mrb_malloc(mrb, sizeof(double) * 2);
+  data[0] = x;
+  data[1] = y;
+
+  DATA_PTR(self) = data;
+  DATA_TYPE(self) = &point_type;
+
+  return self;
+}
+
+/* 3. Access the wrapped data */
+static mrb_value
+point_x(mrb_state *mrb, mrb_value self)
+{
+  double *data = (double*)mrb_data_get_ptr(mrb, self, &point_type);
+  return mrb_float_value(mrb, data[0]);
+}
+
+/* 4. Register the class */
+struct RClass *point = mrb_define_class(mrb, "Point", mrb->object_class);
+MRB_SET_INSTANCE_TT(point, MRB_TT_CDATA);
+mrb_define_method(mrb, point, "initialize", point_init, MRB_ARGS_REQ(2));
+mrb_define_method(mrb, point, "x", point_x, MRB_ARGS_NONE());
+```
+
+## Exception Handling
+
+### Raising Exceptions
+
+```c
+mrb_raise(mrb, E_RUNTIME_ERROR, "something went wrong");
+mrb_raisef(mrb, E_ARGUMENT_ERROR, "expected %d, got %d", expected, actual);
+mrb_raise(mrb, E_TYPE_ERROR, "wrong type");
+```
+
+Common exception classes: `E_RUNTIME_ERROR`, `E_TYPE_ERROR`,
+`E_ARGUMENT_ERROR`, `E_RANGE_ERROR`, `E_NAME_ERROR`,
+`E_NOMETHOD_ERROR`, `E_NOTIMP_ERROR`, `E_KEY_ERROR`.
+
+### Catching Exceptions
+
+```c
+/* Check after mrb_load_string or mrb_funcall */
+mrb_value result = mrb_load_string(mrb, code);
+if (mrb->exc) {
+  mrb_print_error(mrb);
+  mrb->exc = NULL;  /* clear exception */
+}
+```
+
+### Protected Execution
+
+`mrb_protect()` executes a function under protection. If an
+exception is raised, it is captured as a return value instead of
+propagating:
+
+```c
+static mrb_value
+safe_operation(mrb_state *mrb, mrb_value data)
+{
+  /* This function might raise an exception */
+  return mrb_funcall(mrb, data, "do_something", 0);
+}
+
+mrb_bool error;
+mrb_value result = mrb_protect(mrb, safe_operation, data, &error);
+if (error) {
+  /* result contains the exception object; mrb->exc is cleared */
+  mrb_value inspect = mrb_inspect(mrb, result);
+  fprintf(stderr, "Error: %s\n", mrb_str_to_cstr(mrb, inspect));
+}
+```
+
+**Note:** `mrb_protect` clears `mrb->exc` after catching the
+exception. The exception is returned as `result`. Do not use
+`mrb_print_error()` after `mrb_protect` — it reads `mrb->exc`
+which is already `NULL`.
+
+For lower-level protection with a `void*` callback:
+
+```c
+static mrb_value
+body(mrb_state *mrb, void *userdata)
+{
+  /* ... */
+}
+
+mrb_bool error;
+mrb_value result = mrb_protect_error(mrb, body, userdata, &error);
+```
+
+### Rescue
+
+`mrb_rescue()` catches `StandardError` (like Ruby's `rescue`):
+
+```c
+static mrb_value
+body_func(mrb_state *mrb, mrb_value body_data)
+{
+  return mrb_funcall(mrb, body_data, "risky_method", 0);
+}
+
+static mrb_value
+rescue_func(mrb_state *mrb, mrb_value rescue_data)
+{
+  /* handle error, rescue_data is the data passed in */
+  return mrb_nil_value();
+}
+
+mrb_value result = mrb_rescue(mrb, body_func, body_data,
+                              rescue_func, rescue_data);
+```
+
+To rescue specific exception classes:
+
+```c
+struct RClass *classes[] = {
+  E_ARGUMENT_ERROR,
+  mrb_class_get(mrb, "IOError")
+};
+mrb_value result = mrb_rescue_exceptions(mrb, body_func, body_data,
+                                         rescue_func, rescue_data,
+                                         2, classes);
+```
+
+### Ensure
+
+`mrb_ensure()` guarantees cleanup runs regardless of exceptions
+(like Ruby's `ensure`):
+
+```c
+static mrb_value
+body_func(mrb_state *mrb, mrb_value data)
+{
+  return mrb_funcall(mrb, data, "process", 0);
+}
+
+static mrb_value
+cleanup_func(mrb_state *mrb, mrb_value data)
+{
+  mrb_funcall(mrb, data, "close", 0);
+  return mrb_nil_value();
+}
+
+mrb_value result = mrb_ensure(mrb, body_func, body_data,
+                              cleanup_func, cleanup_data);
+```
+
+The ensure function always executes. If the body raises an
+exception, the ensure runs and then the exception is re-raised.
+
+### Error State Management
+
+```c
+mrb_bool mrb_check_error(mrb_state *mrb);  /* check and clear mrb->exc */
+void mrb_clear_error(mrb_state *mrb);      /* clear mrb->exc */
+```
+
+## Method Visibility
+
+```c
+/* Public (default) */
+mrb_define_method(mrb, klass, "name", func, MRB_ARGS_NONE());
+
+/* Private - only callable without explicit receiver */
+mrb_define_private_method(mrb, klass, "name", func, MRB_ARGS_NONE());
+
+/* Class method (singleton method on the class object) */
+mrb_define_class_method(mrb, klass, "name", func, MRB_ARGS_NONE());
+
+/* Module function (both module method and private instance method) */
+mrb_define_module_function(mrb, mod, "name", func, MRB_ARGS_NONE());
+
+/* Singleton method on a specific object */
+mrb_define_singleton_method(mrb, obj, "name", func, MRB_ARGS_NONE());
+
+/* Method alias: alias new_name old_name */
+mrb_define_alias(mrb, klass, "new_name", "old_name");
+
+/* Remove a method */
+mrb_undef_method(mrb, klass, "name");
+mrb_undef_class_method(mrb, klass, "name");
+```
+
+All `_method` variants have `_id` counterparts that accept
+`mrb_sym` instead of `const char*` for better performance.
+
+## Proc and Block Handling
+
+### Creating Procs from C Functions
+
+```c
+/* Simple C function proc */
+struct RProc *proc = mrb_proc_new_cfunc(mrb, my_func);
+
+/* C closure with captured local variables */
+struct RProc *proc = mrb_closure_new_cfunc(mrb, my_func, nlocals);
+```
+
+### C Functions with Environment (requires mruby-proc-ext)
+
+Store values in a proc's environment, accessible from the C
+function:
+
+```c
+mrb_value env_values[] = { mrb_fixnum_value(42) };
+struct RProc *proc = mrb_proc_new_cfunc_with_env(mrb, my_func, 1, env_values);
+
+/* Inside my_func, retrieve environment values */
+static mrb_value my_func(mrb_state *mrb, mrb_value self)
+{
+  mrb_value val = mrb_proc_cfunc_env_get(mrb, 0); /* index 0 */
+  return val;
+}
+```
+
+## Fiber API
+
+```c
+#include <mruby.h>    /* fiber types and functions */
+```
+
+### Creating and Using Fibers
+
+```c
+/* Create a fiber from a proc */
+mrb_value fiber = mrb_fiber_new(mrb, proc);
+
+/* Resume the fiber with arguments */
+mrb_value args[] = { mrb_fixnum_value(1) };
+mrb_value result = mrb_fiber_resume(mrb, fiber, 1, args);
+
+/* Check if fiber is still alive */
+mrb_bool alive = mrb_test(mrb_fiber_alive_p(mrb, fiber));
+```
+
+### Yielding from C
+
+`mrb_fiber_yield()` can only be used as the return value of a C
+function — no code may execute after it:
+
+```c
+static mrb_value
+my_yield_method(mrb_state *mrb, mrb_value self)
+{
+  mrb_value yield_args[] = { mrb_str_new_lit(mrb, "yielded") };
+  return mrb_fiber_yield(mrb, 1, yield_args);  /* must be returned directly */
+}
+```
+
+### Fiber States
+
+| State                   | Meaning                          |
+| ----------------------- | -------------------------------- |
+| `MRB_FIBER_CREATED`     | Created but not yet resumed      |
+| `MRB_FIBER_RUNNING`     | Currently executing              |
+| `MRB_FIBER_RESUMED`     | Resumed another fiber            |
+| `MRB_FIBER_SUSPENDED`   | Yielded, waiting to resume       |
+| `MRB_FIBER_TRANSFERRED` | Transferred via `Fiber#transfer` |
+| `MRB_FIBER_TERMINATED`  | Finished execution               |
+
+**Limitation:** fibers cannot yield across C function boundaries.
+You cannot call `mrb_fiber_yield` from within a C-implemented
+method, except via `mrb_fiber_yield` at function return.
+
+## Compilation Contexts
+
+For advanced compilation control, use `mrb_ccontext`:
+
+```c
+#include <mruby/compile.h>
+
+mrb_ccontext *cxt = mrb_ccontext_new(mrb);
+
+/* Set source filename for error messages and debug info */
+mrb_ccontext_filename(mrb, cxt, "my_script.rb");
+
+/* Compile and execute with context */
+mrb_value result = mrb_load_string_cxt(mrb, "1 + 2", cxt);
+
+/* Clean up */
+mrb_ccontext_free(mrb, cxt);
+```
+
+### Context Options
+
+The `mrb_ccontext` structure provides several flags:
+
+| Field            | Purpose                                 |
+| ---------------- | --------------------------------------- |
+| `capture_errors` | Collect parse errors instead of raising |
+| `no_exec`        | Compile without executing (get RProc)   |
+| `no_optimize`    | Disable peephole optimizations          |
+| `no_ext_ops`     | Disable extended operand instructions   |
+| `keep_lv`        | Preserve local variables across loads   |
+
+### Loading with Context
+
+```c
+mrb_load_string_cxt(mrb, code, cxt);         /* string + context */
+mrb_load_nstring_cxt(mrb, code, len, cxt);   /* with explicit length */
+mrb_load_file_cxt(mrb, fp, cxt);             /* file + context */
+mrb_load_detect_file_cxt(mrb, fp, cxt);      /* auto-detect .mrb or .rb */
+```
+
+## Precompiled Bytecode
+
+Load `.mrb` files compiled by `mrbc`:
+
+```c
+#include <mruby/irep.h>
+
+/* From byte array (generated by mrbc -B) */
+mrb_value result = mrb_load_irep(mrb, bytecode);
+
+/* From buffer with explicit size (safer, bounds-checked) */
+mrb_value result = mrb_load_irep_buf(mrb, buf, size);
+
+/* From file */
+FILE *fp = fopen("script.mrb", "rb");
+mrb_value result = mrb_load_irep_file(mrb, fp);
+fclose(fp);
+
+/* Load without executing (returns irep for inspection) */
+mrb_irep *irep = mrb_read_irep(mrb, bytecode);
+```
+
+All `_irep` loading functions have `_cxt` variants that accept
+a compilation context.
+
+### Deployment Pattern
+
+Ahead-of-time compilation eliminates the need for the compiler gem
+at runtime:
+
+```shell
+# Compile to C array
+mrbc -Bscript_bytecode script.rb
+
+# This generates a C header with:
+# const uint8_t script_bytecode[];
+```
+
+```c
+#include "script.mrb.h"
+
+mrb_state *mrb = mrb_open_core();  /* no compiler needed */
+mrb_load_irep(mrb, script_bytecode);
+```
+
+**Important:** wrap bytecode loading in arena save/restore when
+loading multiple scripts:
+
+```c
+int ai = mrb_gc_arena_save(mrb);
+mrb_load_irep(mrb, script1);
+mrb_gc_arena_restore(mrb, ai);
+
+ai = mrb_gc_arena_save(mrb);
+mrb_load_irep(mrb, script2);
+mrb_gc_arena_restore(mrb, ai);
+```
+
+## Symbols
+
+```c
+/* Create symbol from string */
+mrb_sym sym = mrb_intern_lit(mrb, "name");         /* from literal */
+mrb_sym sym = mrb_intern_cstr(mrb, cstr);          /* from C string */
+mrb_sym sym = mrb_intern(mrb, ptr, len);           /* from pointer + length */
+
+/* Symbol to string */
+const char *name = mrb_sym_name(mrb, sym);
+mrb_int len;
+const char *name = mrb_sym_name_len(mrb, sym, &len);
+```
+
+## Instance Variables
+
+```c
+/* Get/set instance variables on an object */
+mrb_iv_get(mrb, obj, mrb_intern_lit(mrb, "@x"));
+mrb_iv_set(mrb, obj, mrb_intern_lit(mrb, "@x"), val);
+mrb_iv_defined(mrb, obj, mrb_intern_lit(mrb, "@x"));
+mrb_iv_remove(mrb, obj, mrb_intern_lit(mrb, "@x"));
+```
+
+## Global Variables
+
+```c
+mrb_gv_get(mrb, mrb_intern_lit(mrb, "$verbose"));
+mrb_gv_set(mrb, mrb_intern_lit(mrb, "$verbose"), mrb_true_value());
+```
+
+## Class Variables
+
+```c
+mrb_cv_get(mrb, klass, mrb_intern_lit(mrb, "@@count"));
+mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "@@count"), mrb_fixnum_value(0));
+```
+
+## Loading and Executing Code
+
+```c
+/* Load and execute a string (requires mruby-compiler gem) */
+mrb_value result = mrb_load_string(mrb, "1 + 2");
+
+/* Load and execute a file */
+FILE *f = fopen("script.rb", "r");
+mrb_value result = mrb_load_file(mrb, f);
+fclose(f);
+
+/* Load precompiled bytecode (no compiler needed) */
+mrb_value result = mrb_load_irep(mrb, bytecode_array);
+```
+
+## GC Arena
+
+When creating many temporary Ruby objects in C, use the GC arena to
+prevent them from being collected prematurely:
+
+```c
+int ai = mrb_gc_arena_save(mrb);
+/* create temporary objects here */
+mrb_gc_arena_restore(mrb, ai);
+```
+
+See [gc-arena-howto.md](gc-arena-howto.md) for details.
+
+## Memory Allocation
+
+```c
+void *p = mrb_malloc(mrb, size);           /* raises on failure */
+void *p = mrb_calloc(mrb, nmemb, size);    /* zero-initialized */
+void *p = mrb_realloc(mrb, ptr, size);     /* resize */
+mrb_free(mrb, p);                          /* free */
+
+/* NULL-returning variants (for custom error handling) */
+void *p = mrb_malloc_simple(mrb, size);
+void *p = mrb_realloc_simple(mrb, ptr, size);
+```
+
+## Type Conversion
+
+```c
+mrb_obj_as_string(mrb, val)      /* to_s */
+mrb_inspect(mrb, val)            /* inspect */
+mrb_any_to_s(mrb, val)           /* default to_s */
+mrb_str_to_integer(mrb, str, base, badcheck)  /* String to Integer */
+mrb_str_to_dbl(mrb, str, badcheck)            /* String to Float */
+mrb_ensure_float_type(mrb, val)               /* ensure Float */
+```
+
+## Object Comparison
+
+```c
+mrb_equal(mrb, a, b)    /* Ruby == */
+mrb_eql(mrb, a, b)      /* Ruby eql? */
+mrb_obj_eq(mrb, a, b)   /* Ruby equal? (identity) */
+mrb_cmp(mrb, a, b)      /* Ruby <=> (returns mrb_int) */
+```
+
+## Object Inspection
+
+```c
+mrb_obj_classname(mrb, obj)          /* class name as C string */
+mrb_obj_class(mrb, obj)              /* class as RClass* */
+mrb_obj_is_kind_of(mrb, obj, klass)  /* is_a? / kind_of? */
+mrb_obj_respond_to(mrb, klass, mid)  /* respond_to? */
+mrb_obj_id(obj)                      /* object_id */
+mrb_obj_freeze(mrb, obj)             /* freeze */
+mrb_obj_dup(mrb, obj)                /* dup */
+```
+
+## Compile-Time Flags
+
+When compiling C code that uses mruby, you must use the same flags as
+the library was built with. Use `mruby-config` to get them:
+
+```console
+$ build/host/bin/mruby-config --cflags    # compiler flags
+$ build/host/bin/mruby-config --ldflags   # linker flags
+$ build/host/bin/mruby-config --libs      # libraries
+```
+
+Key macros that affect ABI:
+
+| Macro             | Effect                                   |
+| ----------------- | ---------------------------------------- |
+| `MRB_NO_BOXING`   | Struct-based values (larger, debuggable) |
+| `MRB_WORD_BOXING` | Single-word values (fast, 32-bit safe)   |
+| `MRB_NAN_BOXING`  | NaN-tagged values (default on 32-bit)    |
+| `MRB_NO_FLOAT`    | Disable Float support                    |
+| `MRB_INT64`       | 64-bit integers                          |
+| `MRB_USE_FLOAT32` | 32-bit floats                            |
+
+Mismatching these between library and application causes silent
+data corruption.

doc/guides/compile.md

@@ -1,3 +1,5 @@
+<!-- summary: About the Compile -->
+
 # Compile
 
 mruby uses Rake to compile and cross-compile all libraries and
@@ -7,21 +9,22 @@ binaries.
 
 To compile mruby out of the source code you need the following tools:
 
-* C Compiler (e.g. `gcc` or `clang`)
-* Linker (e.g. `gcc` or `clang`)
-* Archive utility (e.g. `ar`)
-* Parser generator (`bison`)
-* Ruby 2.0 or later (e.g. `ruby` or `jruby`)
-
-Note that `bison` bundled with MacOS is too old to compile `mruby`.
-Try `brew install bison` and follow the instruction shown to update
-the `$PATH` to compile `mruby`. We also encourage to upgrade `ruby`
-on MacOS in similar manner.
+- C Compiler (e.g. `gcc` or `clang`)
+- Linker (e.g. `gcc` or `clang`)
+- Archive utility (e.g. `ar`)
+- Ruby 2.5 or later (e.g. `ruby` or `jruby`)
 
 Optional:
 
-* git (to update mruby source and integrate mrbgems easier)
-* C++ compiler (to use GEMs which include \*.cpp, \*.cxx, \*.cc)
+- Git (to update mruby source and integrate mrbgems easier)
+- C++ compiler (to use mrbgems which include `*.cpp`, `*.cxx`, `*.cc`)
+- Bison (to compile `mrbgems/mruby-compiler/core/parse.y`)
+- gperf (to compile `mrbgems/mruby-compiler/core/keywords`)
+
+Note that `bison` bundled with macOS is too old to compile `mruby`.
+Try `brew install bison` and follow the instruction shown to update
+the `$PATH` to compile `mruby`. We also encourage you to upgrade `ruby`
+on macOS in similar manner.
 
 ## Build
 
@@ -32,7 +35,7 @@ line on build, call `rake -v`.
 
 You can specify your own configuration file by the `MRUBY_CONFIG` environment
 variable (you can use `CONFIG` for shorthand for `MRUBY_CONFIG`). If the path
-doesn't exist, *build_config/${MRUBY_CONFIG}.rb* is used. The default
+doesn't exist, `build_config/${MRUBY_CONFIG}.rb` is used. The default
 configuration is defined in the `build_config/default.rb` file.
 
 Those build configuration files contain the build configuration of mruby, for
@@ -48,10 +51,10 @@ All tools necessary to compile mruby can be set or modified here.
 
 ## Build Configuration
 
-We wish you submit a pull-request to *build_config/**PLATFORM**.rb*, once you
+We wish you submit a pull-request to `build_config/PLATFORM.rb`, once you
 created a new configuration for a new platform.
 
-Inside of the configuration file, the following options can be
+Inside the configuration file, the following options can be
 configured based on your environment.
 
 ### Toolchains
@@ -79,7 +82,7 @@ conf.toolchain :clang
 #### Visual Studio 2010, 2012 and 2013
 
 Toolchain configuration for Visual Studio on Windows. If you use the
-[Visual Studio Command Prompt](https://msdn.microsoft.com/en-us/library/ms229859\(v=vs.110\).aspx),
+[Visual Studio Command Prompt](<https://msdn.microsoft.com/en-us/library/ms229859(v=vs.110).aspx>),
 you normally do not have to specify this manually, since it gets automatically detected by our build process.
 
 ```ruby
@@ -102,8 +105,8 @@ in `ANDROID_STANDALONE_TOOLCHAIN`.
 It is possible to select which tools should be compiled during the compilation
 process. For example,
 
-* `mruby`
-* `mirb`
+- `mruby`
+- `mirb`
 
 The configuration are done via `mrbgems`. See `Mrbgems` section.
 
@@ -116,6 +119,36 @@ set the character via `conf.file_separator`.
 conf.file_separator = '/'
 ```
 
+### Name of library directory
+
+In some environments, the `libmruby.a` file requires a different directory name than `lib`.
+You can be changed to any name by the `conf.libdir_name` accessor.
+
+```ruby
+conf.libdir_name = 'lib64'
+```
+
+Alternatively, it can be changed via the environment variable `MRUBY_SYSTEM_LIBDIR_NAME` when
+the `rake` command is run.
+
+```console
+$ export MRUBY_SYSTEM_LIBDIR_NAME=lib64
+$ rake clean all
+```
+
+NOTES:
+
+- This environment variable `MRUBY_SYSTEM_LIBDIR_NAME` does not affect `MRuby::CrossBuild`.
+  In other words, if you want to change it for `MRuby::CrossBuild`, you must set it with `MRuby::CrossBuild#libdir_name=`.
+- If you want to switch this environment variable `MRUBY_SYSTEM_LIBDIR_NAME`, you must do `rake clean`.
+
+  A bad usage example is shown below.
+
+  ```console
+  $ rake clean all
+  $ rake MRUBY_SYSTEM_LIBDIR_NAME=lib64 install
+  ```
+
 ### C Compiler
 
 Configuration of the C compiler binary, flags and include paths.
@@ -134,21 +167,21 @@ end
 
 C Compiler has header searcher to detect installed library.
 
-If you need a include path of header file use `search_header_path`:
+If you need an include path of header file use `search_header_path`:
 
 ```ruby
-# Searches ```iconv.h```.
+# Searches `iconv.h`.
 # If found it will return include path of the header file.
-# Otherwise it will return nil .
+# Otherwise it will return nil.
 fail 'iconv.h not found' unless conf.cc.search_header_path 'iconv.h'
 ```
 
-If you need a full file name of header file use `search_header`:
+If you need a full filename of header file use `search_header`:
 
 ```ruby
-# Searches ```iconv.h```.
+# Searches `iconv.h`.
 # If found it will return full path of the header file.
-# Otherwise it will return nil .
+# Otherwise it will return nil.
 iconv_h = conf.cc.search_header 'iconv.h'
 print "iconv.h found: #{iconv_h}\n"
 ```
@@ -176,7 +209,7 @@ conf.linker do |linker|
   linker.flags_before_libraries = ...
   linker.libraries = ...
   linker.flags_after_libraries = ...
-  linker.library_paths = ....
+  linker.library_paths = ...
   linker.option_library = ...
   linker.option_library_path = ...
   linker.link_options = ...
@@ -228,12 +261,9 @@ end
 
 ### Preallocated Symbols
 
-By far, preallocate symbols are highly compatible with the previous versions, so
-we expect you won't see any problem with them. But just in case you face any
-issue, you can disable preallocated symbols by specifying `conf.disable_presym`.
-
-In the build process, `mrbc` under cross compiling environment will be compiled
-with this configuration.
+Preallocated symbols are always enabled. Symbol IDs used in C source code
+(via `MRB_SYM()` etc.) are resolved to compile-time constants during the
+build process.
 
 ### Mrbgems
 
@@ -264,13 +294,13 @@ There is a `RubyGem` (gem for CRuby) named `mgem` that help you to
 manage `mrbgems`. Try `gem install mgem`. `mgem` can show you the list
 of registered `mrbgems`.
 
-See doc/mrbgems/README.md for more option about mrbgems.
+See [doc/guides/mrbgems.md](mrbgems.md) for more option about mrbgems.
 
 ### Mrbtest
 
 Configuration Mrbtest build process.
 
-If you want mrbtest.a only, You should set `conf.build_mrbtest_lib_only`
+If you want `mrbtest.a` only, You should set `conf.build_mrbtest_lib_only`
 
 ```ruby
 conf.build_mrbtest_lib_only
@@ -279,7 +309,7 @@ conf.build_mrbtest_lib_only
 ### Bintest
 
 Tests for mrbgem tools using CRuby.
-To have bintests place \*.rb scripts to `bintest/` directory of mrbgems.
+To have bintests place `*.rb` scripts to `bintest/` directory of mrbgems.
 See `mruby-bin-*/bintest/*.rb` if you need examples.
 If you want a temporary files use `tempfile` module of CRuby instead of `/tmp/`.
 
@@ -308,9 +338,9 @@ If you need to enable C++ exception explicitly add the following:
 conf.enable_cxx_exception
 ```
 
-#### C++ exception disabling.
+#### C++ exception disabling
 
-If your compiler does not support C++ and you want to ensure
+If your compiler does not support C++, and you want to ensure
 you don't use mrbgem written in C++, you can explicitly disable
 C++ exception, add following:
 
@@ -331,11 +361,11 @@ conf.enable_debug
 
 When debugging mode is enabled
 
-* Macro `MRB_DEBUG` would be defined.
-	* Which means `mrb_assert()` macro is enabled.
-* Debug information of irep would be generated by `mrbc`.
-	* Because `-g` flag would be added to `mrbc` runner.
-    * You can have better backtrace of mruby scripts with this.
+- Macro `MRB_DEBUG` would be defined.
+  - Which means `mrb_assert()` macro is enabled.
+- Debug information of irep would be generated by `mrbc`.
+  - Because `-g` flag would be added to `mrbc` runner.
+    - You can have better backtrace of mruby scripts with this.
 
 ## Cross-Compilation
 
@@ -354,12 +384,12 @@ end
 ```
 
 All configuration options of `MRuby::Build` can also be used in
-`MRuby::CrossBuild`. You can find examples under the *build_config*
+`MRuby::CrossBuild`. You can find examples under the `build_config`
 directory.
 
 ### Mrbtest in Cross-Compilation
 
-In cross compilation, you can run `mrbtest` on emulator if
+In cross compilation, you can run `mrbtest` on an emulator if
 you have it by changing configuration of test runner.
 
 ```ruby
@@ -375,49 +405,44 @@ end
 
 ## Build process
 
-During the build process the directory *build* will be created in the
+During the build process the `build` directory will be created in the
 root directory. The structure of this directory will look like this:
 
-	+- build
-	   |
-	   +-  host
-	       |
-	       +- bin          <- Binaries (mirb, mrbc and mruby)
-	       |
-	       +- lib          <- Libraries (libmruby.a and libmruby_core.a)
-	       |
-	       +- mrblib
-	       |
-	       +- src
-	       |
-	       +- test         <- mrbtest tool
-	       |
-	       +- tools
-	          |
-	          +- mirb
-	          |
-	          +- mrbc
-	          |
-	          +- mruby
+```
++- build
+    |
+    +- host
+        |
+        +- LEGAL        <- License description
+        |
+        +- bin          <- Binaries (mirb, mrbc and mruby)
+        |
+        +- lib          <- Libraries (libmruby.a and libmruby_core.a)
+        |
+        +- mrbc         <- Minimal mrbc place
+        |
+        +- mrbgems      <- Compilation result from mrbgems
+        |
+        +- mrblib       <- Compilation result from mrblib
+        |
+        +- src          <- Compilation result from C sources
+```
 
 The compilation workflow will look like this:
 
-* compile all files under *src* (object files will be stored
-in *build/host/src*)
-* generate parser grammar out of *src/parse.y* (generated
-result will be stored in *build/host/src/y.tab.c*)
-* compile  *build/host/src/y.tab.c* to  *build/host/src/y.tab.o*
-* create *build/host/lib/libmruby_core.a* out of all object files (C only)
-* create `build/host/bin/mrbc` by compiling *tools/mrbc/mrbc.c* and
-linking with *build/host/lib/libmruby_core.a*
-* create *build/host/mrblib/mrblib.c* by compiling all \*.rb files
-under *mrblib* with `build/host/bin/mrbc`
-* compile *build/host/mrblib/mrblib.c* to *build/host/mrblib/mrblib.o*
-* create *build/host/lib/libmruby.a* out of all object files (C and Ruby)
-* create `build/host/bin/mruby` by compiling *mrbgems/mruby-bin-mruby/tools/mruby/mruby.c* and
-linking with *build/host/lib/libmruby.a*
-* create `build/host/bin/mirb` by compiling *mrbgems/mruby-bin-mirb/tools/mirb/mirb.c* and
-linking with *build/host/lib/libmruby.a*
+- compile minimal `mrbc` from `src` and `mrblib` sources
+  - compile all files under `src` (object files will be stored in `build/host/mrbc/src`)
+  - compile `mruby-compiler` gem
+  - create `build/host/mrbc/lib/libmruby_core.a` out of all object files (C only)
+  - create `build/host/mrbc/bin/mrbc` via `mruby-bin-mrbc` gem
+- compile all files under `src` and store result in `build/host/src`
+- create `build/host/mrblib/mrblib.c` by compiling all `*.rb` files under `mrblib` with `build/host/mrbc/bin/mrbc`
+- compile `build/host/mrblib/mrblib.c` to `build/host/mrblib/mrblib.o`
+- create `build/host/lib/libmruby.a` out of all object files (C and Ruby)
+- compile (normal) mrbgems specified in the configuration file
+- create `build/host/lib/libmruby.a` from object files from gems and `libmruby_core.a`
+- create binary commands according to binary gems (e.g. `mirb` and `mruby`)
+- copy binaries under `build/host/bin` to `bin` directory
 
 ```
  _____    _____    ______    ____    ____    _____    _____    ____
@@ -428,74 +453,54 @@ linking with *build/host/lib/libmruby.a*
 
 ### Cross-Compilation
 
-In case of a cross-compilation to *i386* the *build* directory structure looks
+In case of a cross-compilation to `i386` the `build` directory structure looks
 like this:
 
-	+- build
-	   |
-	   +-  host
-	   |   |
-	   |   +- bin           <- Native Binaries
-	   |   |
-	   |   +- lib           <- Native Libraries
-	   |   |
-	   |   +- mrblib
-	   |   |
-	   |   +- src
-	   |   |
-	   |   +- test          <- Native mrbtest tool
-	   |   |
-	   |   +- tools
-	   |      |
-	   |      +- mirb
-	   |      |
-	   |      +- mrbc
-	   |      |
-	   |      +- mruby
-	   +- i386
-	      |
-	      +- bin            <- Cross-compiled Binaries
-	      |
-	      +- lib            <- Cross-compiled Libraries
-	      |
-	      +- mrblib
-	      |
-	      +- src
-	      |
-	      +- test           <- Cross-compiled mrbtest tool
-	      |
-	      +- tools
-	         |
-	         +- mirb
-	         |
-	         +- mrbc
-	         |
-	         +- mruby
+```
++- build
+    |
+    +- host
+    |   |
+    |   +- bin           <- Native Binaries
+    |   |
+    |   +- lib           <- Native Libraries
+    |   |
+    |   +- mrbgems
+    |   |
+    |   +- src
+    |
+    +- i386
+        |
+        +- bin            <- Cross-compiled Binaries
+        |
+        +- include        <- Header Directory
+        |
+        +- lib            <- Cross-compiled Libraries
+        |
+        +- mrbgems
+        |
+        +- mrblib
+        |
+        +- src
+```
 
 An extra directory is created for the target platform. In case you
-compile for *i386* a directory called *i386* is created under the
+compile for `i386` a directory called `i386` is created under the
 build directory.
 
 The cross compilation workflow starts in the same way as the normal
-compilation by compiling all *native* libraries and binaries.
-Afterwards the cross compilation process proceeds like this:
+compilation by compiling all _native_ libraries and binaries, except
+for we don't have `host/mrbc` directory (`host` directory itself works
+as placeholder for `mrbc`). Afterwards the cross compilation process
+proceeds like this:
 
-* cross-compile all files under *src* (object files will be stored
-in *build/i386/src*)
-* generate parser grammar out of *src/parse.y* (generated
-result will be stored in *build/i386/src/y.tab.c*)
-* cross-compile *build/i386/src/y.tab.c* to *build/i386/src/y.tab.o*
-* create *build/i386/mrblib/mrblib.c* by compiling all \*.rb files
-under *mrblib* with the native `build/host/bin/mrbc`
-* cross-compile *build/host/mrblib/mrblib.c* to *build/host/mrblib/mrblib.o*
-* create *build/i386/lib/libmruby.a* out of all object files (C and Ruby)
-* create `build/i386/bin/mruby` by cross-compiling *mrbgems/mruby-bin-mruby/tools/mruby/mruby.c* and
-linking with *build/i386/lib/libmruby.a*
-* create `build/i386/bin/mirb` by cross-compiling *mrbgems/mruby-bin-mirb/tools/mirb/mirb.c* and
-linking with *build/i386/lib/libmruby.a*
-* create *build/i386/lib/libmruby_core.a* out of all object files (C only)
-* create `build/i386/bin/mrbc` by cross-compiling *tools/mrbc/mrbc.c* and
-linking with *build/i386/lib/libmruby_core.a*
+- cross-compile all files under `src` and store result in `build/i386/src`
+- create `build/i386/lib/libmruby_core.a` out of C object files
+- create `build/i386/mrblib/mrblib.c` by compiling all `*.rb` files under `mrblib` with native `build/host/bin/mrbc`
+- cross-compile `build/i386/mrblib/mrblib.c` to `build/i386/mrblib/mrblib.o`
+- create `build/i386/lib/libmruby.a` from object files from gems and `libmruby_core.a`
+- create binary commands according to binary gems (e.g. `mirb` and `mruby`)
+- copy binaries under `build/host/bin` to `bin` directory
 
 ```
  _______________________________________________________________
@@ -526,24 +531,22 @@ feature due to the reason that there are functions (e.g. stdio) which
 can't be disabled for the main build.
 
 ```ruby
-MRuby::CrossBuild.new('Minimal') do |conf|
-  toolchain :gcc
-
-  conf.cc.defines = %w(MRB_NO_STDIO)
-  conf.bins = []
+MRuby::CrossBuild.new('minimal') do |conf|
+  conf.toolchain :gcc
+  conf.cc.defines << 'MRB_NO_STDIO'
 end
 ```
 
-This configuration defines a cross compile build called 'Minimal' which
+This configuration defines a cross compile build called 'minimal' which
 is using the GCC and compiles for the host machine. It also disables
-all usages of stdio and doesn't compile any binaries (e.g. mrbc).
+all usages of stdio and doesn't compile any binaries (e.g. `mrbc`).
 
 ## Test Environment
 
 mruby's build process includes a test environment. In case you start the testing
 of mruby, a native binary called `mrbtest` will be generated and executed.
-This binary contains all test cases which are defined under *test/t*. In case
-of a cross-compilation an additional cross-compiled *mrbtest* binary is
+This binary contains all test cases which are defined under `test/t`. In case
+of a cross-compilation an additional cross-compiled `mrbtest` binary is
 generated. You can copy this binary and run on your target system.
 
 ## Embedding `mruby` in Your Application
@@ -553,22 +556,25 @@ After the build, you will get `libmruby.a`. You can link it to your application.
 For compiler options and library path, you can use `mruby-config` command for
 convenience. `mruby-config` command prints the configuration used for `libmruby.a`.
 
-```
+```console
 $ mruby-config --help
 Usage: mruby-config [switches]
   switches:
+  --cc                        print compiler name
   --cflags                    print flags passed to compiler
+  --ld                        print linker name
   --ldflags                   print flags passed to linker
   --ldflags-before-libs       print flags passed to linker before linked libraries
   --libs                      print linked libraries
   --libmruby-path             print libmruby path
+  --help                      print this help
 ```
 
 For example, when you have a C source file (`c.c`) and try to
 compile and link it with `libmruby.a`, you can run the following command,
 
 ```
-gcc `mruby-config --cflags` c.c `mruby-config --ldflags` `mruby-config --libs`
+`mruby-config --cc --cflags` c.c `mruby-config --ldflags --libs`
 ```
 
 When you use `make`, add following lines in `Makefile`
@@ -579,3 +585,84 @@ CFLAGS = `$(MRB_CONFIG) --cflags`
 LDFLAGS = `$(MRB_CONFIG) --ldflags`
 LIBS = `$(MRB_CONFIG) --libs`
 ```
+
+## Install
+
+To install the files in the `bin`, `include` and `lib` directories generated by the "host" build target into a system directory, do the following:
+
+```console
+$ rake install
+```
+
+If there are multiple build targets in the build configuration file, to install the products of all build targets, do the following:
+
+```console
+$ rake install:full
+```
+
+To install only one of several build targets, e.g., the "its-mine" build target, do the following:
+
+```console
+$ rake install:full:its-mine
+```
+
+To install only the executable files, do the following:
+
+```console
+$ rake install_bin              # only "host" build target
+$ rake install:bin              # all build targets
+$ rake install:bin:its-mine     # only "its-mine" build target
+```
+
+### Installation Directory
+
+The installation directory is `/usr/local` for the "host" build target and `/usr/local/mruby/<build-name>` for the others.
+To change them, you can set the environment variable `PREFIX` or use `MRuby::Build#install_prefix = dir` in your build configuration file.
+
+The `PREFIX` environment variable affects all build targets and changes the `/usr/local` part.
+
+The `MRuby::Build#install_prefix` can be set for each individual build target.
+In this case, the environment variable `PREFIX` is ignored.
+
+Also, if the environment variable `DESTDIR` is set, it will prepend to the path obtained by `install_prefix` to determine the final write directory.
+This is intended for temporary file expansion by the user's package work.
+
+---
+
+To summarize:
+
+- The default value of the environment variable `PREFIX` is `/usr/local`.
+- For the "host" build target, the default value of `MRuby::Build#install_prefix` is `<PREFIX>`.
+- For a build target other than "host", the default value of `MRuby::Build#install_prefix` is `<PREFIX>/mruby/<build-name>`.
+- If the environment variable `DESTDIR` is set, the actual write directory is `<DESTDIR>/<MRuby::Build#install_prefix>`.
+
+### Excluded files
+
+In some cases there are files that you do not want to install.
+In such cases, add a file path filter to the array object `MRuby::Build#install_excludes` to exclude them.
+
+The following is an object that can be defined as a file path filter.
+The `path` variable that appears is a relative path based on `MRuby::Build#build_dir`.
+
+- string objects: files matched by `string.match?(path)` are excluded.
+- regexp object: files matched by `regexp.match?(path)` are excluded.
+- proc object: files which return true with `proc.call(path)` are excluded.
+
+```ruby
+# exclude bin/mrbc
+conf.install_excludes << exefile("bin/mrbc")
+
+# exclude all files under lib/ directory
+conf.install_excludes << %r(^lib/)
+
+# exclude bin/mrbtest, but in this case it is recommended to use string instead of proc
+conf.install_excludes << proc { |path|
+  path == exefile("bin/mrbtest")
+}
+```
+
+By default, it contains only a proc object to exclude `libmruby_core`.
+
+## Tips
+
+- If you see compilation troubles, try `rake clean` first.

doc/guides/debugger.md

@@ -1,3 +1,5 @@
+<!-- summary: About the Debugger with the `mrdb` Command -->
+
 # How to Use the mruby Debugger
 
 copyright (c) 2014 Specified Non-Profit Corporation mruby Forum
@@ -38,7 +40,7 @@ To confirm mrdb was installed properly, run mrdb with the `--version` option:
 
 ```bash
 $ mrdb --version
-mruby 2.1.2 (2020-08-06)
+mruby 3.4.0 (2025-04-20)
 ```
 
 ## 2.2 Basic Operation
@@ -50,7 +52,7 @@ To invoke the mruby debugger, just type `mrdb`.
 To specify the script file:
 
 ```bash
-$ mrdb [option] file name
+$ mrdb [option] filename
 ```
 
 For example: Debugging sample.rb
@@ -61,20 +63,20 @@ $ mrdb sample.rb
 
 You can execute the shell commands listed below:
 
-|command|description|
-|:-:|:--|
-|run|execute programs|
-|step|execute stepping|
-|continue|execute continuing program|
-|break|configure the breaking point|
-|delete|deleting the breaking points|
-|disable|disabling the breaking points|
-|enable|enabling the breaking points|
-|info breakpoints|showing list of the breaking points|
-|print|evaluating and printing the values of the mruby expressions in the script|
-|list|displaying the source cords|
-|help|showing help|
-|quit|terminating the mruby debugger|
+|     command      | description                                                               |
+| :--------------: | :------------------------------------------------------------------------ |
+|       run        | execute programs                                                          |
+|       step       | execute stepping                                                          |
+|     continue     | execute continuing program                                                |
+|      break       | configure the breaking point                                              |
+|      delete      | deleting the breaking points                                              |
+|     disable      | disabling the breaking points                                             |
+|      enable      | enabling the breaking points                                              |
+| info breakpoints | showing list of the breaking points                                       |
+|      print       | evaluating and printing the values of the mruby expressions in the script |
+|       list       | displaying the source cords                                               |
+|       help       | showing help                                                              |
+|       quit       | terminating the mruby debugger                                            |
 
 ### 2.2.2 Debugging mruby Binary Files (mrb file) with mrdb
 
@@ -82,8 +84,8 @@ You can debug the mruby binary files.
 
 #### 2.2.2.1 Debugging the binary files
 
-* notice
-To debug mruby binary files, you need to compile mruby files with option `-g`.
+- notice
+  To debug mruby binary files, you need to compile mruby files with option `-g`.
 
 ```bash
 $ mrbc -g sample.rb
@@ -114,12 +116,12 @@ b [class:]method
 The breakpoint will be ordered in serial from 1.
 The number, which was given to the deleted breakpoint, will never be given to another breakpoint again.
 
-You can give multiple breakpoints to specified the line number and method.
-Be ware that breakpoint command will not check the validity of the class name and method name.
+You can give multiple breakpoints to the specified the line number and method.
+Be aware that the breakpoint command will not check the validity of the class name and method name.
 
 You can get the current breakpoint information by the following options.
 
-breakpoint breakpoint number : file name. line number
+breakpoint breakpoint number : filename. line number
 
 breakpoint breakpoint number : [class name,] method name
 
@@ -165,7 +167,7 @@ Example:
 (foo.rb:1) delete
 ```
 
-This will delete all of the breakpoints.
+This will delete all the breakpoints.
 
 ```
 (foo.rb:1) delete 1 3
@@ -192,7 +194,7 @@ Example:
 (foo.rb:1) disable
 ```
 
-Use `disable` if you would like to disable all of the breakpoints.
+Use `disable` if you would like to disable all the breakpoints.
 
 ```
 (foo.rb:1) disable 1 3
@@ -265,7 +267,7 @@ Example:
 ```
 (sample.rb:1) info breakpoints
 Num     Type           Enb What
-1       breakpoint     y   at sample.rb:3                      -> file name,line number
+1       breakpoint     y   at sample.rb:3                      -> filename,line number
 2       breakpoint     n   in Sample_class:sample_class_method -> [class:]method name
 3       breakpoint     y   in sample_global_method
 ```
@@ -299,11 +301,11 @@ When you do not specify both the `first` and `last` options, you will receive th
 Example:
 
 ```
-Specifying file name and first row number
+Specifying filename and first row number
 sample.rb:1) list sample2.rb:5
 ```
 
-Specifying the file name and the first and last row number:
+Specifying the filename and the first and last row number:
 
 ```
 (sample.rb:1) list sample2.rb:6,7
@@ -324,7 +326,7 @@ expr: expression
 
 The expression is mandatory.
 The displayed expressions will be serially ordered from 1.
-If an exception occurs, the exception information will be displayed and the debugging will be continued.
+If an exception occurs, the exception information will be displayed, and the debugging will be continued.
 
 Example:
 
@@ -367,5 +369,5 @@ r
 #### Step Command
 
 This will run the program step by step.
-When the method and the block are invoked, the program will be stop at the first row.
+When the method and the block are invoked, the program will stop at the first row.
 The program, which is developed in C, will be ignored.