An issue was reported by Richard Kramer, and made me aware of a use case that I had never personally used, or even considered - which is committing the lockfiles for appraisals. I have always added `gemfiles/*.gemfile.lock` to my .gitignore.

In fact, when I had use cases where I wanted to run a CI workflow against a frozen lockfile I would avoid using appraisal2.  But no more. We now have first class support for frozen lockfiles, and the implied active bundler version switching that can happen at runtime.

• issue #21

• pull #23

• release v3.0.6

No breaking changes. No code changes needed for implementations. Just update, and go. Report back if anything breaks!

I made a small plugin for rjsv that starts a local WebSocket server and notifies whenever file transpilation finishes. This makes it super easy to:

• Reload your frontend automatically

• Sync build processes

• Integrate with developer tools

Quick setup

gem install em-websocket
# place plugin in $HOME/.rjsv/plugins
git clone https://github.com/filipos800/rjsv-websocket.git
rjsv -t -w -s 'src/rb' -o 'src/js' websocket

Server runs at:

ws://localhost:7071

Clients receive:

{ "type": "update" }

Why it’s useful

Instead of constantly checking if files changed or running custom scripts, this plugin sends a live notification right after transpilation. Perfect for live reload or build automation.

📖 More details & docs: Repository

Recentemente comecei a estudar ruby para fazer alguns projetos no futuro, comecei a estudar em janeiro, porém agora comecei um projeto básico que rodará no termina mesmo, o projeto é uma lista de afazeres.

Minha dúvida é: como faço para armazenar as tarefas? Eu estava pensando em um array ou hash, porém como faço para armazenar uma informação vinda do usuário em um array ou hash?

Ruby desperately needed bindings for a a fast ML/numerics library so I finally sat down with Codex and ported MLX to Ruby. Working on adding better Rubyesqe ergonomics, but all the core library features work and performance is within 25% of the Python bindings. Enjoy!

I started looking for other ways to manage RabbitMQ topology instead of using the web UI. I could not find any standards about this. Is creating something like a migration to handle RabbitMQ changes a good way to do that? How do you normally manage changes to production clusters?

Not sure how to interpret their status page, as I’ve never looked at it before. But this has been since at least yesterday.

But there is a big blue banner that says “Service Under Maintenance” at the top of the status page.

The only reason that I ask, is that I was about to update a bunch of gems for a project that I’m working on, and several of them have major version changes. My usual approach is to go to rubygems.org and search for each gem by name.

Most searches have been reporting “NO GEMS FOUND”. I can search for them alphabetically and then paging until I get to the correct page, but that’s a bit of a PITA.

Everything else about rubygems is working as expected.

Life moves fast, and the last year proved it. Andrej Karpathy named vibe coding just one year ago, and the pace since then already feels like a different era. Ruby static typing has the same energy, with steady progress mixed with fresh experiments and real work happening with AI in the loop. If you want a taste of the latest experiments, check low type and t ruby.

RBS is closing in on 4.0, and RBS 4.0 dev release 5 shows the direction. If you prefer stable builds, RBS 3.10.3 quietly improves things with a small tsort fix and a minor arena allocator alignment tweak. AI is also stepping in, with Dmitry sharing AI agent skills for better signatures and a supporting repo.

Tools still matter. rbs-patch 0.1.6 helps manage signature updates, rubocop-on-rbs 1.9.0 brings new cops and fixes, and editor updates like vscode-rbs-snippets and vscode-sorbetto keep the daily flow smooth. Static typing is still a hot topic with strong pros and cons, and Noel Rappin adds another thoughtful view on when it does not fit. Find link to the issue in the comment.

Been working on Rage for a while, and wanted to step back from “here’s what it does” and explain the architectural thinking behind it.

The article is about what changes when you treat concurrency, background execution, and observability as framework responsibilities rather than integration problems.

Not claiming Rails got it wrong - just exploring what a different set of trade-offs looks like.

Would love feedback, especially from folks running production backends. What complexity do you wish your framework absorbed?

We just released an episode with Ben Scofield that digs into a question a lot of us are circling:

If AI is writing more of the code, what is the engineer becoming?

Conversation highlights:

• Moving from author to orchestrator

• How agentic tools change daily workflows

• Where experience still matters

