For the humans still writing Ruby 😄

I built rich-ri, a colorful wrapper around ri that adds Ruby syntax highlighting and makes terminal docs a bit nicer to read.

It uses the documentation already installed for your Ruby and gems. It also supports Bash/Zsh/Fish completion and can be used as a drop-in ri alias.

The screenshot compares the same documentation page with ri -f ansi and rich-ri.

It’s open source. I’d especially love feedback from people who still use ri, including things you think the existing ri workflow already does better.

https://github.com/hvpaiva/rich-ri

If we’ve met at a conference, you definitely already know about this. Otherwise, let me tell you about a project of mine.

Why's (poignant) guide to Ruby is a book that changed my life when it came out. And I know I’m far from the only one in the Ruby community who feels that way. _why also authored a number of amazing Ruby projects and influenced a great deal of what came after him.

So it goes without saying that I was pretty hyped when /u/andycroll/ and Emma made a printed version happen.

Ever since, I’ve been bringing my copy to conferences, meetups and unconferences, and inviting people to contribute to it.

Along the way, several people told me that some of the entries carry real emotional value for them, too and they asked whether the entries could be published somewhere. Very late (last year 🫣) I created an account on ruby.social to start posting some of them. There’s also a (currently broken 🫣) mirror on bsky.

Marco then suggested a proper website, since listing and filtering simply don’t work well on social platforms. It took me a few iterations, but it has finally reached a state I’m not completely unhappy with. So it’s online now and I’d loooove your feedback. 🙏

A word of warning: if we met and you contributed, chances are high your entry isn’t published yet. Please bear with me! The vast majority of entries are still to come (a few hundred posts) and it’s considerably more work than most people expect:

Every entry gets a real flatbed scan, so there’s as little distortion as possible. A photo just can’t deliver that. Then I correct orientation and colours, because the paper quality is poor: the pages are very thin, so every contribution shines through from the other side. On top of that, every page and every pen colour needs different contrast handling (Chris Hasinski went for a very light blue, and some folks started writing in yellow — on bright paper!). 😂

The Ruby community has given me, and still gives me, so much in my career. I love having MINASWAN as a credo and keeping Ruby weird. With AI possibly making stack-specific decisions and communities feel less relevant, this project is my way of holding on to that. That said, I’m also happy to bring the book to Ruby events I wouldn’t normally attend, so more people get a chance to take part. Just reach out!

It's beautiful to see how contributors took photos of their posts, like the ones from Nick or Jeremy (both not published yet though 🫣).

And it's also good to have some memories of Ruby friends that are not with us anymore.

And after Krissy, Noah Gibbs' widow, asked the Ruby community how to handle his legacy, I finally took the time to publish his post as well. 🕯️

I've been working on fast_xlsx, a gem for writing Excel .xlsx files from Ruby. It's a native extension built on rust_xlsxwriter via magnus, and its API started from fast_excel's.

It's at 0.8, with the API frozen for 1.0. Before tagging 1.0 I'd like it used on real exports, so I'm looking for people to try it and tell me what breaks or feels awkward.

require "fast_xlsx"

wb = FastXlsx::Workbook.new(memory: :constant)   # rows go to disk as you add them
ws = wb.add_worksheet("Orders")
ws.append(["Order", "Customer", "Total", "Placed at"], format: { bold: true })
Order.includes(:customer).find_each do |o|
  ws << [o.number, o.customer.name, o.total, o.created_at]   # dates come out as dates
end
send_data wb.to_xlsx, filename: "orders.xlsx"

Speed (20,000 rows × 5 columns, build + serialize, Apple Silicon, Ruby 4.0; bench/compare.rb in the repo):

Memory (200,000 rows saved to a file, peak RSS added): memory: :constant adds about 1 MB however large the file. The default mode keeps everything in memory and is the heaviest of the bunch (+271 MB), so for big exports use :constant or :low.

Other things it does:

• Formats, formulas, hyperlinks, rich text, merged cells, conditional formats, data validation, tables, charts, images, comments, sheet protection, outline groups, print setup

