mruby Gems: Extending Ruby for Embedded Systems

March 11, 2026

Most developers associate Ruby with web development. Frameworks like Ruby on Rails helped Ruby become one of the most productive languages for building web applications. However, Ruby is not limited to servers or web frameworks.

Ruby can also run in places far away from data centers: inside embedded systems, firmware, and native applications.

This is exactly the goal of mruby — a lightweight, embeddable implementation of Ruby designed to run in constrained environments while still providing the expressiveness and elegance of the Ruby language.

What is mruby?

mruby is a minimal Ruby interpreter written in C and designed to be embedded inside other software.

Unlike the standard Ruby implementation, mruby is:

• lightweight
• modular
• easily embeddable
• configurable at compile time

Because of this design, mruby is commonly used in environments such as:

• game engines
• firmware
• IoT devices
• embedded dashboards
• scripting engines inside native applications

Instead of running as a standalone language runtime, mruby often acts as a scripting layer embedded inside larger systems.

mrbgems: Extensions for mruby

The standard Ruby ecosystem uses RubyGems to distribute libraries.

mruby uses a similar concept called mrbgems.

An mrbgem is a module that becomes part of the interpreter during compilation. Instead of installing libraries dynamically, the gem is compiled directly into the mruby runtime.

This design provides several advantages for embedded environments:

• predictable memory usage
• no runtime dependency management
• better control of the final binary size

A typical mrbgem has a very simple structure:

mrbgems/mruby-example
├── include/
├── src/
├── mrbgem.rake
└── gem_init.c 

The mrbgem.rake file defines the gem and integrates it into the build system.

Example:

MRuby::Gem::Specification.new('mruby-example') do |spec|
  spec.license = 'MIT'
  spec.authors = 'Germán Silva'
end 

Initialization Hooks

Each mrbgem must define two initialization functions written in C.

These functions allow the gem to register classes, modules, and methods inside the Ruby runtime.

Example:

#include <mruby.h>
void mrb_mruby_example_gem_init(mrb_state *mrb)
{
  /* initialization code */
}
void mrb_mruby_example_gem_final(mrb_state *mrb)
{
} 

The naming convention is important. mruby expects these functions to follow a specific pattern based on the gem name.

This mechanism makes it straightforward to expose C libraries as Ruby APIs.

Wrapping C Libraries

One of the most powerful features of mruby is how easy it is to integrate existing C libraries.

Many mature libraries already exist in C. With a small binding layer, these libraries can become accessible from Ruby code running inside mruby.

This approach allows developers to combine:

• the performance of C
• the expressiveness of Ruby
• the portability of a small embedded interpreter

Experiment: Building mruby-gd

As an experiment, I started working on a binding for libgd, a classic C graphics library used for generating images.

The idea is to create a gem called mruby-gd, allowing image generation directly from mruby scripts.

If successful, it would enable something like this:

img = GD::Image.new(200,200)
img.line(10,10,100,100)
img.save("test.png")

While simple, this kind of capability can be extremely useful in embedded systems.

Why Image Generation in Embedded Ruby?

Generating images from scripts opens interesting possibilities for embedded applications:

• dynamic dashboards on devices
• IoT visualization tools
• lightweight report generation
• graphical debugging tools
• map rendering or data visualization

Instead of implementing complex rendering logic entirely in C, developers can script behavior in Ruby while keeping performance-critical components in native code.

Ruby Beyond the Server

Ruby is often seen as a language for web applications. However, projects like mruby demonstrate that Ruby can also thrive in environments far removed from servers.

With a small interpreter and a flexible extension system, Ruby becomes a powerful scripting layer for embedded software.

And thanks to mrbgems, integrating existing C libraries into Ruby becomes surprisingly straightforward.

For developers interested in embedded systems, scripting engines, or extending Ruby beyond the traditional ecosystem, mruby offers a fascinating platform to explore.