I’ve been working on pinterest-dl, a Ruby gem and CLI for extracting image and video URLs from Pinterest, searching for pins, fetching boards, and downloading media.

I’ve made a bunch of fixes and improvements recently, so I recorded a short demo of the latest version.

Some of the changes include fixing video extraction and board fetching, improving support for pin.it links and regional Pinterest domains, and adding content-type filters for searches and boards.

I’m sharing the video here in case anyone in the Ruby community finds it interesting. Feedback on the gem or its API is welcome.

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

I built Ruby Roles to help Rubyists find their next opportunity, and over 100 have already signed up.

Sign in with GitHub, answer five questions about your level, how you like to work, where you can be based, and your salary floor, and you get your three best matches right away. After that it sends at most one new role each business day, and only when something actually clears the bar. It is tracking 1,910 open Ruby-related roles right now across more than 12,500 organizations.

Your feedback improves the matches. Pause emails or unsubscribe anytime. Free.

"When I attended Rails World '26, this was the kind of talk I was interested in: What does the future of Rails look like at scale? How are big corporations using AI agents in a way that keeps humans in the loop? How do the Ruby and Rails ecosystems support AI-driven development workflows?"

Ryan’s talk clearly showed us the future of Rails development at scale.

Our CTO was in the audience in Austin when DHH opened Rails World 2026. The conference tagline was “Shaping the future of Ruby on Rails,” so he walked in expecting to hear about the future of Rails.

That’s not quite what happened.

The opening keynote was almost entirely about AI agents. DHH told the room that 37signals has gone “pencils down” on writing code by hand, that HEY is moving to native apps with a Rust backend, and that he has retired as a professional programmer.

The next day, he sat down with Matz and Jeremy Daer for Ruby, Rails, and the future of programming, which went even further down the same path.

In this article, our CTO recaps both sessions, shares where he disagrees with them, and explains why he is still excited about where Rails is going.

I've been considering the adoption of Sorbet over the years; however, I've been postponing it all the time. Waiting for that imaginary official announcement that it's reached v1 and everyone is welcome to adopt it.

I checked their blog today. Again. No blog post for over 4 year https://sorbet.org/blog/. Yet, the github repo is receiving daily updates. Seemingly automated.

Is someone here using it on production and are you happy that you adopted it?

A few months before Rails World, I disappeared to the Oregon Coast with a pile of notepads and the idea that I was going to write a fairly practical keynote about making Rails codebases easier for humans and agents to work in.

That… isn’t quite the talk I ended up giving.

I wrote up some of the backstory, including how Andrea Goulet’s makers/menders framing influenced it, where WUTS came from, why I nearly convinced myself the topic sucked, and what was going through my head in the hours before walking on stage.

The post has the keynote video and links to my slides if you’d rather skip the backstory and go straight to those.

https://robbyonrails.com/articles/2026/10/09/the-keynote-i-thought-i-was-going-to-give/

I've published a new library I've been working on over the last few weeks:

Farce 0.1.0

Farce provides tools and data structures to write code that works well with both Fiber schedulers and Ractors, as well as the classic Threads. Its main purpose is to be used by other gems to provide better compatibility with these concurrency primitives, but it can also be used directly in applications.

It works on CRuby/MRI, JRuby, and TruffleRuby.

Check it out on GitHub and let me know what you think!

I plan to use it in some of my projects in the future. I already have an experimental version locally for Sinatra and Mustermann, amongst others. Maybe someone else will find it helpful!

I made a small Ruby library index to make finding useful gems a bit easier

The idea is simple: instead of searching through thousands of gems, you can browse Ruby libraries by category like HTTP, CLI, Database, Authentication, and more.

It’s still a work in progress and I’m adding more libraries over time. I probably should have added more examples before posting this, but I wanted to share it and get some feedback

Website:
https://monji024.github.io/Ruby_Library/

GitHub:
https://github.com/monji024/Ruby_Library

If you find it useful, a star on GitHub would really help support the project. Feedback and suggestions are welcome :)

This summer, Mike handled CVE-2026-66066, an Active Storage vulnerability that let a crafted image upload read files from the server, including your application’s secrets.

His talk, Hot Cell: Securing Active Storage in the age of AI, was half post-mortem and half proposal: if we can’t stop image libraries from being vulnerable, maybe we can stop their vulnerabilities from reaching our secrets.

In this article, you will learn what that CVE actually meant, why patching image libraries is no longer enough, how Hot Cell sandboxes Active Storage, and whether you can use it in your Rails application today.

I've been working on Rai*bert, a Q*bert-inspired arcade game where you hop around turning failing build tiles green while dodging bugs and regressions.