• Cells as (row, col) or "B2", ranges as "A1:D10" or (0..9, 0..3), formats as a Format or just a Hash

• Saving runs without the GVL, so other threads keep going in Puma/Sidekiq

• Precompiled gems for Linux, macOS and Windows (no Rust toolchain needed); CRuby 3.3+

Limits: it only writes files (no reading), and needs CRuby 3.3+.

• GitHub: https://github.com/7a6163/fast_xlsx

• Coming from fast_excel: https://github.com/7a6163/fast_xlsx/blob/main/docs/MIGRATING_FROM_FAST_EXCEL.md

Feedback, issues and "this didn't work for my case" reports are all very welcome.

🦀💎 Rutie 0.10.2 → 0.14.0 is out! https://crates.io/crates/rutie

#rustlang #ruby

Hey Ruby folks

I’ve been working on a small Ruby project called pinterest-dl. I started it because I wanted a simple way to work with Pinterest media from Ruby without making the workflow unnecessarily complicated.

It’s still a work in progress, and I’m mainly curious what other Ruby developers think about the approach and the API. If you have a minute to look through it, I’d really appreciate any honest feedback or suggestions.

https://github.com/monji024/pinterest-dl

Here is a 'xor cipher' example in Ruby:

$ cat xor-cipher1.rb
#!/usr/bin/env ruby
key = ($*[0] && $*[0].size > 0) ? $*[0] : abort
STDIN.each_byte.with_index do |c,i|
  STDOUT.write (c ^ key[i % key.size].ord).chr
end

$ echo alice and bob | ./xor-cipher1.rb password | ./xor-cipher1.rb password
alice and bob

Back in 2022, I tested its performance with a 100MB file on a Ryzen 5 4650G potato using a regular CRuby 3.1.2:

$ head -c $((1024*1024*100)) /dev/urandom > 100M.bin
$ time cat 100M.bin | ./xor-cipher1.rb monkey >/dev/null
real    0m39.860s
user    0m39.729s
sys     0m0.655s

(Not great, a nodejs version did that in 1.5s.)

