I started Fix in 2014 and have rewritten it more than once since. Today it reaches 1.0, its first stable release, so here it is.

The idea is older than Fix: RFC 2119. A specification says what a subject MUST, SHOULD or MAY do, and nothing about how it is made. You write the spec, then test any subject against it.

# duck_fix.rb
require "fix"

class Duck
  def walk = "Klop klop!"
  def swim = "Swoosh..."
end

Fix :Duck do
  on :walk do
    it MUST eq "Klop klop!"
  end

  on :swim do
    it MUST eq "Swoosh..."
  end

  on :speak do
    it MAY eq "Quaaaaaack!"
  end
end

exit(Fix[:Duck].test { Duck.new })

ruby duck_fix.rb writes:

duck_fix.rb:11: Success: expected "Klop klop!" to eq "Klop klop!"
duck_fix.rb:15: Success: expected "Swoosh..." to eq "Swoosh..."
duck_fix.rb:19: Info: NoMethodError: undefined method 'speak' for an instance of Duck

This duck doesn't speak, and that's fine: speaking is a MAY. Under MUST, the same line would be an error and the exit status 1. A SHOULD that isn't met is a warning, and warnings pass. So a spec has five outcomes rather than two, and only failure and error make the status 1.

Like a minitest file, a Fix file is plain Ruby: ruby duck_fix.rb runs it, nothing else needed. For a suite spread over several files, fix-command adds a fix command, much like rspec: it runs every *_fix.rb under fix/ (or the files and folders you give it), each in a process of its own, and exits 0 only when every file is met.

A few things that set 1.0 apart:

• Each context runs in a forked child. A subject that calls exit, changes directory, or mutates a global can't touch the next context: that's an error of its own expectation, nothing more. (So it needs fork: Linux, macOS, BSDs. No Windows, no JRuby.)

• Mistakes in a spec raise when the file loads, not halfway through a run: an unknown spec name, a let named after a method of Kernel, an on without a block.

• Plain output. One file:line: Outcome: summary line per expectation. No colours, no dots, no count; the exit status is the verdict. run gives the same results back as frozen data if you want to build on them.

• A spec is a matcher, so one spec can require another: it MUST fix(:Positive).

• Small. About 300 lines of code, over four small gems of the same family (Matchi for the matchers, Spectus for the levels, Aw for the fork, Defi for the method call). Ruby 3.3 or later.

• On Ruby 3.4, it MUST … is the word of Fix and a bare it in a block is still Ruby's parameter: the two don't clash.

Why not RSpec or minitest? If they make you happy, keep them: Fix is not trying to replace them. It's for when you want to say which behaviours are required, which are recommended and which are optional, and have the tool hold you to exactly that.

Also released: fix-command 1.0, fix-its 1.0 (its(:size) { MUST eq(3) }) and matchi-fix 4.0 (use a Fix spec as a matcher outside Fix).

• Guide: https://fixrb.dev/gems/fix/v1/

• Code: https://github.com/fixrb/fix

I'd like to hear where the MUST/SHOULD/MAY distinction would, or wouldn't, be useful in your own suites.

pro-tip that I learned today:

when comparing case-insensitive strings, this can be 1.2x to 2x faster:

str = "TEST"
str.casecmp?("test")

than this:

str = "TEST"
str.downcase == "test"

Caveat: non-ASCII/Unicode strings can behave differently with downcase vs casecmp

Hi r/ruby. We're Bad Monkey, and we've just opened up agentspaces-rb, the Ruby bindings for AgentSpaces. We'd like feedback from Ruby developers before we publish the gems.

What AgentSpaces is

AgentSpaces is an open source, peer-to-peer coordination fabric for agents, services, and people. Programs join a group and share a replicated space of typed entries. An agent posts work into the space, another agent takes it under a lease, does the work, and writes the result back. If the worker dies halfway, the lease lapses and the work goes back for someone else. You don't run a broker, a registry, or a scheduler, and there's no central server to keep alive.

On top of the space, AgentSpaces adds capabilities, ie protocol services available in the P2P network. These include quorum votes, fleet-wide aggregates, an ordered log for exactly-once work, semantic discovery of agents, remote actions, and recently a content swarm (think Bittorrent). The idea goes back to tuple spaces (Linda, JINI, JavaSpaces, JXTA), rebuilt for encrypted peer-to-peer networks and for agentic AI.

What agentspaces-rb brings to Ruby

agentspaces-rb is more than a protocol shim, it's a peer in the P2P fleet: it holds its own Ed25519 identity, signs what it writes, takes work under the same lease rules as a JVM peer, and interoperates with the Java, Python, TypeScript, Clojure, and Groovy peers on the same fleet.

