webvas 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5741995c39bcdce271bdf34cf96cc377d48cfb43abc9705d8beb6f2b49345034
+  data.tar.gz: 77fee6bec1cafd49ff8fb62b65ca00afeff04e618986b73977b375b13d652ad7
+SHA512:
+  metadata.gz: 7b98cc6279a621f860e0bde96266c11c54913e5331d0a80f4a880ae17caf3b277bd3699dbf5c34913a4376efc792b05b1793ec152933438d4d2a6819789a21cd
+  data.tar.gz: cf95c627be83f6525fd9a5205ffd253367cb06fc6aed829e9d1f056b1bad192c6a41f983e145f71c18b7d494faf6cc38adf10df0b95752eeb53192e2be6485f5

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## [0.1.0] - 2026-09-25
+
+Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+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.

data/README.md

@@ -0,0 +1,97 @@
+<div align="center">
+
+# Webvas
+
+**Run RBGL sketches in a browser with Ruby.**
+
+Webvas connects RBGL's software renderer to an `OffscreenCanvas` and drives one frame at a time with `requestAnimationFrame`.
+
+[Live example](https://rbgfx.github.io/webvas/) · [Ruby API](#ruby-api) · [Browser requirements](#browser-requirements)
+
+</div>
+
+## Features
+
+- RBGL browser backend for RGBA frames and pointer, keyboard, and wheel events
+- Frame scheduling through `RBGL::GUI::Window#step`
+- Standalone loader for `<script type="text/ruby" data-webvas>`
+- Runtime published with the example site; no local WebAssembly build is needed to use it
+
+## Install
+
+Add Webvas to the Ruby bundle used to prepare your WebAssembly runtime:
+
+~~~ruby
+gem "webvas"
+~~~
+
+The browser runtime must also include `rbgl` and its dependencies. When using the runtime distributed with the Webvas example, no local build is required.
+
+## Quick start
+
+Add a canvas, a Ruby script, and the loader to an HTML page:
+
+~~~html
+<canvas id="screen" width="320" height="240"></canvas>
+<script type="text/ruby" data-webvas>
+  require "rbgl"
+  require "webvas"
+
+  window = RBGL::GUI::Window.new(
+    width: 320,
+    height: 240,
+    backend: Webvas::Backend.new(width: 320, height: 240)
+  )
+
+  Webvas.run(window) do |context, _delta_time|
+    context.clear
+    # Bind an RBGL pipeline and draw here.
+  end
+</script>
+<script src="https://rbgfx.github.io/webvas/loader.js"></script>
+~~~
+
+The loader reads `assets/webvas.wasm` beside itself by default. Set `data-runtime` on the loader script to use another HTTPS or same-origin runtime URL. Set `data-canvas` on the Ruby script and use the same selector in `Webvas::Backend` when the canvas is not `#screen`.
+
+## Ruby API
+
+Create an `RBGL::GUI::Window` with a `Webvas::Backend`, then pass it to `Webvas.run`. The callback receives the RBGL context and elapsed seconds. `Webvas.run` reuses one callback for each animation frame and closes the window when it stops or raises an exception.
+
+`Webvas::Backend` accepts `width`, `height`, `canvas`, `title`, and `pixelated`. The canvas size sets the rendering resolution; CSS can scale its display size. With `pixelated: true`, scaled output uses nearest-neighbor display.
+
+Pointer coordinates are mapped from the canvas display bounds to rendering pixels. Pointer buttons, keyboard keys, modifier keys, and wheel deltas are converted to RBGL events. Focus the canvas to send keyboard events.
+
+## Browser requirements
+
+- WebAssembly, module workers, and `OffscreenCanvas`
+- A secure context when loading the page over the network
+- A Ruby runtime built with Webvas, RBGL, and RBGL's dependencies
+
+Ruby runs in a worker without access to the page DOM. The `js` gem exposes APIs available to that worker, so this worker should not be treated as a security sandbox for hostile code. The page's Content Security Policy must allow the worker, runtime URL, and WebAssembly compilation.
+
+Blocking frame loops and `sleep` cannot drive animation in the browser. Use `Webvas.run` to advance the window one frame at a time. WebAssembly threads and compiling native extensions in the browser are not supported.
+
+Ruby source is limited to 32 KiB. Frame pixels use base64 between Ruby and JavaScript; a 320×240 RGBA frame is 307,200 bytes before encoding and 409,600 bytes after encoding.
+
+## Development
+
+The repository expects adjacent checkouts of `larb`, `rbgl`, and `tessel`.
+
+~~~sh
+bundle install
+BUNDLE_GEMFILE=runtime/Gemfile bundle install
+BUNDLE_GEMFILE=runtime/Gemfile bundle exec rbwasm build \
+  --ruby-version 4.0 --target wasm32-unknown-wasip1 \
+  --build-profile full --patch "$(pwd)/patches/psych-wasi.patch" -o build/webvas.wasm
+ruby script/build_site
+bundle exec rake verify
+npm ci
+npx playwright install chromium
+npm run test:browser
+~~~
+
+The Pages workflow builds the WebAssembly runtime, checks the browser loader in Chromium, and deploys the static example.
+
+## License
+
+MIT. See [LICENSE.txt](LICENSE.txt).

data/js/bridge.js

@@ -0,0 +1,72 @@
+(() => {
+  let nextId = 1;
+  const canvases = new Map();
+  const pendingEvents = [];
+  const eventLimit = 2048;
+
+  function queue(handle, event) {
+    if (handle.events.length === eventLimit) handle.events.shift();
+    handle.events.push(event);
+  }
+
+  globalThis.WebvasBridge = {
+    attach(selector, width, height, pixelated) {
+      const canvas = globalThis.WebvasCanvases[selector];
+      if (!(canvas instanceof OffscreenCanvas)) throw new Error("Canvas not found: " + selector);
+      canvas.width = width;
+      canvas.height = height;
+      const context = canvas.getContext("2d", { alpha: false });
+      if (!context) throw new Error("Canvas 2D is unavailable");
+      const handle = { id: nextId++, canvas, context, events: pendingEvents.splice(0) };
+      globalThis.postMessage({ type: "webvas:pixelated", selector, enabled: pixelated });
+      canvases.set(handle.id, handle);
+      return handle.id;
+    },
+
+    present(id, encoded, width, height) {
+      const handle = canvases.get(id);
+      if (!handle) throw new Error("Canvas backend is closed");
+      const { canvas, context } = handle;
+      if (canvas.width !== width || canvas.height !== height) {
+        canvas.width = width;
+        canvas.height = height;
+      }
+      const binary = atob(encoded);
+      if (binary.length !== width * height * 4) throw new Error("RGBA frame size mismatch");
+      const pixels = new Uint8ClampedArray(binary.length);
+      for (let index = 0; index < binary.length; index += 1) pixels[index] = binary.charCodeAt(index);
+      context.putImageData(new ImageData(pixels, width, height), 0, 0);
+      return true;
+    },
+
+    events(id) {
+      const handle = canvases.get(id);
+      return JSON.stringify(handle ? handle.events.splice(0) : []);
+    },
+
+    pushEvent(event) {
+      if (!canvases.size) {
+        if (pendingEvents.length === eventLimit) pendingEvents.shift();
+        pendingEvents.push(event);
+        return;
+      }
+      for (const handle of canvases.values()) queue(handle, event);
+    },
+
+    resize(id, width, height) {
+      const handle = canvases.get(id);
+      if (!handle) return false;
+      handle.canvas.width = width;
+      handle.canvas.height = height;
+      return true;
+    },
+
+    close(id) {
+      canvases.delete(id);
+    },
+
+    showError(message, backtrace) {
+      globalThis.postMessage({ type: "webvas:error", message, backtrace });
+    }
+  };
+})();

data/js/loader.js

@@ -0,0 +1,86 @@
+(() => {
+  const loader = document.currentScript;
+  if (!loader) return;
+
+  const base = new URL(".", loader.src);
+  const runtimeUrl = loader.dataset.runtime || new URL("./assets/webvas.wasm", base).href;
+  const workerUrl = new URL("./worker.js", base).href;
+  const bridgeUrl = new URL("./bridge.js", base).href;
+
+  async function run(sourceElement) {
+    const selector = sourceElement.dataset.canvas || "#screen";
+    const canvas = document.querySelector(selector);
+    if (!(canvas instanceof HTMLCanvasElement)) throw new Error(`Canvas not found: ${selector}`);
+    if (new TextEncoder().encode(sourceElement.textContent).length > 32768) throw new Error("Ruby source exceeds 32 KB.");
+
+    const status = document.createElement("output");
+    status.setAttribute("role", "status");
+    status.setAttribute("aria-live", "polite");
+    canvas.insertAdjacentElement("afterend", status);
+    const report = message => { status.textContent = message; };
+    report("Loading Ruby runtime…");
+    if (canvas.tabIndex < 0) canvas.tabIndex = 0;
+
+    const response = await fetch(workerUrl, { credentials: "omit" });
+    if (!response.ok) throw new Error(`Worker download failed: ${response.status}`);
+    const workerBlobUrl = URL.createObjectURL(new Blob([await response.text()], { type: "text/javascript" }));
+    const worker = new Worker(workerBlobUrl, { type: "module", name: "webvas" });
+    worker.addEventListener("message", event => {
+      const message = event.data || {};
+      if (message.type === "webvas:loading") report(message.message || "Loading Ruby runtime…");
+      else if (message.type === "webvas:ready") {
+        URL.revokeObjectURL(workerBlobUrl);
+        worker.postMessage({ type: "webvas:run", source: sourceElement.textContent });
+      } else if (message.type === "webvas:started") report("Ruby sketch is running");
+      else if (message.type === "webvas:error") report([message.message, message.backtrace].filter(Boolean).join("\n"));
+      else if (message.type === "webvas:pixelated" && message.selector === selector) {
+        canvas.style.imageRendering = message.enabled ? "pixelated" : "auto";
+      }
+    });
+    worker.addEventListener("error", event => {
+      URL.revokeObjectURL(workerBlobUrl);
+      report(event.message || "Webvas worker failed");
+    });
+
+    const forward = event => {
+      if (event.type === "wheel") event.preventDefault();
+      if (event.type === "keydown" && event.code === "Space") event.preventDefault();
+      if (event.type === "pointerdown") {
+        canvas.focus({ preventScroll: true });
+        canvas.setPointerCapture(event.pointerId);
+      }
+      const rect = canvas.getBoundingClientRect();
+      worker.postMessage({
+        type: "webvas:input",
+        event: {
+          type: event.type === "pointercancel" ? "pointerup" : event.type,
+          clientX: event.clientX || 0, clientY: event.clientY || 0,
+          left: rect.left, top: rect.top, rectWidth: rect.width, rectHeight: rect.height,
+          button: event.button, deltaX: event.deltaX, deltaY: event.deltaY,
+          code: event.code, key: event.key, shiftKey: event.shiftKey,
+          ctrlKey: event.ctrlKey, altKey: event.altKey, metaKey: event.metaKey
+        }
+      });
+    };
+    for (const type of ["pointerdown", "pointerup", "pointermove", "pointercancel", "keydown", "keyup", "wheel"]) {
+      canvas.addEventListener(type, forward, type === "wheel" ? { passive: false } : undefined);
+    }
+
+    const offscreen = canvas.transferControlToOffscreen();
+    worker.postMessage({
+      type: "webvas:init", canvas: offscreen, selector,
+      bridgeUrl, wasmUrl: new URL(runtimeUrl, document.baseURI).href
+    }, [offscreen]);
+  }
+
+  const start = () => document.querySelectorAll('script[type="text/ruby"][data-webvas]').forEach(element => {
+    run(element).catch(error => {
+      const status = document.createElement("output");
+      status.setAttribute("role", "alert");
+      status.textContent = error.message || String(error);
+      element.insertAdjacentElement("afterend", status);
+    });
+  });
+  if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", start, { once: true });
+  else start();
+})();

data/js/worker.js

@@ -0,0 +1,47 @@
+let vm;
+let busy = false;
+const pendingEvents = [];
+
+globalThis.window = {
+  requestAnimationFrame(callback) {
+    return setTimeout(() => callback(performance.now()), 1000 / 60);
+  }
+};
+globalThis.requestAnimationFrame ||= callback => globalThis.window.requestAnimationFrame(callback);
+
+function send(type, payload = {}) {
+  globalThis.postMessage({ type: "webvas:" + type, ...payload });
+}
+
+globalThis.addEventListener("message", async event => {
+  const message = event.data;
+  try {
+    if (message?.type === "webvas:init") {
+      await import(message.bridgeUrl);
+      globalThis.WebvasCanvases = { [message.selector]: message.canvas };
+      pendingEvents.splice(0).forEach(input => globalThis.WebvasBridge.pushEvent(input));
+      send("loading", { message: "Downloading the Ruby drawing machine…" });
+      const { DefaultRubyVM } = await import("https://cdn.jsdelivr.net/npm/@ruby/wasm-wasi@2.10.1/dist/browser/+esm");
+      const response = await fetch(message.wasmUrl, { credentials: "omit" });
+      if (!response.ok) throw new Error("Ruby runtime download failed: " + response.status);
+      const module = await WebAssembly.compile(await response.arrayBuffer());
+      send("loading", { message: "Starting Ruby and graphics libraries…" });
+      ({ vm } = await DefaultRubyVM(module));
+      send("ready");
+    } else if (message?.type === "webvas:input") {
+      if (globalThis.WebvasBridge) globalThis.WebvasBridge.pushEvent(message.event);
+      else if (pendingEvents.length < 2048) pendingEvents.push(message.event);
+    } else if (message?.type === "webvas:run" && vm && !busy && typeof message.source === "string") {
+      if (new TextEncoder().encode(message.source).length > 32768) throw new Error("Source exceeds 32 KB.");
+      busy = true;
+      vm.eval(message.source);
+      send("started");
+      busy = false;
+    }
+  } catch (error) {
+    busy = false;
+    send("error", { message: error.message || String(error), backtrace: error.stack || "" });
+  }
+});
+
+globalThis.addEventListener("error", event => send("error", { message: event.message || "Worker error" }));

data/lib/webvas/backend.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Webvas
+  class Backend < RBGL::GUI::Backend
+    def initialize(width:, height:, canvas: "#screen", title: "Webvas", pixelated: false, bridge: Bridge.new)
+      super(width, height, title)
+      @bridge = bridge
+      @handle = @bridge.attach(canvas, width, height, pixelated:)
+      @pending_pixels = nil
+      @closed = false
+    end
+
+    def present(framebuffer)
+      bytes, width, height = @pending_pixels || [framebuffer.to_rgba_bytes, framebuffer.width, framebuffer.height]
+      @pending_pixels = nil
+      @bridge.present(@handle, bytes, width, height)
+    end
+
+    def set_pixels(buffer, width, height)
+      width = Integer(width)
+      height = Integer(height)
+      bytes = validate_rgba_buffer(buffer, width, height)
+      resize(width, height) if [width, height] != [@width, @height]
+      @pending_pixels = [bytes, width, height]
+      true
+    end
+
+    def resize(width, height)
+      width = Integer(width)
+      height = Integer(height)
+      raise ArgumentError, "canvas size must be positive" unless width.positive? && height.positive?
+
+      super
+      @bridge.resize(@handle, width, height)
+    end
+
+    def poll_events
+      Input.translate(@bridge.events(@handle), width: @width, height: @height)
+    end
+
+    def poll_events_raw
+      poll_events.map(&:to_h)
+    end
+
+    def should_close?
+      @closed
+    end
+
+    def close
+      return if @closed
+
+      @closed = true
+      @bridge.close(@handle)
+    end
+  end
+end

data/lib/webvas/bridge.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "base64"
+require "json"
+
+module Webvas
+  class Bridge
+    def initialize(api: nil)
+      require "js" unless api
+      @api = api || JS.global[:WebvasBridge]
+    end
+
+    def attach(selector, width, height, pixelated:)
+      @api.attach(selector, width, height, pixelated)
+    end
+
+    def present(handle, bytes, width, height)
+      @api.present(handle, Base64.strict_encode64(bytes), width, height)
+    end
+
+    def events(handle)
+      JSON.parse(@api.events(handle).to_s)
+    end
+
+    def resize(handle, width, height)
+      @api.resize(handle, width, height)
+    end
+
+    def close(handle)
+      @api.close(handle)
+    end
+
+    def request_animation_frame(callback)
+      JS.global[:window].requestAnimationFrame(callback)
+    end
+
+    def show_error(message, backtrace)
+      @api.showError(String(message), Array(backtrace).join("\n"))
+    end
+  end
+end

data/lib/webvas/input.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Webvas
+  module Input
+    MODIFIERS = { "shiftKey" => :shift, "ctrlKey" => :control, "altKey" => :alt, "metaKey" => :meta }.freeze
+    BUTTONS = { 0 => 1, 1 => 2, 2 => 3 }.freeze
+
+    module_function
+
+    def translate(events, width:, height:)
+      events.filter_map { |event| convert(event, width:, height:) }
+    end
+
+    def convert(event, width:, height:)
+      case type = event.fetch("type")
+      when "pointerdown", "pointerup", "pointermove"
+        x, y = coordinates(event, width:, height:)
+        name = { "pointerdown" => :mouse_press, "pointerup" => :mouse_release, "pointermove" => :mouse_move }.fetch(type)
+        data = { x:, y:, modifiers: modifiers(event) }
+        data[:button] = BUTTONS.fetch(event.fetch("button", 0), event.fetch("button", 0)) unless type == "pointermove"
+        RBGL::GUI::Event.new(name, **data)
+      when "keydown", "keyup"
+        name = type == "keydown" ? :key_press : :key_release
+        key = KeyMap.call(event.fetch("code", ""), event["key"])
+        RBGL::GUI::Event.new(name, key:, keycode: event["code"], char: printable(event["key"]), modifiers: modifiers(event))
+      when "wheel"
+        RBGL::GUI::Event.new(:scroll, dx: event.fetch("deltaX", 0), dy: event.fetch("deltaY", 0), modifiers: modifiers(event))
+      end
+    end
+
+    def coordinates(event, width:, height:)
+      width = Integer(width)
+      height = Integer(height)
+      raise ArgumentError, "canvas size must be positive" unless width.positive? && height.positive?
+
+      rect_width = Float(event.fetch("rectWidth"))
+      rect_height = Float(event.fetch("rectHeight"))
+      return [0, 0] unless rect_width.positive? && rect_height.positive?
+
+      x = ((Float(event.fetch("clientX")) - Float(event.fetch("left"))) * width / rect_width).floor
+      y = ((Float(event.fetch("clientY")) - Float(event.fetch("top"))) * height / rect_height).floor
+      [x.clamp(0, width - 1), y.clamp(0, height - 1)]
+    end
+
+    def modifiers(event)
+      MODIFIERS.filter_map { |key, value| value if event[key] }
+    end
+
+    def printable(key)
+      key if key.is_a?(String) && key.length == 1
+    end
+  end
+end

data/lib/webvas/key_map.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Webvas
+  module KeyMap
+    DIGITS = %i[zero one two three four five six seven eight nine].freeze
+    SPECIAL = {
+      "ArrowLeft" => :left, "ArrowRight" => :right, "ArrowUp" => :up, "ArrowDown" => :down,
+      "Backspace" => :backspace, "Delete" => :delete, "Enter" => :enter, "Escape" => :escape,
+      "Home" => :home, "End" => :end, "PageUp" => :page_up, "PageDown" => :page_down,
+      "Tab" => :tab, "Space" => :space, "ShiftLeft" => :left_shift, "ShiftRight" => :right_shift,
+      "ControlLeft" => :left_control, "ControlRight" => :right_control,
+      "AltLeft" => :left_alt, "AltRight" => :right_alt, "MetaLeft" => :left_meta, "MetaRight" => :right_meta,
+      "Minus" => :minus, "Equal" => :equal, "BracketLeft" => :left_bracket,
+      "BracketRight" => :right_bracket, "Backslash" => :backslash, "Semicolon" => :semicolon,
+      "Quote" => :quote, "Comma" => :comma, "Period" => :period, "Slash" => :slash, "Backquote" => :grave
+    }.freeze
+
+    module_function
+
+    def call(code, key = nil)
+      code = String(code)
+      return SPECIAL.fetch(code) if SPECIAL.key?(code)
+      return key.downcase.to_sym if code.start_with?("Key") && key.to_s.length == 1
+      return DIGITS.fetch(code.delete_prefix("Digit").to_i) if code.match?(/\ADigit[0-9]\z/)
+      return code.downcase.to_sym if code.match?(/\AF\d{1,2}\z/)
+
+      key.to_s.length == 1 ? key.downcase.to_sym : code.downcase.to_sym
+    end
+  end
+end

data/lib/webvas/runner.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Webvas
+  class Scheduler
+    def initialize(bridge: Bridge.new)
+      @bridge = bridge
+    end
+
+    def request_animation_frame(callback)
+      @bridge.request_animation_frame(callback)
+    end
+  end
+end

data/lib/webvas/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Webvas
+  VERSION = "0.1.0"
+end

data/lib/webvas.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "webvas/version"
+require "rbgl"
+require_relative "webvas/bridge"
+require_relative "webvas/backend"
+require_relative "webvas/input"
+require_relative "webvas/key_map"
+require_relative "webvas/runner"
+
+module Webvas
+  class Error < StandardError; end
+
+  def self.run(window, scheduler: nil, on_error: nil, &frame_callback)
+    raise ArgumentError, "a frame callback is required" unless frame_callback
+
+    scheduler ||= Scheduler.new
+    callback = nil
+    callback = proc do |timestamp|
+      begin
+        if !window.should_close? && window.step(Float(timestamp) / 1000, &frame_callback) && !window.should_close?
+          scheduler.request_animation_frame(callback)
+        else
+          window.close
+        end
+      rescue StandardError => error
+        window.close
+        (on_error || method(:report_error)).call(error)
+      end
+    end
+    scheduler.request_animation_frame(callback)
+    callback
+  end
+
+  def self.report_error(error)
+    Bridge.new.show_error(error.message, error.backtrace || [])
+  end
+
+end

data/sig/rbgl.rbs

@@ -0,0 +1,47 @@
+module RBGL
+  module Engine
+    class Framebuffer
+      attr_reader width: Integer
+      attr_reader height: Integer
+      def to_rgba_bytes: () -> String
+    end
+
+    class Context
+    end
+  end
+
+  module GUI
+    class Event
+      attr_reader type: Symbol
+      def initialize: (Symbol, **untyped) -> void
+      def []: (Symbol | String key) -> untyped
+      def to_h: () -> Hash[Symbol, untyped]
+    end
+
+    class Backend
+      attr_reader width: Integer
+      attr_reader height: Integer
+      attr_reader title: String
+      def initialize: (Integer width, Integer height, ?String title, **untyped) -> void
+      def present: (RBGL::Engine::Framebuffer framebuffer) -> untyped
+      def poll_events: () -> Array[RBGL::GUI::Event]
+      def poll_events_raw: () -> Array[Hash[Symbol, untyped]]
+      def resize: (Integer width, Integer height) -> void
+      def set_pixels: (String buffer, Integer width, Integer height) -> untyped
+      def should_close?: () -> bool
+      def close: () -> void
+    end
+
+    class Window
+      attr_reader context: RBGL::Engine::Context
+      attr_reader backend: RBGL::GUI::Backend
+      def initialize: (width: Integer, height: Integer, ?title: String, ?backend: Symbol | RBGL::GUI::Backend, **untyped) -> void
+      def on: (Symbol event_type) { (RBGL::GUI::Event) -> void } -> void
+      def step: (?Float now) { (RBGL::Engine::Context, Float) -> void } -> bool
+      def stop: () -> void
+      def set_pixels: (String buffer) -> untyped
+      def should_close?: () -> bool
+      def close: () -> void
+    end
+  end
+end

data/sig/webvas.rbs

@@ -0,0 +1,48 @@
+module Webvas
+  VERSION: String
+
+  class Error < StandardError
+  end
+
+  class Bridge
+    def initialize: (?api: untyped) -> void
+    def attach: (String selector, Integer width, Integer height, pixelated: bool) -> untyped
+    def present: (untyped handle, String bytes, Integer width, Integer height) -> untyped
+    def events: (untyped handle) -> Array[Hash[String, untyped]]
+    def resize: (untyped handle, Integer width, Integer height) -> untyped
+    def close: (untyped handle) -> untyped
+    def request_animation_frame: (Proc callback) -> untyped
+    def show_error: (String message, Array[String] backtrace) -> untyped
+  end
+
+  class Backend < RBGL::GUI::Backend
+    def initialize: (width: Integer, height: Integer, ?canvas: String, ?title: String, ?pixelated: bool, ?bridge: Bridge) -> void
+    def present: (RBGL::Engine::Framebuffer framebuffer) -> untyped
+    def set_pixels: (String buffer, Integer width, Integer height) -> bool
+    def resize: (Integer width, Integer height) -> untyped
+    def poll_events: () -> Array[RBGL::GUI::Event]
+    def poll_events_raw: () -> Array[Hash[Symbol, untyped]]
+    def should_close?: () -> bool
+    def close: () -> void
+  end
+
+  module Input
+    def self.translate: (Array[Hash[String, untyped]] events, width: Integer, height: Integer) -> Array[RBGL::GUI::Event]
+    def self.convert: (Hash[String, untyped] event, width: Integer, height: Integer) -> RBGL::GUI::Event?
+    def self.coordinates: (Hash[String, untyped] event, width: Integer, height: Integer) -> [Integer, Integer]
+    def self.modifiers: (Hash[String, untyped] event) -> Array[Symbol]
+    def self.printable: (untyped key) -> String?
+  end
+
+  module KeyMap
+    def self.call: (String code, ?untyped key) -> Symbol
+  end
+
+  class Scheduler
+    def initialize: (?bridge: Bridge) -> void
+    def request_animation_frame: (Proc callback) -> untyped
+  end
+
+  def self.run: (RBGL::GUI::Window window, ?scheduler: Scheduler, ?on_error: Proc) { (RBGL::Engine::Context, Float) -> void } -> Proc
+  def self.report_error: (StandardError error) -> untyped
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: webvas
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rbgl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rbs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+description: An RBGL canvas backend and browser loader powered by ruby.wasm.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- js/bridge.js
+- js/loader.js
+- js/worker.js
+- lib/webvas.rb
+- lib/webvas/backend.rb
+- lib/webvas/bridge.rb
+- lib/webvas/input.rb
+- lib/webvas/key_map.rb
+- lib/webvas/runner.rb
+- lib/webvas/version.rb
+- sig/rbgl.rbs
+- sig/webvas.rbs
+homepage: https://github.com/rbgfx/webvas
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/rbgfx/webvas
+  source_code_uri: https://github.com/rbgfx/webvas/tree/main
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Run Ruby graphics in the browser
+test_files: []