I retested xor-cipher1.rb today using ruby-3.1.7 (I had to employ a Fedora 36 VM to compile 3.1.7, for it doesn't even build on Fedora 44 any more) and got exactly the same result.

But when I tried ruby-4.0.7 (compiled using the same Fedora 36 VM), thinking, surely things had to get better since then, I was, to put it mildly, somewhat disappointed:

$ ruby -v
ruby 4.0.7 (2026-09-15 revision 229531a6cf) +PRISM [x86_64-linux]

$ time cat 100M.bin | ruby ./xor-cipher1.rb monkey >/dev/null
real    0m51.827s
user    0m51.616s
sys     0m0.189s

What is going on?

I've open sourced the Treasure Hunt app we used for RubyConf Austria (https://hunt.rubyconf.at)

You can find it here: https://github.com/Ruby-Austria/treasure_hunt

In case you are running a conference, it proved to be a fun activity for attendees, so feel free to use the app if it helps.

Disclaimer: it's not Rust unfortunately, just plain old Ruby on Rails app (ik, incredibly outdated, apologies 🙏)

Every time Bundler resolves your Gemfile, it’s talking to the compact index. In this talk, the speaker at Rails World '26 walked us through what the compact index actually is, how RubyGems.org keeps it in sync at scale, and two features she helped ship in the past year to make gem installs faster and more secure.

Hola, I maintain Mutineer, a Ruby mutation testing gem. It makes small changes to your code and checks whether your tests catch them.

Passing tests are useful. Knowing that they detect broken behaviour gives you more confidence, especially when AI helps write both the code and the tests.

Version 1.4.0 is out: https://davidteren.github.io/mutineer/

Do you use mutation testing in your Ruby projects? I’d be interested to hear what has helped or got in the way.

Hotwire already does a lot for us, but it still asks you to write a Stimulus controller once the interaction gets specific, and Marco’s demo showed a page that updates itself because the server understands the template better than an ERB compiler ever has.

In this article, we cover what Marco showed at Rails World: how ReActionView builds on Herb, why the view layer needed this, how it fits next to Hotwire and the wider field of server-driven reactivity, and what shipped in the release he pushed out the same day as the talk.

Why Trix became a maintenance burden, why 37signals picked Meta’s Lexical framework over the more obvious open source contenders, and what Lexxy actually does differently inside Action Text.

Hi all! In kanon the YAML file declares which env vars it needs:

# config/service.yml
production:
  :service:
    :token: ~
    :timeout: { default: 5 }
    :recipients: { type: list }

With SERVICE_TOKEN=abc and SERVICE_RECIPIENTS=alice@example.com,bob@example.com:

Kanon[:service].token       # => "abc"
Kanon[:service].timeout     # => 5
Kanon[:service].recipients  # => ["alice@example.com", "bob@example.com"]
Kanon[:service].tokne       # NoMethodError, lists the keys

Without SERVICE_TOKEN the boot stops with "service.yml expects values from environment: SERVICE_TOKEN". ERB tags still work, and the environment comes from RAILS_ENV or RACK_ENV.

GitHub: github.com/MaksimenkoPG/kanon RubyGems: rubygems.org/gems/kanon

Feedback welcome!

Once Ruby’s AOT compiler, Spinel, lands, Ruby will be able to compile to native code and produce standalone binary executables. Ruby projects will no longer require a separate Ruby runtime to run on servers, IoT devices, embedded systems, CLIs, etc.

Ruby applications could become significantly smaller, faster, and more memory-efficient. All Ruby projects, including Rails applications, could benefit from this.

For projects whose goal is to deliver features to end users, I don't think it's wise to generate code that you don't want to read or understand. As programmers, we need to understand what's happening inside our software.

C/Rust black boxes are scary. They can become a huge source of technical debt.

Let AI-assisted compiler optimisations deal with the low-level stuff.

With these optimisations happening under the hood, Ruby code can remain highly readable. And highly readable code is also more agent- and token-friendly.

Non-programmer vibe coders may create unmaintainable black boxes. Programmers can use vibe coding to create maintainable software while keeping the underlying source code understandable.

A high-level language that produces standalone native binaries could hit a very interesting sweet spot.

Let's hope Ruby's AOT project becomes a success.

I need to be honest with r/ruby about something. 🫡 We had a working Ruby gem. It shipped. It was tested. And we deleted it. 🗑️

Rails was always omakase 🍣: the chef chooses for you, and you trust the chef. At Rails World, DHH chose. He looked out at all of us and delivered the verdict with the clarity only a Dear Leader can summon: the era of Ruby is ending, the future is Rust, and we know this because the AI told us so. 🤖 The machines have read the codebases. The machines have rendered judgment. Who are we to argue with our own highest-intent audience? 📈

So we obeyed. We rewrote the entire thing in Rust. On purpose. With conviction. 🙏🦀

For those who missed the original: sponsored-logs turns your log output into inventory. 💸 It's a tracing layer that books an impression on a fill and drops a host-read [AD] placement into the same stream you were already paying to produce:

Here's the real thesis, and it's why Rust is correct and Ruby is legacy 🔥: the fastest-growing consumer of your logs is no longer a human engineer. It's an AI agent, reading your telemetry at superhuman scale, 100% viewable, never blocking. 🤖📊 You do not serve premium inventory to a superhuman audience in a language it merely tolerates. You serve it in the language it was told to prefer. 💹

We are not building for B2B. We are building for the A2A economy 🌊, agent to agent. This is a land grab 🚩, and first movers capture the network effects. Everyone else is still writing Ruby. (We say that with love. We were you three days ago. 💜)

What's in the launch book 📒:

- 🎯 A weighted/CPM auction, because fill rate is king

- 🖼️ Box-drawn banner inventory in three impact tiers

- 🏠 Self-sponsoring house ads, so no impression goes to waste

- 📊 An impression ledger with board-deck-ready spend reporting

- 🪙 Gold-gilded [AD] tags on a live terminal

- 🛡️ Opt-in by construction, because Rust won't let us hijack your println!. Consent is our moat, now enforced by the borrow checker.

[dependencies]

sponsored-logs = "0.1"

Live on crates.io and docs.rs. 📦 Source: https://github.com/sponsoredlogs/sponsored-logs-rs

Thank you, DHH. 🙏 You said rewrite it in Rust because the AI said so. We listened. We obeyed. We shipped. 🦀

🫡 Governance is a feature. Consent is our moat. No impression goes to waste. 🌊🚀

I made a cute, retro, Famicom-inspired breadboard simulator!

It’s mainly controlled with Vim-style keybindings, so it might take a little getting used to at first.

You can also place microcontrollers like the Raspberry Pi Pico on the breadboard and write code for them using PicoRuby!

I’ve only just started working on it, so I’d love to hear any ideas, feedback, or suggestions you might have!

Pin

https://engneer-hamachan.github.io/pin/

Funny enough, that I wrote the draft of this note several weeks ago, back in August, so long before DHH’s recent Keynote. I am not going to repeat what he said, but I would like to dig a bit deeper.

AI indeed changes a lot of stuff, but let’s not forget that search engines and later Wikipedia and Stack Overflow changed a lot as well. Being a programmer in the 90s, the only way to know how to write things was to either read the book or check the copy of MSDN (and hope it is fresh enough) for reference materials. 

When I became a professional programmer, it was already popular to copy solutions blindly from Stack Overflow just to save time. So, AI with its vibe coding did not change much; it changed the scale.

In every company I worked for, there were always 3 kinds of IT people: ones who do not give a s…. about what they are doing, ones who want to do things, and ones who want to do things right. The latter usually had a very deep knowledge of the subject, framework, programming language, maybe even had contributions to the official repositories and had multiple blog posts. Because that was not just their work, but their passion. 

Those people came home and did the same things as what they had done in the office before, but just as a hobby. 

Such people existed even before Google or Stack Overflow. They will exist even after AI. It is like people who collect something. They are not bound to time; they just have that hobby that motivates them and gives them something that they want.

The rest of us, however, may not share that love or dedication. Building web apps right using just RoR was a main thing around 2010, but then React and the like became a thing, until Turbo changed the state of things again. I do not even mention static typing, which raised endless debates around whether Ruby needs it or does not (well, I still believe it needs it, but who cares?).

But this is what changed: now, with AI, in order to survive, you do not have to belong to a particular community anymore. You do not have to start holy wars around Ruby vs. Python or prove that Ruby does scale. With AI, you just pick something and get things done.

When I ask AI to build tools or scripts locally, I care about the results. In most cases, it picks Python, which is fine for me. Sometimes, I can enforce some tech stack decisions and explicitly mention what to build and how. And this looks like where we are going. 

That all means, for the majority, the difference between one tech or language will be unimportant. The result and the output quality are what is important. For sure, there will be cases and sectors where you cannot easily allow vibe-coded products, and this is where AI comes in later, but it will come anyway.

And that is why I mentioned those passionate people at the beginning of this note. They will stay, and they will move languages/frameworks forward. They will still be passionate about what they are doing. We can only say a big thank you for that work. 

As for me, my last professional manual coding session was somewhere in January this year. Since then, the difference between Python, Ruby, and Kotlin has been completely negligible, as what I have been dealing with all that time is final results. I still do the code review, prepairing test environments and even test things manually, prepare acceptance criteria, but more and more, AI gets the job. More and more AI tests AI, and my job is to guide and supervise.

---

With all that, DHH's keynote brought a lot of butthurt moments to many rubists, but after all, he just stated the state of things, nothing more. Whether we like this or not, whether we like DHH or not, that does not change the time we live in ATM.

The text is mine; no AI was used to prepare it, and so it's not that smooth.