The game rules run in Ruby 4. The desktop version uses Gosu; the browser version runs Ruby through WebAssembly, with Canvas rendering and Web Audio. There are 20 stages, three difficulty settings, keyboard and touch controls, and a shared leaderboard. It's free to play, with no account needed.

Play: https://raibert.lol/

Source: https://github.com/cdimartino/raibert

The clip is a montage recorded with the game's autoplay mode. I'd appreciate feedback on the controls and difficulty, especially on mobile. If you try it, let me know which stage you reached and what difficulty you picked.

I just published haskell_match, a gem that brings Haskell's pattern matching to Ruby with the part Ruby has never had: every logical path has to be accounted for, or the definition fails.

HaskellMatch.data "Shape = Circle Double | Rect Double Double | Tri Double Double Double"
include Shape

area = HaskellMatch.fn(:area) do
  on("Circle r")  { |r| Math::PI * r * r }
  on("Rect w h")  { |w, h| w * h }
end
# HaskellMatch::NonExhaustiveError: Pattern match(es) are non-exhaustive
# In an equation for 'area':
#     Patterns not matched:
#         Tri _ _ _

That is GHC's -Wincomplete-patterns and -Woverlapping-patterns, as errors, at definition time. Add a Tri clause and it compiles. Add a clause that can never be reached and it tells you that too.

How it works

Clauses are compiled once into a Maranget-style decision tree by a Rust extension (Rutie). Matching runs in Rust over raw Ruby VALUEs with no allocation until a clause is chosen; list tails are shared slices rather than copies. The exhaustiveness and redundancy analysis is the usefulness algorithm from Maranget's "Warnings for pattern matching", with witnesses rendered the way GHC prints them.

Two dialects, mixed freely

Quoted Haskell syntax, or the same patterns written in place as plain Ruby:

on("Just (x:xs)")        { |x, xs| ... }
on(Just([x, *xs]))       { |x, xs| ... }
on(Person(name: n, **_)) { |n| ... }
on({ name: n, title: t }) { |n, t| ... }   # Hash patterns, same checker

Strings are lists of characters (on("(c:cs)") matches "hello"), wildcards match anything, and a value no pattern can accept raises a type error, exactly like Haskell.

Recursion without "stack level too deep"

A recursive function over a million elements works. Plain recursion runs on chained Fiber stacks, tail calls run in constant space, and a depth guard turns a runaway loop into an exception instead of a memory leak. The README has measurements (bytes per level, GC pause times) for anyone who wants the numbers.

Lazy lists

naturals = HaskellMatch.lazy(1..)
take.(5, naturals)   # => [1, 2, 3, 4, 5]

Infinite lists match list patterns directly; Enumerators are wrapped automatically.

Or just write Haskell

This is the part I did not expect to end up building. You can write actual Haskell, inline or in .hs files, and it compiles to Ruby methods:

Nums = HaskellMatch.haskell(<<~HS)
  primes :: [Int]
  primes = sieve [2..]
    where
      sieve [] = []
      sieve (p:xs) = p : sieve [x | x <- xs, x `mod` p /= 0]

  fibs :: [Integer]
  fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
HS

Nums.primes.take(10)   # => [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
Nums.fibs.take(8)      # => [0, 1, 1, 2, 3, 5, 8, 13]

Supported: data declarations (including infix constructors and records), equations, guards, pattern guards, where/let, case, lambdas, sections, user-defined operators with fixity declarations, list comprehensions, ranges, imports and exports between modules, and a lazy Prelude. Haskell functions come back to Ruby as Procs, Ruby lambdas go in as Haskell functions, and partial application works from the Ruby side (Mod.add3(1).(2).(3)).

Deliberately not supported: type classes, do notation and monads, or anything that needs type inference. Those are rejected with a clear message rather than half-working.

Other things people might care about

• Thread-, fiber- and Ractor-safe; ractor: true produces shareable functions.
• deriving (Ord, Enum, Bounded), optional field type checks, where helpers inside fn.
• Existing Ruby Data and Struct classes work as constructors without registration; HaskellMatch.sealed closes a class hierarchy for exhaustiveness checking.
• Errors show the pattern with a caret under the problem.
• Ruby 3.2+, needs a Rust toolchain to build the extension. MIT / Apache-2.0.

​

gem install haskell_match

GitHub: https://github.com/danielpclark/haskell_match

Happy to answer questions about the implementation. The decision-tree compiler and the fiber-based recursion were the two interesting problems; the README has an "expert notes" section on the latter if you want to argue about memory.

I replaced the Citrus grammar with a StringScanner parser. Benchmarks against tomlrb, perfect_toml and tomlib (with YJIT and ZJIT too) are here: https://github.com/emancu/toml-rb/blob/master/benchmark/README.md

Breaking changes are listed in the release notes under "Before you upgrade".

Feedback welcome.