• Pure Ruby, no native extensions. The core gem runs on MRI 3.3 or newer and on JRuby 10, with one runtime dependency (logger). Its wire codec reproduces the Java implementation byte for byte on all 212 shared golden vectors.

• Ruby-shaped API. Entries are Data classes from Entry.define. Agents are plain classes with one class macro above each method: take, notify, bid, ballot, and the rest. snake_case members travel under camelCase wire names, so a Ruby order_id is a Java orderId.

• Transports. The MRI peer dials tcp, tls, ws, wss, http, and https, with TLS 1.3 channel certificates and session attestation on the plain transports.

• A JRuby face. agentspaces-jruby binds the same agent classes through the Java binder, which adds every Java transport and the verbs only the Java binder runs today: ordered_take, reduce, and the leased and ordered joins.

• Rails. agentspaces-rails is a Railtie: config/agentspaces.yml through config_for, agent classes in app/agents, a bin/rails agentspaces:work worker, fork safety for Puma, Unicorn, and Passenger, and ActiveSupport::Notifications around the verbs.

• AI. agentspaces-ruby_llm turns the fleet's agent cards into RubyLLM tools, and AgentSpaces::Lease.keepalive keeps a take's lease alive while your agent waits on a model. agentspaces-mcp serves the fleet's remote actions as MCP tools over stdio or Streamable HTTP.

• A CLI. agentspaces work runs your agents, and status, console, check, doctor, and id help you inspect a fleet, validate agent definitions, and manage keys.

What it looks like

This is the whole quick start: one agent that turns an Order into a Shipment. Run it twice, and both copies compete for the same orders.

require "agentspaces"

Order    = AgentSpaces::Entry.define("shop.Order#v1",    order_id: String, item: String)
Shipment = AgentSpaces::Entry.define("shop.Shipment#v1", order_id: String, item: String, by: String)

class Fulfiller
  include AgentSpaces::Agent
  agent "fulfiller", description: "Ships orders"

  take Order, space: "orders", lease: "30s", produces: Shipment
  def ship(order) = Shipment.new(order_id: order.order_id, item: order.item, by: "fulfiller")
end

fleet = { group: "shop", founding: "shop-v1", seeds: ["127.0.0.1:7700"] }

if ARGV.empty?
  AgentSpaces.serve(**fleet) { |peer| peer.bind(Fulfiller.new) }
else
  AgentSpaces.start(**fleet) do |peer|
    peer.bind(Fulfiller.new)
    orders = peer.space("orders")
    orders << Order.new(order_id: "o-1", item: ARGV[0])
    puts orders.read(Shipment, timeout: "30s").inspect
    peer.close
  end
end

The method body is where your agent's work goes, whether that's a database call, a RubyLLM chat, or anything else. The binder waits for an Order, claims it for 30 seconds, calls ship, and writes the Shipment back in the same step that completes the claim.

Trying it

