diff --git a/tools/build_rules/ruby.bzl b/tools/build_rules/ruby.bzl
new file mode 100644
index 0000000..7c02745
--- /dev/null
+++ b/tools/build_rules/ruby.bzl
@@ -0,0 +1,93 @@
+ZIP_PATH = '/usr/bin/zip'
+
+ruby_file_types = FileType(['.rb'])
+
+def _collect_transitive_sources(ctx):
+  source_files = set(order='compile')
+  for dep in ctx.attr.deps:
+    source_files += dep.transitive_ruby_files
+
+  source_files += ruby_file_types.filter(ctx.files.srcs)
+  return source_files
+
+def _ruby_library_impl(ctx):
+  transitive_sources = _collect_transitive_sources(ctx)
+  return struct(
+    transitive_ruby_files = transitive_sources,
+  )
+
+def _ruby_binary_impl(ctx):
+  main_file = ctx.files.srcs[0]
+  transitive_sources = _collect_transitive_sources(ctx)
+  executable = ctx.outputs.executable
+  manifest_file = ctx.outputs.manifest
+
+  path_map = '\n'.join([('%s|%s' % (item.short_path, item.path))
+                        for item in transitive_sources])
+  ctx.file_action(output=manifest_file, content=path_map)
+
+  ctx.action(
+    inputs = list(transitive_sources) + [manifest_file],
+    outputs = [ executable ],
+    arguments = [ manifest_file.path, executable.path, main_file.path ],
+    executable = ctx.executable._ruby_linker,
+  )
+
+  return struct(
+    files = set([executable]),
+    runfiles = ctx.runfiles(collect_data = True),
+  )
+
+
+_ruby_attrs = {
+  'srcs': attr.label_list(
+    allow_files = ruby_file_types,
+    mandatory = True,
+    non_empty = True,
+  ),
+  'deps': attr.label_list(
+    providers = ['transitive_ruby_files'],
+    allow_files = False,
+  ),
+  'data': attr.label_list(
+    allow_files = True,
+    cfg = DATA_CFG,
+  ),
+}
+
+'''Packages ruby code into a library.
+
+The files can use require with paths from the base of the workspace and/or
+require_relative with other files that are part of the library.
+require also works from the filesystem as usual.
+
+Attrs:
+  srcs: Ruby source files to include.
+  deps: Other ruby_library rules to include.
+'''
+ruby_library = rule(
+  implementation = _ruby_library_impl,
+  attrs = _ruby_attrs,
+)
+
+'''Packages ruby code into a binary which can be run.
+
+See ruby_library for details on how require works.
+
+Attrs:
+  srcs: Ruby source files to include. The first one is loaded to at startup.
+  deps: ruby_library rules to include.
+'''
+ruby_binary = rule(
+  implementation = _ruby_binary_impl,
+  executable = True,
+  attrs = _ruby_attrs + {
+    '_ruby_linker': attr.label(
+      executable = True,
+      default = Label('//tools/ruby:standalone_ruby'),
+    )
+  },
+  outputs = {
+    'manifest': '%{name}.tar_manifest',
+  },
+)
diff --git a/tools/ruby/BUILD b/tools/ruby/BUILD
new file mode 100644
index 0000000..426a9f1
--- /dev/null
+++ b/tools/ruby/BUILD
@@ -0,0 +1,5 @@
+py_binary(
+  name = 'standalone_ruby',
+  srcs = ['standalone_ruby.py'],
+  visibility = ['//visibility:public'],
+)
diff --git a/tools/ruby/standalone_ruby.py b/tools/ruby/standalone_ruby.py
new file mode 100644
index 0000000..0c574e0
--- /dev/null
+++ b/tools/ruby/standalone_ruby.py
@@ -0,0 +1,75 @@
+#!/usr/bin/python
+
+import zlib, sys, os, stat
+
+with file(sys.argv[2], "wb+") as outf:
+  outf.write("""#!/usr/bin/env ruby
+require "zlib"
+
+def zip_file_binding()
+  binding()
+end
+
+module Kernel
+  class ZipRequireRecord
+    attr_accessor :fname, :val
+    def initialize(fname, val)
+      @fname = fname
+      @val = val
+    end
+    def do_require()
+      return false if !@val
+      eval(@val, binding = zip_file_binding(), filename="//@bazel/" + @fname)
+      @val = nil
+      return true
+    end
+  end
+  BAZEL_START_ENTRY = "/@bazel/"
+  ZIP_TEMP_OBJS = {}
+  def require_relative(relative_feature)
+    file = caller.first.split(/:\d/,2).first
+    raise LoadError, "require_relative is called in #{$1}" if /\A\((.*)\)/ =~ file
+    require File.expand_path(relative_feature, File.dirname(file))
+  end
+  def require_zip(moduleName)
+    if moduleName.start_with?(BAZEL_START_ENTRY)
+      moduleName = moduleName[BAZEL_START_ENTRY.length..-1]
+    end
+    zip_obj = ZIP_TEMP_OBJS[moduleName]
+    if not zip_obj and !moduleName.end_with?('.rb')
+      zip_obj = ZIP_TEMP_OBJS[moduleName + '.rb']
+    end
+    return zip_obj.do_require() if (zip_obj)
+    return pre_zip_load_require(moduleName)
+  end
+  alias :pre_zip_load_require :require
+  alias :require :require_zip
+  def init_app(main_fname)
+    $0 = "//@bazel/" + main_fname
+    Kernel.require_zip(main_fname)
+  end
+  def register_inline_file(fname, data)
+    raise if ZIP_TEMP_OBJS.has_key?(fname)
+    ZIP_TEMP_OBJS[fname] = Kernel::ZipRequireRecord.new(fname, data.force_encoding("UTF-8"))
+  end
+end
+
+my_data = Zlib.inflate(DATA.read())
+""")
+
+  blob_data = []
+  offset = 0
+  with file(sys.argv[1], 'r') as infile:
+    for line in infile.xreadlines():
+      file_outname, file_binname = line.strip().split('|')
+      with file(file_binname, 'r') as obj_file:
+        obj = obj_file.read()
+      blob_data.append(obj)
+      new_off = offset + len(obj)
+      outf.write("Kernel.register_inline_file(%s, my_data.slice(%s...%s))\n" %
+                 (repr(file_outname), offset, new_off))
+      offset = new_off
+
+  outf.write("Kernel.init_app(%s)\n" % repr(sys.argv[3]))
+  outf.write("__END__\n")
+  outf.write(zlib.compress("".join(blob_data)))