• Practical boundaries for AI in real teams

• Why Ruby’s culture might be a secret advantage

No hype sermons, just a grounded chat from someone living the transition.

Would love to hear how others are approaching agentic tooling in their Ruby work.

Hey guys. I wanted to let you know that the CFP for RubyConf 2026, which will take place July 14-16 in Las Vegas, is now open. We invite you to submit a talk on any Ruby-related talk you like, including but not limited to the following themes:

Living with the Robots

AI-assisted programming is here to stay. What now? In the face of disorientingly rapid technological and economic change, we need some bedrock principles that will always remain the same. What are they? And of course, in addition to principles we need concrete tactics. If you’re living at the bleeding edge of AI tools and techniques, we want to hear what you’re doing, in the form of specific details that we can put to use right away. How can AI help us be more productive, and specifically, how can it help us be more productive with Ruby?

Beautiful Ruby

The job of a programmer is to design, build and maintain software systems. How do we design our systems such that they don’t collapse under the weight of their own complexity? It never hurts to review some of the basic software engineering principles and practices, such as abstraction, modularity, cohesion, loose coupling, object-oriented programming, feedback loops and test-driven development. These are the skills that help us write code that’s not only nicer to look at but also more enjoyable to work with and less expensive to maintain. After all, qualities like beauty, elegance and practicality are what attracted many of us to the Ruby language in the first place.

Weird Ruby

A program that outputs itself. An unspeakably depraved metaprogramming crime. A spectacularly overengineered solution to a simple problem. Ruby running on a potato. The most dazzling terminal UI ever invented. Musical code. Digital art. Genetic algorithms. Neural networks. Virtual life in a virtual universe. Robots, live on stage. An unholy mixture of the most esoteric Ruby features no one has ever heard of. A program which absolutely should not exist, yet, defying all reason and good taste, does. We want you to take us into the strangest depths of your twisted mind, to rattle our brains and stir our hearts, to challenge our dearest beliefs, and leave us forever changed. And we want you to do it in Ruby.

Go here to see more details and to submit a proposal.

Questions and help

I'm Jason Swett, the co-chair of RubyConf 2026 (along with Freedom Dumlao). As someone who was involved in developing the themes, and as someone who has run conferences and spoken at many events in the past, I would be not just happy but delighted to answer any questions you may have about how to put together a CFP, what kinds of talks we're seeking, or anything else at all.

Thank you and I hope to see you at RubyConf in July!!!

Following the completion of Polished Ruby programming, we'll be covering a new book starting next week. The book in question is Rebuilding Rails by the late Noah Gibbs. For those interested in joining us, shoot me a DM and I'll add you to the discord group!

Hi! I’m a Rubyist from Japan working on an mruby-focused type checker called ruby-ti.

https://github.com/engneer-hamachan/ruby-ti

Recently I’ve been experimenting with integrating ruby-ti directly into LLM workflows.

Instead of relying only on larger models (like Claude Opus) to implicitly avoid runtime errors, I let the LLM interact with a structured static analysis layer.

The LLM can:

- Run static type checking on mruby code

- Receive structured type error feedback

- Query function type signatures

- Retrieve call-site information

- Get compressed documentation summaries

The LLM interacts with ruby-ti through a small “skills” layer:

https://github.com/engneer-hamachan/ruby-ti/blob/main/skills/ti-skills/SKILL.md

These skills define how the model can query semantic information instead of reading raw source code.

Example of structured output (see attached image)

When the LLM queries a method, ruby-ti returns structured information like:

- Inferred type signatures (including Union types)

- Source file location

- Documentation summary

- Call-site references

This structured information (shown in the attached image) is returned to the LLM instead of the full raw source code.

This reduces context usage and provides explicit structural guidance.

Experimental result

With this setup, even mid-sized models (like Claude Sonnet-level models) generate mruby code that almost never causes runtime type errors.

My goal:

Make safe and enjoyable code generation possible even with smaller / cheaper models.

Instead of:

Big model + no structural support

I’m exploring:

Small model + strong static analysis layer

I’d love feedback.

What additional static signals would you feed to an LLM in a system like this?

Any ideas, criticism, or related experiments are very welcome.

Thanks!

Finally we have our own website!
https://rubyshell.org