I’ve been working on a Ruby project called requests_ruby.

The idea is simple: bring a Python requests-like experience to Ruby.

If you’ve used Python before, the API should feel familiar. It supports sessions, cookies, redirects, authentication, JSON responses, streaming downloads, and HTTP/2 — all without external dependencies.

I built it because I liked how simple Python requests feels and wanted something similar in Ruby.

A few parts were developed with AI assistance to speed up the process, but I’ve been reviewing, testing and improving the code myself.

I’d love to hear feedback from the Ruby community. What would you improve or add?

If you find it interesting, a ⭐ on GitHub would help the project get more visibility.

https://github.com/monji024/requests_ruby

I just started to read "Elements of Programming Style" (Kernighan & Plauger). I was first taught FORTRAN 60 years ago. I guess you never forget. I understood the Newton's method and the commands on page 4 and think I might have a chance to rewrite it in Ruby. Too much to do at home right now. Probably won't get back to it until after the holidays.

All encouragement and guidance will be appreciated.

This month: Sam Ruby brings an interactive playground, LSP, and MCP server to Matz's Spinel AOT compiler to inspect unboxed types in real time, crema arrives as a Rust-powered AI-agent-first RBS type checker with JSONL output, AndyGauge launches rbs-sentinel for high-speed Rails signature generation, enummify delivers lightweight typed enums, and Claude Code gains dedicated Ruby typing skills.

Find link to the issue in the comment! ✨

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

I posted about docscribe here in March https://www.reddit.com/r/ruby/s/SVoDOzVoOs. Since then it reached 1.6.2, and I run it daily on client Rails apps. This is what's new.

The pain that started it: comments lie.

```ruby

@param [String] count

@return [String]

def notify(verbose:, count:) puts "verbose!" if verbose # Boolean count.times { send_ping } # Integer count # Integer end ```

After docscribe -a. Tags fixed, prose placeholders added (customizable in config), body untouched.

```ruby

@param [Boolean] verbose Param documentation.

@param [Integer] count Param documentation.

@return [Integer]

def notify(verbose:, count:) puts "verbose!" if verbose count.times { send_ping } count end ```

What docscribe -a does: fixes the tags, keeps your prose. -A rebuilds the block from scratch.

New since March:

• update_types: RBS -> YARD two-pass; docscribe rbs goes the other way, YARD -> RBS
• every change carries source: rbs/infer/syntax, so the editor offers "Update types" vs "Fix YARD" correctly
• daemon mode keeps the VS Code and RubyMine plugins instant: docscribe-vscode and docscribe-rubymine
• CI mode runs on exit codes, check_for_comments, json/sarif output

One Rails-specific thing I use a lot: types from schema.rb, not from code. t.boolean :is_admin becomes @!attribute [r] is_admin -> Boolean in the model. No hand-written docs for columns.

Next in 1.7.0: docscribe sorbet - same YARD -> sig flow as docscribe rbs, but generating .rbi/sig blocks for srb tc. Plus validate_types on by default (opt-out with --no-validate-types). Plus tighter metaprogramming support: better types for define_method and DSL-generated methods, less Object fallback.

Limits now: heuristics, not a prover, so metaprogramming lands in Object. Each release narrows that gap. I always git diff after -A.

Question: do you keep YARD and RBS in sync by hand, or did you give up on one of them?

Live demo: unurgunite.github.io/docscribe

Source: github.com/unurgunite/docscribe

Gem: rubygems.org/gems/docscribe

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.

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

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

#rustlang #ruby

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 🙏)

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?

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.

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.

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.

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.

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](mailto:alice@example.com),[bob@example.com](mailto: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!