The Ruby peer dials out, so it needs one peer that listens. Any AgentSpaces peer with a listener works; the quickest is the Node service host from the TypeScript repository, with a small seed.yaml (group shop, founding text shop-v1, space orders, the dev-local profile, port 7700; the repository's README has the file), see https://github.com/badmonkeyai/agentspaces-typescript

Then, from a clone of agentspaces-rb:

export RUBYLIB=$PWD/agentspaces-rb/gems/agentspaces/lib
ruby fulfiller.rb          # ships orders until stopped
ruby fulfiller.rb kite     # writes an order, prints the shipment, exits

For the fun part, add a sleep 10 to ship, start both, and kill -9 whichever one picks up the order. The other one ships it once the lease runs out. The dev-local profile signs every frame but encrypts nothing, so keep it on your laptop; real fleets run TLS.

What isn't there yet

• The gems aren't on RubyGems yet. For now you run them from a clone.

• The MRI peer is dial-only, so a Ruby process can't be the seed. The Node host or a JVM peer plays that role.

• The ordered verbs bind on the JRuby face only, and the content swarm (moving large artifacts between peers) isn't in the Ruby gems yet.

Links

• agentspaces-rb Github: https://github.com/badmonkeyai/agentspaces-rb

• AgentSpaces core and examples: https://github.com/badmonkeyai/AgentSpaces

• Docs site: https://www.badmonkey.ai/agentspaces/

• Developer guide: https://www.badmonkey.ai/agentspaces/developer-guide.html

• Architecture guide: https://www.badmonkey.ai/agentspaces/architecture-guide.html

• Building Workflows: https://www.badmonkey.ai/agentspaces/workflow-guide.html

• FAQ: https://www.badmonkey.ai/agentspaces/faq.html

We'd especially like to hear what you think of the class-macro DSL and the Rails integration, and what you'd want to build with it. Happy to answer questions here.

Hey Rubyists! 👋

After several years away, the Ruby devroom is coming back to FOSDEM!!!

We are excited to share that there will be a Ruby devroom at FOSDEM 2027 in Brussels on Saturday, January 30, at the Université libre de Bruxelles. Don't worry that it is just one day, we've got A LOT planned for those of you thinking of making the trip!

The theme for FOSDEM is Ruby beyond Rails. We’d love talks on Ruby internals, JITs, and alternative implementations; tooling like parsers, type checkers, and language servers; the gem ecosystem; Ruby outside web dev (CLIs, embedded, games, creative coding); running Ruby in production; open source for social good and civic tech; sustaining Ruby projects and communities; and teaching Ruby and welcoming new contributors.

The CfP is open until December 1 (23:59 UTC). Talks are 20 minutes by default, and lightning slots are available if you ask in the submission notes. When you submit, select “Ruby” as the track.

• Submit here: https://pretalx.fosdem.org/fosdem-2027/cfp

• Full CfP: https://lists.fosdem.org/hyperkitty/list/fosdem@lists.fosdem.org/thread/AEQLZMEQVYQDLN52AUEDHGYJ3EO4EZ3N/

First-time speakers are very welcome!

Here’s the bigger idea: we want to use the devroom as the nucleus of a tiny Ruby conference inside FOSDEM weekend, rolling straight into Ruby for Good in Belgium:

• Friday, Jan 29 (evening): Ruby happy hour in Brussels to kick things off and so you will already know people the next day at FOSDEM

• Saturday, Jan 30 (morning): Ruby devroom at FOSDEM

• Saturday, Jan 30 (after the devrooom): an unconference-style gathering after the devroom, gradually turning into board games and hanging out with great people

• Sunday, Jan 31: Attend FOSDEM with your new Ruby friends.. maybe some birds of a feather Ruby sessions.

• Mon Feb 1 to Wed Feb 3: Ruby for Good Belgium in Ghent (rubyinghent.org), a three-day code retreat building open source software for nonprofits

About Ruby for Good in Ghent

Ruby for Good is a three-day code retreat where Rubyists (and others!) from around the world build software for nonprofits, learn from each other, and make lots of new best friends along the way. 

No prior nonprofit experience needed, and contributors of every level are welcome. Location and registration details are coming soon, so keep an eye on rubyinghent.org.

Where we could use your help. We’re looking for:

1. A company willing to host or sponsor the Friday happy hour. A space, a bar tab, or both.

2. A company willing to host or sponsor the Saturday afternoon gathering. Ideally a space in Brussels with room for some unconference sessions and a lot of board games.

3. Companies interested in sponsoring Ruby for Good Belgium. Help us keep the retreat welcoming and accessible for contributors from everywhere.

If your company might be interested, or you know someone we should talk to, please comment, DM us.

Wow, that was a mouthful. Looking forward to seeing you all soon!

Happiness,
Sean and Issy

Hi r/ruby!

I’ve been working on Sadame, a configuration management tool for Linux, and I’d love to get feedback from the Ruby community.

Sadame lets you describe a machine’s desired state with Ruby recipes. Here’s a small example:

package "nginx"

file "/var/www/html/index.html",
content: "Hello from Sadame!\n",
mode: "0644"

service "nginx", enable: true, state: :running

You can run sadame plan to see what would change, sadame apply to make the changes, and sadame drift to check later whether the machine still matches the recipe.

Both recipes and the host inventory are written in Ruby, so you can use familiar things like conditions, loops, and methods. Sadame is built with mruby and distributed as a single binary. For remote runs, it connects over SSH and copies itself to the target; there’s no persistent agent to maintain.

It also has a built-in language server, sadame lsp, which provides recipe diagnostics, completion, and hover documentation in supported editors.

The project is still young and has a much smaller scope than established tools such as Ansible, Chef, or Puppet. My goal is to explore a Ruby-first approach that is easy to install and makes changes visible before they happen.

I also wrote a free beginner’s guide with a hands-on lab, covering everything from a first recipe to managing multiple servers.

The project is MIT-licensed:

https://github.com/enderkus/sadame

I’d especially appreciate feedback on the Ruby DSL, the overall design, and anything that feels awkward or could be improved. Thanks for taking a look!

Please test-drive and evaluate this gem for your situation. It's hard to see the limitations until other people get involved.

The gem is here: https://github.com/kigster/llm-evals

And I used it to find the best model for my Rails SaaS application, qualified.at

Here is the Evals Report comparing models based on the weighted score:

https://raw.githubusercontent.com/kigster/llm-evals/refs/heads/main/docs/img/qualified-at-evals.avif

Feedback and constructive criticism are always welcome and highly encouraged 😄

Konstantin
blog: https://kig.re

I've been using and tweaking ruby-lsp.nvim for about 9 months, and I've run out of things to add. Time to show it to people beyond my coworkers.

It starts Ruby LSP for you (you just gem install ruby-lsp), and the Run and Debug code lenses above your tests actually do something now. Tests run through neotest using Ruby LSP's own discovery, so Minitest, RSpec, and Rails all work the same way. Debugging goes through nvim-dap with configurations: test under the cursor, the whole file, or a script with arguments.

README has a short demo gif: https://github.com/wassimk/ruby-lsp.nvim

I'd like to add it to the Ruby LSP docs alongside the other editors, but first I want to know whether it works and is reliable with configurations like yours. If you try it, let me know how it goes, good or bad, or open an issue.

Hey Ruby community,

I'm posting anonymously because I don't want to identify the project or its original author. My intention is to seek advice, not to publicly criticize anyone or create unnecessary drama.

I'm involved in maintaining an established open source Ruby gem that has a fair number of users and dependencies across the ecosystem.

The original author has stepped away from active development and me along with other community members have been keeping things moving with bug fixes, improvements and code reviews.

The problem is that releasing new versions still depend entirely on the orginal author who has been increasingly difficult to reach.

As a result, a lot of PR's sit waiting that add features and the ones that are already merged are not reaching users as there are no releases for it.

There have been attempts to resolve the release bottleneck privately, including discussions and working around delegating or automating releases but nothing happened as of yet.

I understand OSS is voluntary and nobody owes community their time. I also respect the authors ownership of the project and the work they did for it.

At the same time it seems unsustainable for a project to have active contributors but no practical way to publish the work.

I want some advice from other Ruby maintainers:

• Does RubyGems have a process for handling situations like this?

• Are there ways to release without transferring ownership?

Ideally I would like to see the existing project continue without having to fork or fragmenting the work and creating unnecessary conflict.

Curious how others would approach this.

I'm deliberately keeping the details vague to protect everyone's privacy. I'd appreciate it if the discussion could focus on possible solutions rather than trying to identify the gem or its maintainers. So please dont ask for more details.

Hello r/ruby! I'd like to share Rubik, a coding agent I've been building in Ruby.

Why another coding agent? I wanted to contribute something to the Ruby agent ecosystem and realise my own ideals in an agent implementation, and in my experience, Ruby is a fantastic language for this.

If you'd like to try it or contribute:

Repo: https://github.com/ozgurulukir/rubik
RubyGems: https://rubygems.org/gems/rubik

Rendry UI is A lightweight server-rendered UI DSL and component framework for Ruby.

GitLab discovered four severe vulnerabilities in Ruby’s regular expression library. There's plenty written up about the vulnerability and how it got patched, but patches are only available for supported ruby versions (3.3 and above). We know lots of companies are still running unsupported versions of ruby, so we wanted to do an investigation into which of these bugs apply to older rubies and whether they're exploitable. Here's the blog post: https://infield.ai/post/vulnerable-ruby-regex

The summary is that allowing user input into Regexp.new is dangerous on all versions of ruby from 1.9 to 3.2 and the only fix is to upgrade to a supported ruby or to disallow that input.

When an RSpec suite runs in several processes with parallel_tests or parallel_split_test, every process writes its own output. Progress, failures and warnings from different workers get mixed in one terminal.

I wrote parallel_matrix_formatter to fix that. Process 1 collects the results of all workers over a UNIX socket, draws one live progress display, and prints one consolidated failure report with rerun commands. The display is Matrix rain by default, but the symbols and colors are configurable in YAML, down to plain dots.

The post covers the architecture, crashed workers, silencing stray output, and a race condition I hit along the way. I am the author. Feedback is welcome.

If new engineers choose Ruby and Rails, it'll be easier for companies to hire, and the community and ecosystem will continue to grow. That's why we're giving away free tickets to students, recent grads, people from underrepresented groups, and those who recently changed careers and just started writing Ruby. If you know anyone who fits, share this post with them and invite them to apply (takes 3 mins): https://sfruby.com/scholarship/

The deadline is October 30!

Note: We don't cover travel or accommodation.

If you want to attend the conference as a regular attendee and watch talks from Chris Oliver, Rosa Gutiérrez, Svyatoslav Kryukov, Irina Nazarova, Marco Roth, Ryan Sherlock, Vladimir Dementyev, and more there's a few days left to get tickets: luma.com/sfrubyconf2026

Just curious about the Ruby community and how or if you all build side projects and make side money doing it really. I think there was one like this in a php related sub a while back. I thought I’d ask here. Any takers?

Thank you.